python: Make sure we hold the GIL when jumping into the logging callback

[pakfire.git] / src / _pakfire / pakfire.c

/*#############################################################################
#                                                                             #
# Pakfire - The IPFire package management system                              #
# Copyright (C) 2017 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/>.       #
#                                                                             #
#############################################################################*/

#define PY_SSIZE_T_CLEAN
#include <Python.h>
#include <errno.h>
#include <syslog.h>

#include <pakfire/archive.h>
#include <pakfire/build.h>
#include <pakfire/constants.h>
#include <pakfire/ctx.h>
#include <pakfire/dist.h>
#include <pakfire/jail.h>
#include <pakfire/logging.h>
#include <pakfire/mount.h>
#include <pakfire/packagelist.h>
#include <pakfire/pakfire.h>
#include <pakfire/key.h>
#include <pakfire/repo.h>
#include <pakfire/repolist.h>
#include <pakfire/transaction.h>
#include <pakfire/util.h>

#include "archive.h"
#include "ctx.h"
#include "errors.h"
#include "key.h"
#include "pakfire.h"
#include "repo.h"
#include "util.h"

static PyObject* Pakfire_new(PyTypeObject* type, PyObject* args, PyObject* kwds) {
	PakfireObject* self = (PakfireObject *)type->tp_alloc(type, 0);
	if (self) {
		self->ctx = NULL;
		self->pakfire = NULL;
	}

	return (PyObject *)self;
}

static int Pakfire_init(PakfireObject* self, PyObject* args, PyObject* kwds) {
	char* kwlist[] = {
		"ctx",
		"path",
		"arch",
		"conf",
		NULL,
	};
	CtxObject* ctx = NULL;
	const char* path = NULL;
	const char* arch = NULL;
	PyObject* conf = Py_None;
	int r = 1;

	FILE* fconf = NULL;

	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!|zzO", kwlist,
			&CtxType, &ctx, &path, &arch, &conf))
		goto ERROR;

	// Map the configuration
	if (conf != Py_None) {
		fconf = PyObject_AsFileHandle(conf, "r");
		if (!fconf)
			goto ERROR;
	}

	int flags = 0;

	Py_BEGIN_ALLOW_THREADS

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

	// Create a new Pakfire instance
	r = pakfire_create(&self->pakfire, self->ctx, path, arch, fconf, flags);

	Py_END_ALLOW_THREADS

	if (r < 0) {
		errno = -r;

		switch (errno) {
			// Invalid architecture or path
			case EINVAL:
				PyErr_SetString(PyExc_ValueError, "Invalid architecture or path");
				break;

			// Anything else
			default:
				PyErr_SetFromErrno(PyExc_OSError);
		}

		r = -1;
		goto ERROR;
    }

ERROR:
	if (fconf)
		fclose(fconf);

	return -r;
}

static void Pakfire_dealloc(PakfireObject* self) {
	if (self->pakfire) {
		Py_BEGIN_ALLOW_THREADS

		pakfire_unref(self->pakfire);

		Py_END_ALLOW_THREADS
	}
	if (self->ctx)
		pakfire_ctx_unref(self->ctx);

	Py_TYPE(self)->tp_free((PyObject *)self);
}

static PyObject* Pakfire_repr(PakfireObject* self) {
	const char* path = pakfire_get_path(self->pakfire);
	const char* arch = pakfire_get_arch(self->pakfire);

	return PyUnicode_FromFormat("<_pakfire.Pakfire %s (%s)>", path, arch);
}

static PyObject* Pakfire_get_path(PakfireObject* self) {
	const char* path = pakfire_get_path(self->pakfire);

	return PyUnicode_FromString(path);
}

static PyObject* Pakfire_get_arch(PakfireObject* self) {
	const char* arch = pakfire_get_arch(self->pakfire);

	return PyUnicode_FromString(arch);
}

static PyObject* Pakfire_get_repo(PakfireObject* self, PyObject* args) {
	const char* name = NULL;

	if (!PyArg_ParseTuple(args, "s", &name))
		return NULL;

	struct pakfire_repo* repo = pakfire_get_repo(self->pakfire, name);
	if (!repo)
		Py_RETURN_NONE;

	PyObject* obj = new_repo(&RepoType, repo);
	pakfire_repo_unref(repo);

	return obj;
}

static int convert_packages(PyObject* object, void* address) {
	char*** packages = (char***)address;

	// Called for cleanup
	if (!object)
		goto ERROR;

	// Nothing to do when object is None
	if (object == Py_None)
		return Py_CLEANUP_SUPPORTED;

	if (!PySequence_Check(object)) {
		PyErr_SetString(PyExc_ValueError, "Packages must be a sequence");
		goto ERROR;
	}

	const unsigned int length = PySequence_Length(object);
	if (!length)
		return Py_CLEANUP_SUPPORTED;

	// Allocate array
	*packages = calloc(length + 1, sizeof(*packages));
	if (!*packages) {
		PyErr_SetFromErrno(PyExc_OSError);
		goto ERROR;
	}

	for (unsigned int i = 0; i < length; i++) {
		PyObject* item = PySequence_GetItem(object, i);

		// Check if input is a string
		if (!PyUnicode_Check(item)) {
			Py_DECREF(item);

			PyErr_SetString(PyExc_AttributeError, "Expected a string");
			goto ERROR;
		}

		// Fetch string
		const char* package = PyUnicode_AsUTF8(item);
		if (!package) {
			Py_DECREF(item);
			goto ERROR;
		}

		// Add package to array
		(*packages)[i] = strdup(package);
		if (!(*packages)[i]) {
			Py_DECREF(item);
			goto ERROR;
		}

		Py_DECREF(item);
	}

	// Success
	return Py_CLEANUP_SUPPORTED;

ERROR:
	if (*packages) {
		for (char** package = *packages; *package; package++)
			free(*package);
		free(*packages);
	}

	return 0;
}

/*
	XXX This could be moved out of here as this no longer depends on Pakfire
*/
static PyObject* Pakfire_generate_key(PakfireObject* self, PyObject* args, PyObject* kwds) {
	char* kwlist[] = { "algorithm", "comment", NULL };
	struct pakfire_key* key = NULL;
	pakfire_key_algo_t algo = PAKFIRE_KEY_ALGO_NULL;
	const char* comment = NULL;

	if (!PyArg_ParseTupleAndKeywords(args, kwds, "is", kwlist, &algo, &comment))
		return NULL;

	// Generate a new key
	int r = pakfire_key_generate(&key, self->ctx, algo, comment);
	if (r) {
		PyErr_SetFromErrno(PyExc_OSError);
		return NULL;
	}

	PyObject* object = new_key(&KeyType, key);
	pakfire_key_unref(key);

	return object;
}
/*
	XXX This could be moved out of here as this no longer depends on Pakfire
*/
static PyObject* Pakfire_import_key(PakfireObject* self, PyObject* args) {
	struct pakfire_key* key = NULL;
	PyObject* object = NULL;
	char* data = NULL;
	Py_ssize_t data_length = 0;
	int r;

	// Parse arguments
	if (!PyArg_ParseTuple(args, "s#", &data, &data_length))
		return NULL;

	// Map the object
	FILE* f = fmemopen(data, data_length, "r");
	if (!f)
		return NULL;

	// Import the key
	r = pakfire_key_import(&key, self->ctx, f);
	if (r) {
		PyErr_SetFromErrno(PyExc_OSError);
		goto ERROR;
	}

	// Convert the key into a Key object
	object = new_key(&KeyType, key);
	if (!object)
		goto ERROR;

ERROR:
	if (key)
		pakfire_key_unref(key);
	if (f)
		fclose(f);

	return object;
}

static PyObject* Pakfire_whatprovides(PakfireObject* self, PyObject* args) {
	const char* provides = NULL;
	struct pakfire_packagelist* list = NULL;
	PyObject* ret = NULL;
	int r;

	if (!PyArg_ParseTuple(args, "s", &provides))
		return NULL;

	// Create a new list
	r = pakfire_packagelist_create(&list, self->ctx);
	if (r) {
		PyErr_SetFromErrno(PyExc_OSError);
		goto ERROR;
	}

	r = pakfire_whatprovides(self->pakfire, provides, 0, list);
	if (r) {
		PyErr_SetFromErrno(PyExc_OSError);
		goto ERROR;
	}

	// Create a Python list from the package list
	ret = PyList_FromPackageList(list);

ERROR:
	if (list)
		pakfire_packagelist_unref(list);

	return ret;
}

static PyObject* Pakfire_whatrequires(PakfireObject* self, PyObject* args) {
	const char* requires = NULL;
	struct pakfire_packagelist* list = NULL;
	PyObject* ret = NULL;
	int r;

	if (!PyArg_ParseTuple(args, "s", &requires))
		return NULL;

	Py_BEGIN_ALLOW_THREADS

	// Create a new list
	r = pakfire_packagelist_create(&list, self->ctx);
	if (r) {
		Py_BLOCK_THREADS
		PyErr_SetFromErrno(PyExc_OSError);
		goto ERROR;
	}

	r = pakfire_whatrequires(self->pakfire, requires, 0, list);
	if (r) {
		Py_BLOCK_THREADS
		PyErr_SetFromErrno(PyExc_OSError);
		goto ERROR;
	}

	Py_END_ALLOW_THREADS

	// Create a Python list from the package list
	ret = PyList_FromPackageList(list);

ERROR:
	if (list)
		pakfire_packagelist_unref(list);

	return ret;
}

static PyObject* Pakfire_search(PakfireObject* self, PyObject* args, PyObject* kwds) {
	char* kwlist[] = { "pattern", "name_only", NULL };
	struct pakfire_packagelist* list = NULL;
	const char* pattern = NULL;
	int name_only = 0;
	int flags = 0;
	PyObject* ret = NULL;
	int r;

	if (!PyArg_ParseTupleAndKeywords(args, kwds, "s|$p", kwlist, &pattern, &name_only))
		return NULL;

	// Search for package names only
	if (name_only)
		flags |= PAKFIRE_SEARCH_NAME_ONLY;

	r = pakfire_packagelist_create(&list, self->ctx);
	if (r) {
		PyErr_SetFromErrno(PyExc_OSError);
		goto ERROR;
	}

	r = pakfire_search(self->pakfire, pattern, flags, list);
	if (r) {
		PyErr_SetFromErrno(PyExc_OSError);
		goto ERROR;
	}

	ret = PyList_FromPackageList(list);

ERROR:
	if (list)
		pakfire_packagelist_unref(list);

	return ret;
}

static PyObject* Pakfire_version_compare(PakfireObject* self, PyObject* args) {
	const char* evr1 = NULL;
	const char* evr2 = NULL;

	if (!PyArg_ParseTuple(args, "ss", &evr1, &evr2))
		return NULL;

	int cmp = pakfire_version_compare(self->pakfire, evr1, evr2);

	return PyLong_FromLong(cmp);
}

static int Pakfire_execute_output_callback(struct pakfire_ctx* ctx, struct pakfire_jail* jail,
		void* data, const char* line, size_t length) {
	PyObject* callback = (PyObject*)data;
	PyObject* args = NULL;
	PyObject* result = NULL;
	int r = 1;

	// Do nothing if callback isn't set
	if (!callback)
		return 0;

	// Remove the trailing newline
	if (line && length && line[length - 1] == '\n')
		length--;

	// Get the GIL
	PyGILState_STATE state = PyGILState_Ensure();

	// Create tuple with arguments for the callback function
	args = Py_BuildValue("(is#)", LOG_INFO, line, (Py_ssize_t)length);
	if (!args)
		goto ERROR;

	// Call the callback method
	result = PyObject_CallObject(callback, args);
    if (result && PyLong_Check(result)) {
        r = PyLong_AsLong(result);
    }

ERROR:
	Py_XDECREF(args);
	Py_XDECREF(result);

	// Release the GIL
	PyGILState_Release(state);

	return r;
}

static PyObject* Pakfire_execute(PakfireObject* self, PyObject* args, PyObject* kwds) {
	char* kwlist[] = {
		"command",
		"environ",
		"bind",
		"callback",
		"nice",
		NULL
	};

	struct pakfire_jail* jail = NULL;
	const char** argv = NULL;
	int r;
	PyObject* ret = NULL;

	PyObject* command = NULL;
	PyObject* environ = NULL;
	PyObject* bind = NULL;
	PyObject* callback = NULL;
	int nice = 0;

	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|OOOi", kwlist, &command, &environ,
			&bind, &callback, &nice))
		return NULL;

	// Check if command is a list
	if (!PyList_Check(command)) {
		PyErr_SetString(PyExc_TypeError, "command must be a list");
		goto ERROR;
	}

	const ssize_t command_length = PyList_Size(command);

	// Check if command is not empty
	if (command_length == 0) {
		PyErr_SetString(PyExc_ValueError, "command is empty");
		goto ERROR;
	}

	// Allocate argv
	argv = calloc(command_length + 1, sizeof(*argv));
	if (!argv)
		goto ERROR;

	// All arguments in command must be strings
	for (unsigned int i = 0; i < command_length; i++) {
		PyObject* item = PyList_GET_ITEM(command, i);

		if (!PyUnicode_Check(item)) {
			PyErr_Format(PyExc_TypeError, "Item %u in command is not a string", i);
			goto ERROR;
		}

		// Copy to argv
		argv[i] = PyUnicode_AsUTF8(item);
	}

	// Check if bind is a sequence
	if (bind && !PySequence_Check(bind)) {
		PyErr_SetString(PyExc_ValueError, "bind is not a sequence");
		goto ERROR;
	}

	// Check callback
	if (callback && !PyCallable_Check(callback)) {
		PyErr_SetString(PyExc_TypeError, "callback must be callable\n");
		goto ERROR;
	}

	// Create jail
	r = pakfire_jail_create(&jail, self->pakfire);
	if (r) {
		PyErr_SetFromErrno(PyExc_OSError);
		goto ERROR;
	}

	// Set nice
	if (nice) {
		r = pakfire_jail_nice(jail, nice);
		if (r) {
			PyErr_SetFromErrno(PyExc_OSError);
			goto ERROR;
		}
	}

	PyObject* key = NULL;
	PyObject* value = NULL;
	Py_ssize_t p = 0;

	// Parse the environment
	if (environ) {
		// Check if environ is a dictionary
		if (!PyDict_Check(environ)) {
			PyErr_SetString(PyExc_TypeError, "environ must be a dictionary");
			goto ERROR;
		}

		// All keys and values must be strings
		while (PyDict_Next(environ, &p, &key, &value)) {
			if (!PyUnicode_Check(key) || !PyUnicode_Check(value)) {
				PyErr_SetString(PyExc_TypeError, "Environment contains a non-string object");
				goto ERROR;
			}

			// Set environment value
			r = pakfire_jail_set_env(jail, PyUnicode_AsUTF8(key), PyUnicode_AsUTF8(value));
			if (r) {
				PyErr_SetFromErrno(PyExc_OSError);
				goto ERROR;
			}
		}
	}

	// Bind
	if (bind && PySequence_Check(bind)) {
		const Py_ssize_t num_bind = PySequence_Length(bind);

		for (unsigned int i = 0; i < num_bind; i++) {
			PyObject* b = PySequence_ITEM(bind, i);
			if (!b)
				goto ERROR;

			// Check if this is a Unicode object
			if (!PyUnicode_Check(b)) {
				PyErr_SetString(PyExc_ValueError, "bind contains a non-Unicode object");
				Py_DECREF(b);
				goto ERROR;
			}

			const char* path = PyUnicode_AsUTF8(b);

			// Perform bind
			r = pakfire_jail_bind(jail, path, path, 0);
			if (r) {
				PyErr_SetFromErrno(PyExc_OSError);
				Py_DECREF(b);
				goto ERROR;
			}

			Py_DECREF(b);
		}
	}

	Py_BEGIN_ALLOW_THREADS

	// Set callback
	pakfire_jail_set_stdout_callback(jail, Pakfire_execute_output_callback, callback);

	// Execute command
	r = pakfire_jail_exec(jail, argv, 0);

	Py_END_ALLOW_THREADS

	// If the return code was negative, we had some internal error
	if (r < 0) {
		PyErr_SetFromErrno(PyExc_OSError);
		goto ERROR;

	// Otherwise the executed command returned some error code
	} else if (r > 0) {
		PyObject* code = PyLong_FromLong(r);

		// Raise CommandExecutionError
		PyErr_SetObject(PyExc_CommandExecutionError, code);
		Py_DECREF(code);

		goto ERROR;
	}

	// The process has exited successfully

	// Return None
	ret = Py_None;
	Py_INCREF(ret);

ERROR:
	if (argv)
		free(argv);
	if (jail)
		pakfire_jail_unref(jail);

	return ret;
}

static PyObject* Pakfire_dist(PakfireObject* self, PyObject* args) {
	const char* path = NULL;
	const char* target = NULL;
	char* result = NULL;
	int r;

	if (!PyArg_ParseTuple(args, "s|z", &path, &target))
		return NULL;

	Py_BEGIN_ALLOW_THREADS

	r = pakfire_dist(self->pakfire, path, target, &result);
	if (r) {
		Py_BLOCK_THREADS
		PyErr_SetFromErrno(PyExc_OSError);
		return NULL;
	}

	Py_END_ALLOW_THREADS

	PyObject* ret = PyUnicode_FromString(result);
	free(result);

	return ret;
}

static PyObject* Pakfire_get_repos(PakfireObject* self) {
	struct pakfire_repolist* repos = pakfire_get_repos(self->pakfire);
	if (!repos) {
		PyErr_SetFromErrno(PyExc_OSError);
		return NULL;
	}

	const size_t l = pakfire_repolist_size(repos);

	PyObject* list = PyList_New(l);
	if (!list)
		goto ERROR;

	for (unsigned int i = 0; i < l; i++) {
		struct pakfire_repo* repo = pakfire_repolist_get(repos, i);
		if (!repo)
			continue;

		PyObject* obj = new_repo(&RepoType, repo);
		PyList_SET_ITEM(list, i, obj);

		pakfire_repo_unref(repo);
	}

ERROR:
	pakfire_repolist_unref(repos);

	return list;
}

static PyObject* execute_return_value(int r) {
	// Raise an OS error if r < 0
	if (r < 0) {
		errno = -r;

		PyErr_SetFromErrno(PyExc_OSError);
		return NULL;

	// Raise exception when the command failed
	} else if (r > 0) {
		PyObject* code = PyLong_FromLong(r);

		PyErr_SetObject(PyExc_CommandExecutionError, code);
		Py_DECREF(code);

		return NULL;
	}

	Py_RETURN_NONE;
}

static PyObject* Pakfire_build(PakfireObject* self, PyObject* args, PyObject* kwargs) {
	char* kwlist[] = {
		"path",
		"target",
		"build_id",
		"ccache_path",
		"interactive",
		"disable_snapshot",
		"disable_ccache",
		"disable_tests",
		NULL,
	};
	struct pakfire_build* build = NULL;
	const char* path = NULL;
	const char* target = NULL;
	const char* build_id = NULL;
	const char* ccache_path = NULL;
	int interactive = 0;
	int disable_snapshot = 0;
	int disable_ccache = 0;
	int disable_tests = 0;
	int r;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|zzzpppp", kwlist,
			&path, &target, &build_id, &ccache_path, &interactive,
			&disable_snapshot, &disable_ccache, &disable_tests))
		return NULL;

	int flags = 0;

	if (interactive)
		flags |= PAKFIRE_BUILD_INTERACTIVE;

	// Disable snapshot if requested
	if (disable_snapshot)
		flags |= PAKFIRE_BUILD_DISABLE_SNAPSHOT;

	// Disable ccache if requested
	if (disable_ccache)
		flags |= PAKFIRE_BUILD_DISABLE_CCACHE;

	// Disable tests if requested
	if (disable_tests)
		flags |= PAKFIRE_BUILD_DISABLE_TESTS;

	// Create a new build environment
	r = pakfire_build_create(&build, self->pakfire, build_id, flags);
	if (r) {
		PyErr_SetFromErrno(PyExc_OSError);
		goto ERROR;
	}

	// Set target
	if (target) {
		r = pakfire_build_set_target(build, target);
		if (r) {
			PyErr_SetFromErrno(PyExc_OSError);
			goto ERROR;
		}
	}

	// Set ccache path
	if (ccache_path) {
		r = pakfire_build_set_ccache_path(build, ccache_path);
		if (r) {
			PyErr_SetFromErrno(PyExc_OSError);
			goto ERROR;
		}
	}

	Py_BEGIN_ALLOW_THREADS

	// Run build
	r = pakfire_build_exec(build, path);
	if (r) {
		Py_BLOCK_THREADS;

		if (r < 0) {
			PyErr_SetFromErrno(PyExc_OSError);

		// Raise a command execution error
		} else {
			PyObject* code = PyLong_FromLong(r);

			PyErr_SetObject(PyExc_CommandExecutionError, code);
			Py_DECREF(code);
		}

		goto ERROR;
	}

	Py_END_ALLOW_THREADS

ERROR:
	if (build)
		pakfire_build_unref(build);

	if (r)
		return NULL;

	Py_RETURN_NONE;
}

static PyObject* Pakfire_shell(PakfireObject* self, PyObject* args, PyObject* kwargs) {
	char* kwlist[] = {
		"install",
		"disable_snapshot",
		NULL,
	};
	char** packages = NULL;
	int disable_snapshot = 0;
	int r;

	// Parse everything
	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O&p", kwlist,
			convert_packages, &packages, &disable_snapshot))
		return NULL;

	int flags = 0;

	if (disable_snapshot)
		flags |= PAKFIRE_BUILD_DISABLE_SNAPSHOT;

	Py_BEGIN_ALLOW_THREADS

	r = pakfire_shell(self->pakfire, (const char**)packages, flags);

	Py_END_ALLOW_THREADS

	return execute_return_value(r);
}

static PyObject* Pakfire_clean(PakfireObject* self) {
	int r;

	Py_BEGIN_ALLOW_THREADS

	r = pakfire_clean(self->pakfire, 0);
	if (r) {
		Py_BLOCK_THREADS
		PyErr_SetFromErrno(PyExc_OSError);
		return NULL;
	}

	Py_END_ALLOW_THREADS

	Py_RETURN_NONE;
}

static PyObject* Pakfire_refresh(PakfireObject* self, PyObject* args) {
	int force = 0;
	int r;

	if (!PyArg_ParseTuple(args, "|p", &force))
		return NULL;

	Py_BEGIN_ALLOW_THREADS

	r = pakfire_refresh(self->pakfire, force);
	if (r) {
		Py_BLOCK_THREADS
		PyErr_SetFromErrno(PyExc_OSError);
		return NULL;
	}

	Py_END_ALLOW_THREADS

	Py_RETURN_NONE;
}

static PyObject* Pakfire_open(PakfireObject* self, PyObject* args) {
	struct pakfire_archive* archive = NULL;
	const char* path = NULL;

	if (!PyArg_ParseTuple(args, "s", &path))
		return NULL;

	Py_BEGIN_ALLOW_THREADS

	int r = pakfire_archive_open(&archive, self->pakfire, path);
	if (r) {
		Py_BLOCK_THREADS
		PyErr_SetFromErrno(PyExc_OSError);
		return NULL;
	}

	Py_END_ALLOW_THREADS

	// Create Python object
	PyObject* object = new_archive(&ArchiveType, archive);
	pakfire_archive_unref(archive);

	return object;
}

static PyObject* Pakfire_repo_compose(PakfireObject* self, PyObject* args, PyObject* kwargs) {
	char* kwlist[] = { "path", "files", "key", NULL };
	const char* path = NULL;
	PyObject* list = NULL;
	KeyObject* key = NULL;

	PyObject* ret = NULL;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "sO|O!", kwlist, &path, &list, &KeyType, &key))
		return NULL;

	// List must be a sequence
	if (!PySequence_Check(list)) {
		PyErr_SetString(PyExc_ValueError, "Expected a sequence.");
		return NULL;
	}

	// How many new files do we have?
	ssize_t num_files = PySequence_Length(list);
	if (num_files < 0)
		return NULL;

	// Allocate files array
	const char** files = calloc(num_files + 1, sizeof(*files));
	if (!files) {
		PyErr_SetFromErrno(PyExc_OSError);
		return NULL;
	}

	for (int i = 0; i < num_files; i++) {
		PyObject* file = PySequence_GetItem(list, i);
		if (!file)
			goto ERROR;

		// Check if file is a Unicode object
		if (!PyUnicode_Check(file)) {
			PyErr_SetString(PyExc_ValueError, "Expected a string.");
			goto ERROR;
		}

		// Add pointer to string to files array
		files[i] = PyUnicode_AsUTF8(file);
		if (!files[i])
			goto ERROR;

		Py_DECREF(file);
	}

	Py_BEGIN_ALLOW_THREADS

	int r = pakfire_repo_compose(self->pakfire, path, (key) ? key->key : NULL, files);
	if (r) {
		Py_BLOCK_THREADS
		PyErr_SetFromErrno(PyExc_OSError);
		return NULL;
	}

	Py_END_ALLOW_THREADS

	// Return None on success
	ret = Py_None;
	Py_INCREF(ret);

ERROR:
	if (files)
		free(files);

	return ret;
}

static PyObject* Pakfire_mkimage(PakfireObject* self, PyObject* args, PyObject* kwargs) {
	char* kwlist[] = {
		"type",
		"path",
		NULL,
	};
	struct pakfire_build* build = NULL;
	const char* type = NULL;
	PyObject* file = NULL;
	FILE* f = NULL;
	int r;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "sO", kwlist, &type, &file))
		return NULL;

	// Make a file handle out of file
	f = PyObject_AsFileHandle(file, "w");
	if (!f)
		return NULL;

	// Create a new build environment
	r = pakfire_build_create(&build, self->pakfire, NULL, 0);
	if (r) {
		PyErr_SetFromErrno(PyExc_OSError);
		goto ERROR;
	}

	Py_BEGIN_ALLOW_THREADS

	// Run mkimage
	r = pakfire_build_mkimage(build, type, f);
	if (r) {
		Py_BLOCK_THREADS;

		if (r < 0)
			PyErr_SetFromErrno(PyExc_OSError);

		goto ERROR;
	}

	Py_END_ALLOW_THREADS

ERROR:
	if (build)
		pakfire_build_unref(build);
	if (f)
		fclose(f);
	if (r)
		return NULL;

	Py_RETURN_NONE;
}

static struct PyMethodDef Pakfire_methods[] = {
	{
		"build",
		(PyCFunction)Pakfire_build,
		METH_VARARGS|METH_KEYWORDS,
		NULL
	},
	{
		"clean",
		(PyCFunction)Pakfire_clean,
		METH_NOARGS,
		NULL,
	},
	{
		"dist",
		(PyCFunction)Pakfire_dist,
		METH_VARARGS,
		NULL
	},
	{
		"execute",
		(PyCFunction)Pakfire_execute,
		METH_VARARGS|METH_KEYWORDS,
		NULL
	},
	{
		"generate_key",
		(PyCFunction)Pakfire_generate_key,
		METH_VARARGS|METH_KEYWORDS,
		NULL
	},
	{
		"get_repo",
		(PyCFunction)Pakfire_get_repo,
		METH_VARARGS,
		NULL
	},
	{
		"import_key",
		(PyCFunction)Pakfire_import_key,
		METH_VARARGS,
		NULL,
	},
	{
		"mkimage",
		(PyCFunction)Pakfire_mkimage,
		METH_VARARGS|METH_KEYWORDS,
		NULL
	},
	{
		"open",
		(PyCFunction)Pakfire_open,
		METH_VARARGS,
		NULL
	},
	{
		"refresh",
		(PyCFunction)Pakfire_refresh,
		METH_VARARGS,
		NULL,
	},
	{
		"repo_compose",
		(PyCFunction)Pakfire_repo_compose,
		METH_VARARGS|METH_KEYWORDS,
		NULL
	},
	{
		"search",
		(PyCFunction)Pakfire_search,
		METH_VARARGS|METH_KEYWORDS,
		NULL
	},
	{
		"shell",
		(PyCFunction)Pakfire_shell,
		METH_VARARGS|METH_KEYWORDS,
		NULL,
	},
	{
		"version_compare",
		(PyCFunction)Pakfire_version_compare,
		METH_VARARGS,
		NULL
	},
	{
		"whatprovides",
		(PyCFunction)Pakfire_whatprovides,
		METH_VARARGS,
		NULL
	},
	{
		"whatrequires",
		(PyCFunction)Pakfire_whatrequires,
		METH_VARARGS,
		NULL
	},
	{ NULL },
};

static struct PyGetSetDef Pakfire_getsetters[] = {
	{
		"arch",
		(getter)Pakfire_get_arch,
		NULL,
		NULL,
		NULL
	},
    {
		"path",
		(getter)Pakfire_get_path,
		NULL,
		NULL,
		NULL
	},
	{
		"repos",
		(getter)Pakfire_get_repos,
		NULL,
		NULL,
		NULL
	},
    { NULL },
};

PyTypeObject PakfireType = {
	PyVarObject_HEAD_INIT(NULL, 0)
	tp_name:            "_pakfire.Pakfire",
	tp_basicsize:       sizeof(PakfireObject),
	tp_flags:           Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
	tp_new:             Pakfire_new,
	tp_dealloc:         (destructor)Pakfire_dealloc,
	tp_init:            (initproc)Pakfire_init,
	tp_doc:             "Pakfire object",
	tp_methods:         Pakfire_methods,
	tp_getset:          Pakfire_getsetters,
	tp_repr:            (reprfunc)Pakfire_repr,
};