[people/ms/pakfire.git] / src / libpakfire / xfer.c

/*#############################################################################
#                                                                             #
# Pakfire - The IPFire package management system                              #
# Copyright (C) 2023 Pakfire development team                                 #
#                                                                             #
# This program is free software: you can redistribute it and/or modify        #
# it under the terms of the GNU General Public License as published by        #
# the Free Software Foundation, either version 3 of the License, or           #
# (at your option) any later version.                                         #
#                                                                             #
# This program is distributed in the hope that it will be useful,             #
# but WITHOUT ANY WARRANTY; without even the implied warranty of              #
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               #
# GNU General Public License for more details.                                #
#                                                                             #
# You should have received a copy of the GNU General Public License           #
# along with this program.  If not, see <http://www.gnu.org/licenses/>.       #
#                                                                             #
#############################################################################*/

#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <sys/queue.h>

#include <curl/curl.h>

#include <json.h>

#include <openssl/err.h>
#include <openssl/evp.h>

#include <pakfire/ctx.h>
#include <pakfire/mirrorlist.h>
#include <pakfire/path.h>
#include <pakfire/progress.h>
#include <pakfire/string.h>
#include <pakfire/util.h>
#include <pakfire/xfer.h>

struct pakfire_xfer {
	struct pakfire_ctx* ctx;
	int nrefs;

	// Reference to the HTTP client
	struct pakfire_httpclient* client;

	// Reference to the progress indicator
	struct pakfire_progress* progress;

	// cURL handle
	CURL* handle;

	// Headers
	struct curl_slist* headers;

	// URL
	CURLU* fullurl;

	char url[PATH_MAX];
	char title[NAME_MAX];
	char path[PATH_MAX];
	int tries;

	// POST MIME Object
	curl_mime* mime;

	// Xfer direction
	enum {
		PAKFIRE_XFER_DOWNLOAD = 0,
		PAKFIRE_XFER_UPLOAD   = 1,
	} direction;

	// Size
	size_t expected_size;
	size_t xferred;

	// File handles for streams
	FILE* fin;
	FILE* fout;

	// Crypto Stuff
	EVP_MD_CTX* evp;
	const EVP_MD* md;
	unsigned char computed_digest[EVP_MAX_MD_SIZE];
	unsigned int computed_digest_length;
	unsigned char expected_digest[EVP_MAX_MD_SIZE];
	unsigned int expected_digest_length;

	// Mirrors
	char baseurl[PATH_MAX];
	struct pakfire_mirrorlist* mirrors;
	struct pakfire_mirror* mirror;

	// Effective URL
	const char* effective_url;

	// Authentication
	unsigned int auth;

	// Space for cURL error message
	char error[CURL_ERROR_SIZE];
};

static void pakfire_xfer_free(struct pakfire_xfer* xfer) {
	// Close any streams
	if (xfer->fin)
		fclose(xfer->fin);

	// Free OpenSSL EVP context
	if (xfer->evp)
		EVP_MD_CTX_free(xfer->evp);

	// cURL stuff
	if (xfer->handle)
		curl_easy_cleanup(xfer->handle);
	if (xfer->headers)
		curl_slist_free_all(xfer->headers);
	if (xfer->mime)
		curl_mime_free(xfer->mime);
	if (xfer->fullurl)
		curl_url_cleanup(xfer->fullurl);

	if (xfer->mirror)
		pakfire_mirror_unref(xfer->mirror);
	if (xfer->mirrors)
		pakfire_mirrorlist_unref(xfer->mirrors);
	if (xfer->progress)
		pakfire_progress_unref(xfer->progress);
	if (xfer->client)
		pakfire_httpclient_unref(xfer->client);
	if (xfer->ctx)
		pakfire_ctx_unref(xfer->ctx);

	free(xfer);
}

#ifdef ENABLE_DEBUG
static int pakfire_xfer_debug_callback(CURL *handle, curl_infotype type,
		char* data, size_t size, void* private) {
	struct pakfire_ctx* ctx = private;

	switch (type) {
		case CURLINFO_TEXT:
			CTX_DEBUG(ctx, "cURL: %.*s", (int)size, data);
			break;

		// Log headers
		case CURLINFO_HEADER_IN:
			CTX_DEBUG(ctx, "cURL: < %.*s", (int)size, data);
			break;

		case CURLINFO_HEADER_OUT:
			CTX_DEBUG(ctx, "cURL: > %.*s", (int)size, data);
			break;

		// Ignore everything else
		default:
			break;
	}

	return 0;
}
#endif

static size_t pakfire_xfer_read(char* data, size_t size, size_t nmemb, void* p) {
	struct pakfire_xfer* xfer = p;

	return fread(data, size, nmemb, xfer->fout);
}

static int pakfire_xfer_seek(void* p, curl_off_t offset, int origin) {
	struct pakfire_xfer* xfer = p;
	int r;

	// Perform the seek
	r = fseek(xfer->fout, (long)offset, origin);
	if (r < 0)
		return CURL_SEEKFUNC_CANTSEEK;

	return CURL_SEEKFUNC_OK;
}

static size_t pakfire_xfer_write(
		char* data, size_t size, size_t nmemb, void* p) {
	struct pakfire_xfer* xfer = p;
	struct pakfire_ctx* ctx = xfer->ctx;
	int r;

	// Do not write empty blocks
	if (!nmemb)
		return nmemb;

	// Update message digest
	if (xfer->evp) {
		r = EVP_DigestUpdate(xfer->evp, data, nmemb);
		if (r != 1) {
			CTX_ERROR(ctx, "EVP_DigestUpdate failed: %s\n",
				ERR_error_string(ERR_get_error(), NULL));
			return 0;
		}
	}

	// If there is no output steam, we just pretent that we have consumed the data
	if (!xfer->fin)
		return nmemb;

	// Write everything to the allocated file descriptor
	return fwrite(data, size, nmemb, xfer->fin);
}

static int pakfire_xfer_setup(struct pakfire_xfer* xfer) {
	struct pakfire_config* config = NULL;
	const char* proxy = NULL;
	int r;

	CURLSH* share = pakfire_httpclient_share(xfer->client);

	// Configure the share handle
	r = curl_easy_setopt(xfer->handle, CURLOPT_SHARE, share);
	if (r) {
		CTX_ERROR(xfer->ctx, "Could not configure cURL share handle: %s\n",
			curl_easy_strerror(r));
		return r;
	}

	// Fetch global configuration
	config = pakfire_ctx_get_config(xfer->ctx);

	// Set global configuration
	if (config) {
		proxy = pakfire_config_get(config, "general", "proxy", NULL);
		if (proxy)
			curl_easy_setopt(xfer->handle, CURLOPT_PROXY, proxy);
	}

	// Be a good net citizen and set a user agent
	curl_easy_setopt(xfer->handle, CURLOPT_USERAGENT, PACKAGE_NAME "/" PACKAGE_VERSION);

#ifdef ENABLE_DEBUG
	// Enable logging/debugging
	curl_easy_setopt(xfer->handle, CURLOPT_VERBOSE, 1L);

	curl_easy_setopt(xfer->handle, CURLOPT_DEBUGFUNCTION, pakfire_xfer_debug_callback);
	curl_easy_setopt(xfer->handle, CURLOPT_DEBUGDATA, xfer->ctx);
#endif

	// Set error buffer
	r = curl_easy_setopt(xfer->handle, CURLOPT_ERRORBUFFER, xfer->error);
	if (r)
		goto ERROR;

	// Limit protocols to HTTPS, HTTP, FTP and FILE
	curl_easy_setopt(xfer->handle, CURLOPT_PROTOCOLS_STR, "HTTPS,HTTP,FTP,FILE");

	// Raise any HTTP errors
	r = curl_easy_setopt(xfer->handle, CURLOPT_FAILONERROR, 1L);
	if (r)
		goto ERROR;

	// Allow all support encodings
	curl_easy_setopt(xfer->handle, CURLOPT_ACCEPT_ENCODING, "");

	// Reference back to this xfer
	curl_easy_setopt(xfer->handle, CURLOPT_PRIVATE, xfer);

	// Follow any redirects
	curl_easy_setopt(xfer->handle, CURLOPT_FOLLOWLOCATION, 1);

	// Only follow up to 30 redirects
	curl_easy_setopt(xfer->handle, CURLOPT_MAXREDIRS, 30L);

	// Read any data from a callback function
	curl_easy_setopt(xfer->handle,
		CURLOPT_READFUNCTION, pakfire_xfer_read);
	curl_easy_setopt(xfer->handle, CURLOPT_READDATA, xfer);

	// Write all data to the callback function
	curl_easy_setopt(xfer->handle,
		CURLOPT_WRITEFUNCTION, pakfire_xfer_write);
	curl_easy_setopt(xfer->handle, CURLOPT_WRITEDATA, xfer);

	// Register the seek callback
	curl_easy_setopt(xfer->handle,
		CURLOPT_SEEKFUNCTION, pakfire_xfer_seek);
	curl_easy_setopt(xfer->handle, CURLOPT_SEEKDATA, xfer);

	// Success
	r = 0;

ERROR:
	if (config)
		pakfire_config_unref(config);

	return r;
}

int pakfire_xfer_create(struct pakfire_xfer** xfer, struct pakfire_ctx* ctx,
			struct pakfire_httpclient* client, const char* url) {
	struct pakfire_xfer* x = NULL;
	int r;

	// Allocate a new xfer
	x = calloc(1, sizeof(*x));
	if (!x)
		return -errno;

	// Store a reference to the context
	x->ctx = pakfire_ctx_ref(ctx);

	// Initialize the reference counter
	x->nrefs = 1;

	// Store a reference to the HTTP client
	x->client = pakfire_httpclient_ref(client);

	// Store the URL
	r = pakfire_string_set(x->url, url);
	if (r)
		goto ERROR;

	// Allocate a handle
	x->handle = curl_easy_init();
	if (!x->handle) {
		r = 1;
		goto ERROR;
	}

	// Allocate the full URL
	x->fullurl = curl_url();
	if (!x->fullurl) {
		r = -errno;
		goto ERROR;
	}

	// Setup the xfer
	r = pakfire_xfer_setup(x);
	if (r)
		goto ERROR;

	// Return the reference
	*xfer = x;

	return 0;

ERROR:
	if (x)
		pakfire_xfer_unref(x);

	return r;
}

struct pakfire_xfer* pakfire_xfer_ref(struct pakfire_xfer* xfer) {
	++xfer->nrefs;

	return xfer;
}

struct pakfire_xfer* pakfire_xfer_unref(struct pakfire_xfer* xfer) {
	if (--xfer->nrefs > 0)
		return xfer;

	pakfire_xfer_free(xfer);
	return NULL;
}

CURL* pakfire_xfer_handle(struct pakfire_xfer* xfer) {
	return xfer->handle;
}

int pakfire_xfer_set_method(struct pakfire_xfer* xfer,
		const pakfire_xfer_method_t method) {
	const char* m = NULL;

	switch (method) {
		case PAKFIRE_METHOD_DELETE:
			m = "DELETE";
			break;

		default:
			return -EINVAL;
	}

	return curl_easy_setopt(xfer->handle, CURLOPT_CUSTOMREQUEST, m);
}


const char* pakfire_xfer_get_title(struct pakfire_xfer* xfer) {
	char title[PATH_MAX];
	int r;

	// Default to the filename if no title is set
	if (!*xfer->title) {
		// Only use the basename
		r = pakfire_path_basename(title, xfer->url);
		if (r)
			return NULL;

		// Store the title
		r = pakfire_xfer_set_title(xfer, title);
		if (r)
			return NULL;
	}

	return xfer->title;
}

int pakfire_xfer_set_title(struct pakfire_xfer* xfer, const char* title) {
	return pakfire_string_set(xfer->title, title);
}

int pakfire_xfer_set_baseurl(struct pakfire_xfer* xfer, const char* baseurl) {
	return pakfire_string_set(xfer->baseurl, baseurl);
}

const char* pakfire_xfer_get_effective_url(struct pakfire_xfer* xfer) {
	return xfer->effective_url;
}

int pakfire_xfer_set_mirrorlist(struct pakfire_xfer* xfer, struct pakfire_mirrorlist* mirrors) {
	if (xfer->mirrors)
		pakfire_mirrorlist_unref(xfer->mirrors);

	xfer->mirrors = pakfire_mirrorlist_ref(mirrors);

	return 0;
}

// Size

size_t pakfire_xfer_get_size(struct pakfire_xfer* xfer) {
	return xfer->expected_size;
}

int pakfire_xfer_set_size(struct pakfire_xfer* xfer, size_t size) {
	xfer->expected_size = size;

	return 0;
}

int pakfire_xfer_verify_digest(struct pakfire_xfer* xfer, const enum pakfire_digest_types md,
		const unsigned char* expected_digest, const size_t expected_digest_length) {
	// Check inputs
	if (!expected_digest || !expected_digest_length)
		return -EINVAL;

	// Expected digest length cannot be too long
	if (expected_digest_length > sizeof(xfer->expected_digest))
		return -ENOBUFS;

	// Store digest type
	switch (md) {
		case PAKFIRE_DIGEST_SHA3_512:
			xfer->md = EVP_sha3_512();
			break;

		case PAKFIRE_DIGEST_SHA3_256:
			xfer->md = EVP_sha3_256();
			break;

		case PAKFIRE_DIGEST_BLAKE2B512:
			xfer->md = EVP_blake2b512();
			break;

		case PAKFIRE_DIGEST_BLAKE2S256:
			xfer->md = EVP_blake2s256();
			break;

		case PAKFIRE_DIGEST_SHA2_512:
			xfer->md = EVP_sha512();
			break;

		case PAKFIRE_DIGEST_SHA2_256:
			xfer->md = EVP_sha256();
			break;

		default:
			return -ENOTSUP;
	}

	// Store the expected digest and its length
	memcpy(xfer->expected_digest, expected_digest, expected_digest_length);
	xfer->expected_digest_length = expected_digest_length;

	return 0;
}

int pakfire_xfer_add_param(struct pakfire_xfer* xfer,
		const char* key, const char* format, ...) {
	curl_mimepart* part = NULL;
	char* buffer = NULL;
	va_list args;
	int r;

	// Allocate the MIME object if not done, yet
	if (!xfer->mime) {
		xfer->mime = curl_mime_init(xfer->handle);

		if (!xfer->mime) {
			CTX_ERROR(xfer->ctx, "Could not allocate the MIME object: %s\n",
				strerror(errno));
			r = -errno;
			goto ERROR;
		}
	}

	// Format value
	va_start(args, format);
	r = vasprintf(&buffer, format, args);
	va_end(args);

	// Abort if we could not format the value
	if (r < 0)
		goto ERROR;

	// Allocate another MIME part
	part = curl_mime_addpart(xfer->mime);
	if (!part) {
		CTX_ERROR(xfer->ctx, "Could not allocate MIME part: %s\n",
			strerror(errno));
		r = errno;
		goto ERROR;
	}

	// Set the key
	r = curl_mime_name(part, key);
	if (r) {
		CTX_ERROR(xfer->ctx, "Could not set parameter key (%s): %s\n",
			key, curl_easy_strerror(r));
		goto ERROR;
	}

	// Set the data
	r = curl_mime_data(part, buffer, CURL_ZERO_TERMINATED);
	if (r) {
		CTX_ERROR(xfer->ctx, "Could not set parameter data (%s): %s\n",
			key, curl_easy_strerror(r));
		goto ERROR;
	}

ERROR:
	if (buffer)
		free(buffer);

	return r;
}

static void pakfire_xfer_reset_output(struct pakfire_xfer* xfer) {
	if (xfer->fin) {
		fclose(xfer->fin);
		xfer->fin = NULL;
	}
}

int pakfire_xfer_set_output(struct pakfire_xfer* xfer, FILE* f) {
	pakfire_xfer_reset_output(xfer);

	// Store the new stream
	xfer->fin = f;

	return 0;
}

int pakfire_xfer_set_output_buffer(struct pakfire_xfer* xfer,
		char** buffer, size_t* length) {
	FILE* f = NULL;

	// Open a memory stream
	f = open_memstream(buffer, length);
	if (!f) {
		CTX_ERROR(xfer->ctx, "Could not open memory stream: %s\n", strerror(errno));
		return -errno;
	}

	return pakfire_xfer_set_output(xfer, f);
}

int pakfire_xfer_set_input(struct pakfire_xfer* xfer, FILE* f) {
	struct stat stat;
	int r;

	// Fetch the file descriptor
	const int fd = fileno(f);

	// Change direction
	xfer->direction = PAKFIRE_XFER_UPLOAD;

	// Store the file handle
	xfer->fout = f;

	// Try to find the upload size
	if (fd > 0) {
		r = fstat(fd, &stat);
		if (r)
			return 0;

		// Store the expected filesize
		xfer->expected_size = stat.st_size;
	}

	return 0;
}

static int pakfire_xfer_allocate_tmpfile(struct pakfire_xfer* xfer, const char* path) {
	char dirname[PATH_MAX];
	FILE* f = NULL;
	int fd = -1;
	int r;

	// Find the directory name
	r = pakfire_path_dirname(dirname, path);
	if (r)
		return r;

	// Ensure the directory exists
	r = pakfire_mkdir(dirname, 0755);
	if (r)
		return r;

	// Open a new temporary file
	fd = open(dirname, O_TMPFILE|O_RDWR, 0600);
	if (fd < 0) {
		CTX_ERROR(xfer->ctx, "Could not open temporary file in %s: %s\n",
			dirname, strerror(errno));
		return -errno;
	}

	// Turn the file descriptor into a FILE handle
	f = fdopen(fd, "w+");
	if (!f)
		return -errno;

	// Set the handle as output
	return pakfire_xfer_set_output(xfer, f);
}

int pakfire_xfer_set_output_path(struct pakfire_xfer* xfer, const char* path) {
	int r;

	// Store the output path
	r = pakfire_string_set(xfer->path, path);
	if (r)
		return r;

	// Allocate a temporary file
	r = pakfire_xfer_allocate_tmpfile(xfer, path);
	if (r)
		return r;

	return 0;
}

int pakfire_xfer_auth(struct pakfire_xfer* xfer) {
	// Enable authentication
	xfer->auth = 1;

	return 0;
}

static int pakfire_xfer_select_mirror(struct pakfire_xfer* xfer) {
	// Choose the next mirror
	if (xfer->mirror)
		xfer->mirror = pakfire_mirrorlist_get_next(xfer->mirrors, xfer->mirror);

	// If no mirror has been selected yet, choose the first one
	else
		xfer->mirror = pakfire_mirrorlist_get_first(xfer->mirrors);

	// Skip this mirror if it is broken
	while (xfer->mirror && pakfire_mirror_is_broken(xfer->mirror)) {
		// Move on to the next mirror
		xfer->mirror = pakfire_mirrorlist_get_next(xfer->mirrors, xfer->mirror);
	}

	// No mirror found
	if (!xfer->mirror) {
		CTX_ERROR(xfer->ctx, "No mirrors left to try\n");

		// No mirrors left
		return ENOENT;
	}

	CTX_DEBUG(xfer->ctx, "Selected mirror %s\n", pakfire_mirror_get_url(xfer->mirror));

	return 0;
}

static const char* curl_http_version(long v) {
	switch (v) {
#ifdef CURL_HTTP_VERSION_3_0
		case CURL_HTTP_VERSION_3_0:
			return "HTTP/3.0";
#endif

		case CURL_HTTP_VERSION_2_0:
			return "HTTP/2.0";

		case CURL_HTTP_VERSION_1_1:
			return "HTTP/1.1";

		case CURL_HTTP_VERSION_1_0:
			return "HTTP/1.0";
	}

	return "unknown";
}

static int pakfire_xfer_save(struct pakfire_xfer* xfer) {
	int r;

	// Flush any buffered data out to disk
	if (xfer->fin)
		fflush(xfer->fin);

	// Nothing to do if path isn't set
	if (!*xfer->path)
		return 0;

	CTX_DEBUG(xfer->ctx, "Download successful. Storing result in %s\n", xfer->path);

	int fd = fileno(xfer->fin);

	// Make sure the parent directory exists
	r = pakfire_mkparentdir(xfer->path, 0755);
	if (r)
		return r;

	// Unlink the destination file (if it exists)
	unlink(xfer->path);

	// Move the temporary file to its destination
	r = linkat(fd, "", AT_FDCWD, xfer->path, AT_EMPTY_PATH);
	if (r) {
		CTX_ERROR(xfer->ctx, "Could not link destination file %s: %m\n", xfer->path);
		return r;
	}

	return 0;
}

int pakfire_xfer_fail(struct pakfire_xfer* xfer, int code) {
	int r;

	CTX_DEBUG(xfer->ctx, "Xfer failed\n");

	// Throw away any downloaded data
	if (xfer->fin) {
		// Get file descriptor
		int fd = fileno(xfer->fin);

		// Truncate downloaded data
		if (fd >= 0) {
			r = ftruncate(fd, 0);
			if (r)
				return r;
		}

		// Rewind
		rewind(xfer->fin);
	}

	// Did we use a mirror?
	if (xfer->mirror) {
		pakfire_mirror_xfer_failed(xfer->mirror);

		// Try again with another mirror
		return EAGAIN;
	}

	return 0;
}

int pakfire_xfer_done(struct pakfire_xfer* xfer, int code) {
	CURL* h = xfer->handle;
	int r;
	char* scheme = NULL;
	long response_code;
	long http_version;
	double total_time;

	curl_off_t download_size = 0;
	curl_off_t download_speed = 0;
	curl_off_t upload_size = 0;
	curl_off_t upload_speed = 0;

	// Finish progress
	r = pakfire_progress_finish(xfer->progress);
	if (r)
		return r;

	CTX_DEBUG(xfer->ctx, "cURL xfer done: %d - %s\n",
		code, curl_easy_strerror(code));

	// Finish message digest computation
	if (xfer->evp) {
		r = EVP_DigestFinal_ex(xfer->evp, xfer->computed_digest, &xfer->computed_digest_length);
		if (r != 1) {
			CTX_ERROR(xfer->ctx, "Could not finish message digest computation: %s\n",
				ERR_error_string(ERR_get_error(), NULL));
			return 1;
		}
	}

	// Protocol
	curl_easy_getinfo(h, CURLINFO_SCHEME, &scheme);

	// Effective URL
	curl_easy_getinfo(h, CURLINFO_EFFECTIVE_URL, &xfer->effective_url);
	if (xfer->effective_url)
		CTX_DEBUG(xfer->ctx, "  Effective URL: %s\n", xfer->effective_url);

	// Response code
	curl_easy_getinfo(h, CURLINFO_RESPONSE_CODE, &response_code);
	if (response_code)
		CTX_DEBUG(xfer->ctx, "  Response code: %ld\n", response_code);

	// HTTP Version
	curl_easy_getinfo(h, CURLINFO_HTTP_VERSION, &http_version);
	if (http_version)
		CTX_DEBUG(xfer->ctx, "  HTTP Version: %s\n", curl_http_version(http_version));

	// Total Times
	curl_easy_getinfo(h, CURLINFO_TOTAL_TIME, &total_time);
	CTX_DEBUG(xfer->ctx, "  Total Time: %.2fs\n", total_time);

	// Download Size
	r = curl_easy_getinfo(h, CURLINFO_SIZE_DOWNLOAD_T, &download_size);
	if (r)
		return r;

	if (download_size)
		CTX_DEBUG(xfer->ctx, "  Download Size: %ld bytes\n", download_size);

	// Download Speed
	r = curl_easy_getinfo(h, CURLINFO_SPEED_DOWNLOAD_T, &download_speed);
	if (r)
		return r;

	if (download_speed)
		CTX_DEBUG(xfer->ctx, "  Download Speed: %ld bps\n", download_speed);

	// Upload Size
	r = curl_easy_getinfo(h, CURLINFO_SIZE_UPLOAD_T, &upload_size);
	if (r)
		return r;

	if (upload_size)
		CTX_DEBUG(xfer->ctx, "  Upload Size: %ld bytes\n", upload_size);

	// Upload Speed
	r = curl_easy_getinfo(h, CURLINFO_SPEED_UPLOAD_T, &upload_speed);
	if (r)
		return r;

	if (upload_speed)
		CTX_DEBUG(xfer->ctx, "  Upload Speed: %ld bps\n", upload_speed);

	// Message Digest
	char* hexdigest = __pakfire_hexlify(xfer->computed_digest, xfer->computed_digest_length);
	if (hexdigest && *hexdigest) {
		CTX_DEBUG(xfer->ctx, "  Message Digest: %s\n", hexdigest);
		free(hexdigest);
	}

	// Check if digests match
	if (xfer->evp) {
		r = CRYPTO_memcmp(xfer->computed_digest, xfer->expected_digest,
			xfer->computed_digest_length);

		// If they don't match, log an error and try again
		if (r) {
			char* computed_hexdigest = __pakfire_hexlify(xfer->computed_digest,
				xfer->computed_digest_length);
			char* expected_hexdigest = __pakfire_hexlify(xfer->expected_digest,
				xfer->expected_digest_length);

			CTX_ERROR(xfer->ctx, "Download checksum for %s didn't match:\n", xfer->effective_url);
			CTX_ERROR(xfer->ctx, "  Expected: %s\n", expected_hexdigest);
			CTX_ERROR(xfer->ctx, "  Computed: %s\n", computed_hexdigest);

			if (computed_hexdigest)
				free(computed_hexdigest);
			if (expected_hexdigest)
				free(expected_hexdigest);

			// Make this download fail
			r = pakfire_xfer_fail(xfer, 0);
			if (r)
				return r;

			return 1;
		}
	}

	// If we could not determine the scheme...
	if (!scheme)
		r = pakfire_xfer_fail(xfer, 0);

	// FILE
	else if (strcmp(scheme, "FILE") == 0) {
		// Handle any errors
		if (code)
			r = pakfire_xfer_fail(xfer, code);
		else
			r = pakfire_xfer_save(xfer);

		return r;

	// HTTPS + HTTP
	} else if ((strcmp(scheme, "HTTPS") == 0) || (strcmp(scheme, "HTTP") == 0)) {
		switch (response_code) {
			// 200 - OK
			case 200:
				r = pakfire_xfer_save(xfer);
				if (r)
					return r;
				break;

			// Treat all other response codes as an error
			default:
				r = pakfire_xfer_fail(xfer, code);
				if (r)
					return r;

				// Error
				return 1;
		}

	// FTP
	} else if (strcmp(scheme, "FTP") == 0) {
		if (response_code == 226)
			r = pakfire_xfer_save(xfer);
		else
			r = pakfire_xfer_fail(xfer, code);

		return r;
	}

	// Success
	return 0;
}

static int pakfire_xfer_update(void* data,
		curl_off_t dltotal, curl_off_t dlnow, curl_off_t ultotal, curl_off_t ulnow) {
	struct pakfire_xfer* xfer = data;

	switch (xfer->direction) {
		case PAKFIRE_XFER_DOWNLOAD:
			// Update the expected size
			xfer->expected_size = dltotal;

			// Update the xferred counter
			xfer->xferred = dlnow;
			break;

		case PAKFIRE_XFER_UPLOAD:
			// Update the expected size
			xfer->expected_size = ultotal;

			// Update the xferred counter
			xfer->xferred = ulnow;
			break;
	}

	// Do nothing if no progress indicator has been set up
	if (!xfer->progress)
		return 0;

	// Set maximum (because this might have changed)
	pakfire_progress_set_max_value(xfer->progress, xfer->expected_size);

	// Update current value
	return pakfire_progress_update(xfer->progress, xfer->xferred);
}

static int pakfire_xfer_prepare_progress(struct pakfire_xfer* xfer,
		struct pakfire_progress* parent, int flags) {
	const char* title = NULL;
	int progress_flags =
		PAKFIRE_PROGRESS_SHOW_PERCENTAGE |
		PAKFIRE_PROGRESS_SHOW_BYTES_TRANSFERRED |
		PAKFIRE_PROGRESS_SHOW_TRANSFER_SPEED |
		PAKFIRE_PROGRESS_SHOW_ETA;
	int r;

	// If this has already been set up, we skip it
	if (xfer->progress)
		return 0;

	// Show no progress if requested
	if (flags & PAKFIRE_XFER_NO_PROGRESS)
		progress_flags |= PAKFIRE_PROGRESS_NO_PROGRESS;

	// Show no progress if we have a parent progress
	else if (parent)
		progress_flags |= PAKFIRE_PROGRESS_NO_PROGRESS;

	// Make a new progress meter
	r = pakfire_progress_create(&xfer->progress, xfer->ctx, progress_flags, parent);
	if (r)
		return r;

	// Set the title
	title = pakfire_xfer_get_title(xfer);
	if (title) {
		r = pakfire_progress_set_title(xfer->progress, title);
		if (r)
			return r;
	}

	// Configure callbacks
	curl_easy_setopt(xfer->handle, CURLOPT_XFERINFOFUNCTION,
		pakfire_xfer_update);
	curl_easy_setopt(xfer->handle, CURLOPT_XFERINFODATA, xfer);
	curl_easy_setopt(xfer->handle, CURLOPT_NOPROGRESS, 0L);

	// Start progress
	r = pakfire_progress_start(xfer->progress, xfer->expected_size);
	if (r)
		return r;

	return 0;
}

static int pakfire_xfer_prepare_url(struct pakfire_xfer* xfer) {
	int r;

	// Simply set absolute URLs
	if (pakfire_string_is_url(xfer->url)) {
		r = curl_url_set(xfer->fullurl, CURLUPART_URL, xfer->url, 0);
		if (r)
			goto ERROR;

	// Join path if we are using mirrors
	} else if (xfer->mirrors && !pakfire_mirrorlist_empty(xfer->mirrors)) {
		r = pakfire_xfer_select_mirror(xfer);
		if (r)
			goto ERROR;

		// Set the mirror's base URL first
		r = curl_url_set(xfer->fullurl, CURLUPART_URL,
			pakfire_mirror_get_url(xfer->mirror), 0);
		if (r)
			goto ERROR;

		// Then append our own part
		r = curl_url_set(xfer->fullurl, CURLUPART_URL, xfer->url, 0);
		if (r)
			goto ERROR;

	// Use baseurl
	} else if (*xfer->baseurl) {
		// Set the base URL first
		r = curl_url_set(xfer->fullurl, CURLUPART_URL, xfer->baseurl, 0);
		if (r)
			goto ERROR;

		// Then append our own part
		r = curl_url_set(xfer->fullurl, CURLUPART_URL, xfer->url, 0);
		if (r)
			goto ERROR;

	// Fail if we could not set the URL
	} else {
		CTX_ERROR(xfer->ctx, "Invalid xfer %s\n", xfer->url);
		r = -EINVAL;
		goto ERROR;
	}

	// Set the URL
	r = curl_easy_setopt(xfer->handle, CURLOPT_CURLU, xfer->fullurl);
	if (r) {
		CTX_ERROR(xfer->ctx, "Could not set the URL: %s\n", curl_easy_strerror(r));
		goto ERROR;
	}

ERROR:
	return r;
}

int pakfire_xfer_prepare(struct pakfire_xfer* xfer, struct pakfire_progress* progress, int flags) {
	int r;

	// Increment tries
	xfer->tries++;

	// Set special options for direction
	switch (xfer->direction) {
		case PAKFIRE_XFER_DOWNLOAD:
			break;

		case PAKFIRE_XFER_UPLOAD:
			// Let cURL know that we are uploading things
			r = curl_easy_setopt(xfer->handle, CURLOPT_UPLOAD, 1L);
			if (r) {
				CTX_ERROR(xfer->ctx, "Could not enable upload\n");
				return r;
			}

			// Tell it the expected upload size
			if (xfer->expected_size) {
				r = curl_easy_setopt(xfer->handle,
					CURLOPT_INFILESIZE_LARGE, (curl_off_t)xfer->expected_size);
				if (r) {
					CTX_ERROR(xfer->ctx, "Could not set upload size\n");
					return r;
				}
			}

			// Upload files chunked
			xfer->headers = curl_slist_append(xfer->headers, "Transfer-Encoding: chunked");
			break;
	}

	// Compose the URL
	r = pakfire_xfer_prepare_url(xfer);
	if (r) {
		CTX_ERROR(xfer->ctx, "Could not compose URL: %m\n");
		return r;
	}

	// Add any headers
	if (xfer->headers) {
		r = curl_easy_setopt(xfer->handle, CURLOPT_HTTPHEADER, xfer->headers);
		if (r) {
			CTX_ERROR(xfer->ctx, "Could not set headers: %s\n", curl_easy_strerror(r));
			return r;
		}
	}

	// Add any payload
	if (xfer->mime) {
		r = curl_easy_setopt(xfer->handle, CURLOPT_MIMEPOST, xfer->mime);
		if (r) {
			CTX_ERROR(xfer->ctx, "Could not set POST payload: %s\n", curl_easy_strerror(r));
			return r;
		}
	}

	// Authentication
	if (xfer->auth) {
		// Request SPNEGO
		r = curl_easy_setopt(xfer->handle, CURLOPT_HTTPAUTH, CURLAUTH_NEGOTIATE|CURLAUTH_ONLY);
		if (r) {
			CTX_ERROR(xfer->ctx, "Could not enable SPNEGO\n");
			return r;
		}

		// Set an empty username
		r = curl_easy_setopt(xfer->handle, CURLOPT_USERPWD, ":");
		if (r) {
			CTX_ERROR(xfer->ctx, "Could not set username\n");
			return r;
		}
	}

	// Drop any previously used EVP contexts
	if (xfer->evp) {
		EVP_MD_CTX_free(xfer->evp);
		xfer->evp = NULL;
	}

	// Create a new EVP context
	if (xfer->md) {
		xfer->evp = EVP_MD_CTX_new();
		if (!xfer->evp) {
			CTX_ERROR(xfer->ctx, "Could not create EVP context: %m\n");
			return 1;
		}

		// Initialize the EVP context
		r = EVP_DigestInit_ex(xfer->evp, xfer->md, NULL);
		if (r != 1) {
			CTX_ERROR(xfer->ctx, "Could not initialize EVP context: %s\n",
				ERR_error_string(ERR_get_error(), NULL));
			return 1;
		}
	}

	// Setup progress
	r = pakfire_xfer_prepare_progress(xfer, progress, flags);
	if (r)
		return r;

	return 0;
}

int pakfire_xfer_run(struct pakfire_xfer* xfer, int flags) {
	int r;

AGAIN:
	// Prepare the xfer
	r = pakfire_xfer_prepare(xfer, NULL, flags);
	if (r) {
		CTX_ERROR(xfer->ctx, "Could not prepare xfer %s: %s\n",
			xfer->url, strerror(-r));
		return r;
	}

	// Perform the action
	r = curl_easy_perform(xfer->handle);

	// Handle the result
	r = pakfire_xfer_done(xfer, r);

	// Repeat the xfer if asked
	switch (-r) {
		case EAGAIN:
			goto AGAIN;

		default:
			break;
	}

	return r;
}

static int pakfire_xfer_handle_api_error(
		struct pakfire_xfer* xfer, const struct json_object* error) {
	struct json_object* message = NULL;
	struct json_object* code = NULL;
	const char* m = NULL;
	unsigned int c = 0;

	// Fetch the URL
	const char* url = pakfire_xfer_get_effective_url(xfer);

	// Fetch the code
	if (!json_object_object_get_ex(error, "code", &code))
		return -EBADMSG;

	// Check if the code is an integer
	if (!json_object_is_type(code, json_type_int))
		return -EBADMSG;

	// Fetch the message
	if (!json_object_object_get_ex(error, "message", &message))
		return -EBADMSG;

	// Check if the message is a string
	if (!json_object_is_type(message, json_type_string))
		return -EBADMSG;

	c = json_object_get_uint64(code);
	m = json_object_get_string(message);

	// Log the error
	CTX_ERROR(xfer->ctx, "%s responded with error %u (%s):\n  %s\n",
		url, c, strerror(c), m);

	return -c;
}

/*
	This function parses an API response
*/
static int pakfire_xfer_parse_api_response(struct pakfire_xfer* xfer,
		const char* buffer, const size_t length, struct json_object** object) {
	struct json_object* error = NULL;
	struct json_object* o = NULL;
	int r;

	// Check if we received any data
	if (!length) {
		CTX_ERROR(xfer->ctx, "Received an empty response\n");
		r = -EBADMSG;
		goto ERROR;
	}

	// XXX Maybe fetch the parser's error message here?!

	// Parse the buffer
	o = pakfire_json_parse(xfer->ctx, buffer, length);
	if (!o) {
		CTX_ERROR(xfer->ctx, "Could not parse the response\n");
		r = -EBADMSG;
		goto ERROR;
	}

	// Check if the response is a dictionary
	if (!json_object_is_type(o, json_type_object)) {
		CTX_ERROR(xfer->ctx, "The received object is not a JSON dict\n");
		r = -EBADMSG;
		goto ERROR;
	}

	// Fetch error
	r = json_object_object_get_ex(o, "error", &error);
	if (r) {
		r = pakfire_xfer_handle_api_error(xfer, error);
		goto ERROR;
	}

	// Return the object
	if (object)
		*object = json_object_get(o);

ERROR:
	if (o)
		json_object_put(o);

	return r;
}

static int pakfire_xfer_run_api_request_once(struct pakfire_xfer* xfer, struct json_object** response) {
	char* buffer = NULL;
	size_t length = 0;
	int r;

	// Write the response to the buffer
	r = pakfire_xfer_set_output_buffer(xfer, &buffer, &length);
	if (r)
		goto ERROR;

	// Run the xfer
	r = pakfire_xfer_run(xfer, PAKFIRE_XFER_NO_PROGRESS);
	if (r)
		goto ERROR;

	// Parse the response
	r = pakfire_xfer_parse_api_response(xfer, buffer, length, response);
	if (r) {
		CTX_ERROR(xfer->ctx, "Could not parse the API response: %s\n", strerror(-r));
		goto ERROR;
	}

ERROR:
	// Reset the output stream
	pakfire_xfer_reset_output(xfer);

	if (buffer)
		free(buffer);

	return r;
}

/*
	This function sends a request and automatically parses the response.
	The response might optionally be returned if response is not NULL.
*/
int pakfire_xfer_run_api_request(struct pakfire_xfer* xfer, struct json_object** response) {
	int r;

	// Loop indefinitely...
	for (;;) {
		r = pakfire_xfer_run_api_request_once(xfer, response);
		switch (r) {
			// XXX need to catch errors and act accordingly

			default:
				return r;
		}
	}

	return 0;
}