buildservice: Log a message when we initialized properly

[pakfire.git] / src / libpakfire / buildservice.c

/*#############################################################################
#                                                                             #
# Pakfire - The IPFire package management system                              #
# Copyright (C) 2021 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 <limits.h>
#include <stdlib.h>

#include <json.h>

#include <pakfire/buildservice.h>
#include <pakfire/config.h>
#include <pakfire/ctx.h>
#include <pakfire/digest.h>
#include <pakfire/httpclient.h>
#include <pakfire/logging.h>
#include <pakfire/path.h>
#include <pakfire/private.h>
#include <pakfire/string.h>
#include <pakfire/util.h>
#include <pakfire/xfer.h>

#include <krb5/krb5.h>

#define DEFAULT_KEYTAB "/etc/krb5.keytab"

struct pakfire_buildservice {
	struct pakfire_ctx* ctx;
	int nrefs;

	// Configuration
	char url[PATH_MAX];
	char keytab[PATH_MAX];

	// A HTTP Client
	struct pakfire_httpclient* httpclient;

	// Kerberos Context
	krb5_context krb5_ctx;
};

static int pakfire_buildservice_setup_auth(struct pakfire_buildservice* service) {
	const char* error = NULL;
	int r;

	// Setup a Kerberos context
	r = krb5_init_context(&service->krb5_ctx);
	if (r) {
		error = krb5_get_error_message(service->krb5_ctx, r);

		CTX_ERROR(service->ctx, "Could not initialize Kerberos: %s\n", error);
		krb5_free_error_message(service->krb5_ctx, error);

		goto ERROR;
	}

ERROR:
	return r;
}

static int pakfire_buildservice_setup(struct pakfire_buildservice* service) {
	struct pakfire_config* config = NULL;
	const char* url = NULL;
	const char* keytab = NULL;
	int r;

	// Fetch the configuration
	config = pakfire_ctx_get_config(service->ctx);
	if (!config) {
		r = 1;
		goto ERROR;
	}

	// Fetch the URL
	url = pakfire_config_get(config, "client", "url", NULL);
	if (!url) {
		CTX_ERROR(service->ctx, "Build Service URL is not configured\n");
		r = 1;
		goto ERROR;
	}

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

	// Fetch the keytab
	keytab = pakfire_config_get(config, "client", "keytab", DEFAULT_KEYTAB);

	// Store the keytab
	r = pakfire_string_set(service->keytab, keytab);
	if (r)
		goto ERROR;

	// Setup the HTTP client
	r = pakfire_httpclient_create(&service->httpclient, service->ctx);
	if (r)
		goto ERROR;

	// Setup authentication
	r = pakfire_buildservice_setup_auth(service);
	if (r)
		goto ERROR;

ERROR:
	if (config)
		pakfire_config_unref(config);

	return r;
}

static void pakfire_buildservice_free(struct pakfire_buildservice* service) {
	if (service->krb5_ctx)
		krb5_free_context(service->krb5_ctx);
	if (service->httpclient)
		pakfire_httpclient_unref(service->httpclient);
	if (service->ctx)
		pakfire_ctx_unref(service->ctx);

	free(service);
}

PAKFIRE_EXPORT int pakfire_buildservice_create(
		struct pakfire_buildservice** service, struct pakfire_ctx* ctx) {
	struct pakfire_buildservice* s = NULL;
	int r;

	// Allocate some memory
	s = calloc(1, sizeof(*s));
	if (!s)
		return -errno;

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

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

	// Setup everything
	r = pakfire_buildservice_setup(s);
	if (r)
		goto ERROR;

	CTX_DEBUG(s->ctx, "Pakfire Build Service initialized for %s\n", s->url);

	// Return the pointer
	*service = s;

	return 0;

ERROR:
	pakfire_buildservice_free(s);

	return r;
}

PAKFIRE_EXPORT struct pakfire_buildservice* pakfire_buildservice_ref(
		struct pakfire_buildservice* service) {
	++service->nrefs;

	return service;
}

PAKFIRE_EXPORT struct pakfire_buildservice* pakfire_buildservice_unref(
		struct pakfire_buildservice* service) {
	if (--service->nrefs > 0)
		return service;

	pakfire_buildservice_free(service);
	return NULL;
}

PAKFIRE_EXPORT const char* pakfire_buildservice_get_url(struct pakfire_buildservice* service) {
	return service->url;
}

static int pakfire_buildservice_create_xfer(struct pakfire_xfer** xfer,
		struct pakfire_buildservice* service, const char* url) {
	struct pakfire_xfer* t = NULL;
	int r;

	// Create a new xfer
	r = pakfire_httpclient_create_xfer(&t, service->httpclient, url);
	if (r)
		goto ERROR;

	// Set the base URL
	r = pakfire_xfer_set_baseurl(t, service->url);
	if (r)
		goto ERROR;

	// Return the new xfer
	*xfer = pakfire_xfer_ref(t);

ERROR:
	if (t)
		pakfire_xfer_unref(t);

	return r;
}

static int pakfire_buildservice_handle_error(struct pakfire_buildservice* service,
		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(service->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_buildservice_parse_response(struct pakfire_buildservice* service,
		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(service->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(service->ctx, buffer, length);
	if (!o) {
		CTX_ERROR(service->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(service->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_buildservice_handle_error(service, xfer, error);
		goto ERROR;
	}

	// Return the object
	*object = o;

	return 0;

ERROR:
	if (o)
		json_object_put(o);

	return r;
}

// Build

int pakfire_buildservice_build(struct pakfire_buildservice* service, const char* upload,
		const char* repo, const char** arches, int flags) {
	struct pakfire_xfer* xfer = NULL;
	struct json_object* response = NULL;
	char* buffer = NULL;
	size_t length = 0;
	int r;

	// Create a new xfer
	r = pakfire_buildservice_create_xfer(&xfer, service, "/api/v1/builds");
	if (r)
		goto ERROR;

	// Enable authentication
	r = pakfire_xfer_auth(xfer);
	if (r)
		goto ERROR;

	// Add the upload parameter
	r = pakfire_xfer_add_param(xfer, "upload", "%s", upload);
	if (r)
		goto ERROR;

	// Add the repo parameter
	r = pakfire_xfer_add_param(xfer, "repo", "%s", repo);
	if (r)
		goto ERROR;

	// Add any arches
	if (arches) {
		for (const char** arch = arches; *arch; arch++) {
			r = pakfire_xfer_add_param(xfer, "arch", "%s", *arch);
			if (r)
				goto ERROR;
		}
	}

	// Disable tests?
	if (flags & PAKFIRE_BUILD_DISABLE_TESTS) {
		r = pakfire_xfer_add_param(xfer, "disable_test_builds", "%s", "yes");
		if (r)
			goto ERROR;
	}

	// 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_buildservice_parse_response(service, xfer, buffer, length, &response);
	if (r) {
		CTX_ERROR(service->ctx, "Could not parse the response: %s\n", strerror(-r));
		goto ERROR;
	}

ERROR:
	if (xfer)
		pakfire_xfer_unref(xfer);
	if (response)
		json_object_put(response);
	if (buffer)
		free(buffer);

	return r;
}

// Uploads

static int pakfire_buildservice_create_upload(struct pakfire_buildservice* service,
		const char* path, const char* filename, FILE* f, char** uuid) {
	struct pakfire_xfer* xfer = NULL;
	struct pakfire_digests digests = {};
	struct json_object* response = NULL;
	struct json_object* id = NULL;
	const char* __id = NULL;
	char* hexdigest = NULL;
	char* buffer = NULL;
	size_t length = 0;
	struct stat stat;
	int r;

	const int fd = fileno(f);

	// Stat the file
	r = fstat(fd, &stat);
	if (r) {
		CTX_ERROR(service->ctx, "Could not stat %s: %s\n", path, strerror(errno));
		goto ERROR;
	}

	// Compute the digest
	r = pakfire_digests_compute_from_file(service->ctx, &digests, PAKFIRE_DIGEST_BLAKE2B512, f);
	if (r) {
		CTX_ERROR(service->ctx, "Could not compute the digest of %s: %s\n",
			path, strerror(-r));
		goto ERROR;
	}

	// Convert the digest into hex format
	hexdigest = pakfire_digest_get_hex(&digests, PAKFIRE_DIGEST_BLAKE2B512);
	if (!hexdigest)
		goto ERROR;

	// Create a new xfer
	r = pakfire_buildservice_create_xfer(&xfer, service, "/api/v1/uploads");
	if (r)
		goto ERROR;

	// Enable authentication
	r = pakfire_xfer_auth(xfer);
	if (r)
		goto ERROR;

	// Add the filename parameter
	r = pakfire_xfer_add_param(xfer, "filename", "%s", filename);
	if (r)
		goto ERROR;

	// Add the size parameter
	r = pakfire_xfer_add_param(xfer, "size", "%jd", stat.st_size);
	if (r)
		goto ERROR;

	// Add the hexdigest algo parameter
	r = pakfire_xfer_add_param(xfer, "hexdigest_algo", "%s", "blake2b512");
	if (r)
		goto ERROR;

	// Add the hexdigest parameter
	r = pakfire_xfer_add_param(xfer, "hexdigest", "%s", hexdigest);
	if (r)
		goto ERROR;

	// 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_buildservice_parse_response(service, xfer, buffer, length, &response);
	if (r) {
		CTX_ERROR(service->ctx, "Could not parse the response: %s\n", strerror(-r));
		goto ERROR;
	}

	// Fetch the ID
	r = json_object_object_get_ex(response, "id", &id);
	if (r == 0) {
		CTX_ERROR(service->ctx, "Could not fetch ID from response\n");
		r = -EBADMSG;
		goto ERROR;
	}

	// Extract the UUID
	__id = json_object_get_string(id);
	if (!__id) {
		CTX_ERROR(service->ctx, "Could not fetch ID from response\n");
		r = -EBADMSG;
		goto ERROR;
	}

	// Return the UUID
	*uuid = strdup(__id);
	if (!*uuid) {
		r = -errno;
		goto ERROR;
	}

	// Success
	r = 0;

ERROR:
	if (xfer)
		pakfire_xfer_unref(xfer);
	if (response)
		json_object_put(response);
	if (hexdigest)
		free(hexdigest);
	if (buffer)
		free(buffer);

	return r;
}

static int pakfire_buildservice_upload_payload(struct pakfire_buildservice* service,
		const char* filename, const char* uuid, FILE* f) {
	struct pakfire_xfer* xfer = NULL;
	struct json_object* response = NULL;
	char* buffer = NULL;
	size_t length = 0;
	char url[PATH_MAX];
	int r;

	// Make the URL
	r = pakfire_string_format(url, "/api/v1/uploads/%s", uuid);
	if (r)
		goto ERROR;

	// Create a new xfer
	r = pakfire_buildservice_create_xfer(&xfer, service, url);
	if (r)
		goto ERROR;

	// Set the title
	r = pakfire_xfer_set_title(xfer, filename);
	if (r)
		goto ERROR;

	// Set source file
	r = pakfire_xfer_set_input(xfer, f);
	if (r)
		goto ERROR;

	// Set the output buffer
	r = pakfire_xfer_set_output_buffer(xfer, &buffer, &length);
	if (r)
		goto ERROR;

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

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

ERROR:
	if (xfer)
		pakfire_xfer_unref(xfer);
	if (response)
		json_object_put(response);

	return r;
}

PAKFIRE_EXPORT int pakfire_buildservice_upload(struct pakfire_buildservice* service,
		const char* path, const char* filename, char** uuid) {
	char basename[NAME_MAX];
	FILE* f = NULL;
	int r;

	// Compute the basename
	r = pakfire_path_basename(basename, path);
	if (r)
		goto ERROR;

	// Set the basename as default filename
	if (!filename)
		filename = basename;

	// Open the source file
	f = fopen(path, "r");
	if (!f) {
		CTX_ERROR(service->ctx, "Could not open file for upload %s: %m\n", path);
		return -errno;
	}

	// Create a new upload
	r = pakfire_buildservice_create_upload(service, path, filename, f, uuid);
	if (r)
		goto ERROR;

	CTX_DEBUG(service->ctx, "Created a new download (%s)\n", *uuid);

	// Send the payload
	r = pakfire_buildservice_upload_payload(service, filename, *uuid, f);
	if (r)
		goto ERROR;

ERROR:
	if (r) {
		if (*uuid)
			free(*uuid);

		*uuid = NULL;
	}
	if (f)
		fclose(f);

	return r;
}

PAKFIRE_EXPORT int pakfire_buildservice_list_uploads(
		struct pakfire_buildservice* service, struct json_object** p) {
	struct pakfire_xfer* xfer = NULL;
	struct json_object* response = NULL;
	struct json_object* uploads = NULL;
	char* buffer = NULL;
	size_t length = 0;
	int r;

	// Create a new xfer
	r = pakfire_buildservice_create_xfer(&xfer, service, "/api/v1/uploads");
	if (r)
		goto ERROR;

	// Enable authentication
	r = pakfire_xfer_auth(xfer);
	if (r)
		goto ERROR;

	// 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_buildservice_parse_response(service, xfer, buffer, length, &response);
	if (r) {
		CTX_ERROR(service->ctx, "Could not parse the response: %s\n", strerror(-r));
		goto ERROR;
	}

	// Fetch the uploads
	uploads = json_object_object_get(response, "uploads");
	if (!uploads) {
		CTX_ERROR(service->ctx, "Malformed response\n");
		r = -EBADMSG;
		goto ERROR;
	}

	// Return the pointer
	*p = json_object_get(uploads);

ERROR:
	if (xfer)
		pakfire_xfer_unref(xfer);
	if (response)
		json_object_put(response);
	if (buffer)
		free(buffer);

	return r;
}

PAKFIRE_EXPORT int pakfire_buildservice_delete_upload(
		struct pakfire_buildservice* service, const char* uuid) {
	struct pakfire_xfer* xfer = NULL;
	struct json_object* response = NULL;
	char* buffer = NULL;
	size_t length = 0;
	char url[PATH_MAX];
	int r;

	// Compose the URL
	r = pakfire_string_format(url, "/api/v1/uploads/%s", uuid);
	if (r)
		goto ERROR;

	// Create a new xfer
	r = pakfire_buildservice_create_xfer(&xfer, service, url);
	if (r)
		goto ERROR;

	// Ask to DELETE
	r = pakfire_xfer_set_method(xfer, PAKFIRE_METHOD_DELETE);
	if (r)
		goto ERROR;

	// Enable authentication
	r = pakfire_xfer_auth(xfer);
	if (r)
		goto ERROR;

	// 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_buildservice_parse_response(service, xfer, buffer, length, &response);
	if (r) {
		CTX_ERROR(service->ctx, "Could not parse the response: %s\n", strerror(-r));
		goto ERROR;
	}

ERROR:
	if (xfer)
		pakfire_xfer_unref(xfer);
	if (response)
		json_object_put(response);
	if (buffer)
		free(buffer);

	return r;
}

// Repositories

PAKFIRE_EXPORT int pakfire_buildservice_list_repos(struct pakfire_buildservice* service,
		const char* distro, struct json_object** p) {
	struct pakfire_xfer* xfer = NULL;
	struct json_object* response = NULL;
	struct json_object* repos = NULL;
	char url[PATH_MAX];
	char* buffer = NULL;
	size_t length = 0;
	int r;

	// Check inputs
	if (!distro)
		return -EINVAL;

	// Compose path
	r = pakfire_string_format(url, "/api/v1/repos/%s", distro);
	if (r)
		goto ERROR;

	// Create a new xfer
	r = pakfire_buildservice_create_xfer(&xfer, service, url);
	if (r)
		goto ERROR;

	// Enable authentication
	r = pakfire_xfer_auth(xfer);
	if (r)
		goto ERROR;

	// 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_buildservice_parse_response(service, xfer, buffer, length, &response);
	if (r) {
		CTX_ERROR(service->ctx, "Could not parse the response: %s\n", strerror(-r));
		goto ERROR;
	}

	// Fetch the repos
	if (!json_object_object_get_ex(response, "repos", &repos)) {
		CTX_ERROR(service->ctx, "Malformed response\n");
		r = -EBADMSG;
		goto ERROR;
	}

	// Return the pointer
	*p = json_object_get(repos);

ERROR:
	if (xfer)
		pakfire_xfer_unref(xfer);
	if (response)
		json_object_put(response);
	if (buffer)
		free(buffer);

	return r;
}

PAKFIRE_EXPORT int pakfire_buildservice_get_repo(struct pakfire_buildservice* service,
		const char* distro, const char* name, struct json_object** p) {
	struct pakfire_xfer* xfer = NULL;
	struct json_object* response = NULL;
	char url[PATH_MAX];
	char* buffer = NULL;
	size_t length = 0;
	int r;

	// Check inputs
	if (!distro || !name)
		return -EINVAL;

	// Compose URL
	r = pakfire_string_format(url, "/api/v1/repos/%s/%s", distro, name);
	if (r)
		goto ERROR;

	// Create a new xfer
	r = pakfire_buildservice_create_xfer(&xfer, service, url);
	if (r)
		goto ERROR;

	// Enable authentication
	r = pakfire_xfer_auth(xfer);
	if (r)
		goto ERROR;

	// 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_buildservice_parse_response(service, xfer, buffer, length, &response);
	if (r) {
		CTX_ERROR(service->ctx, "Could not parse the response: %s\n", strerror(-r));
		goto ERROR;
	}

	// Return the pointer
	*p = json_object_get(response);

ERROR:
	if (xfer)
		pakfire_xfer_unref(xfer);
	if (response)
		json_object_put(response);
	if (buffer)
		free(buffer);

	return r;
}

PAKFIRE_EXPORT int pakfire_buildservice_create_repo(struct pakfire_buildservice* service,
		const char* distro, const char* name, const char* description, struct json_object** p) {
	struct pakfire_xfer* xfer = NULL;
	struct json_object* response = NULL;
	char url[PATH_MAX];
	char* buffer = NULL;
	size_t length = 0;
	int r;

	// Check inputs
	if (!distro)
		return -EINVAL;

	// Compose path
	r = pakfire_string_format(url, "/api/v1/repos/%s", distro);
	if (r)
		goto ERROR;

	// Create a new xfer
	r = pakfire_buildservice_create_xfer(&xfer, service, url);
	if (r)
		goto ERROR;

	// Enable authentication
	r = pakfire_xfer_auth(xfer);
	if (r)
		goto ERROR;

	// Set name
	r = pakfire_xfer_add_param(xfer, "name", "%s", name);
	if (r)
		goto ERROR;

	// Set description
	if (description) {
		r = pakfire_xfer_add_param(xfer, "description", "%s", description);
		if (r)
			goto ERROR;
	}

	// 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_buildservice_parse_response(service, xfer, buffer, length, &response);
	if (r) {
		CTX_ERROR(service->ctx, "Could not parse the response: %s\n", strerror(-r));
		goto ERROR;
	}

	// Return the pointer
	if (p)
		*p = json_object_get(response);

ERROR:
	if (xfer)
		pakfire_xfer_unref(xfer);
	if (response)
		json_object_put(response);
	if (buffer)
		free(buffer);

	return r;
}

PAKFIRE_EXPORT int pakfire_buildservice_delete_repo(struct pakfire_buildservice* service,
		const char* distro, const char* name) {
	struct pakfire_xfer* xfer = NULL;
	struct json_object* response = NULL;
	char* buffer = NULL;
	size_t length = 0;
	char url[PATH_MAX];
	int r;

	// Compose the URL
	r = pakfire_string_format(url, "/api/v1/repos/%s/%s", distro, name);
	if (r)
		goto ERROR;

	// Create a new xfer
	r = pakfire_buildservice_create_xfer(&xfer, service, url);
	if (r)
		goto ERROR;

	// Ask to DELETE
	r = pakfire_xfer_set_method(xfer, PAKFIRE_METHOD_DELETE);
	if (r)
		goto ERROR;

	// Enable authentication
	r = pakfire_xfer_auth(xfer);
	if (r)
		goto ERROR;

	// 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_buildservice_parse_response(service, xfer, buffer, length, &response);
	if (r) {
		CTX_ERROR(service->ctx, "Could not parse the response: %s\n", strerror(-r));
		goto ERROR;
	}

ERROR:
	if (xfer)
		pakfire_xfer_unref(xfer);
	if (response)
		json_object_put(response);
	if (buffer)
		free(buffer);

	return r;
}