package: Refactor pakfire_package_set_filelist_from_string

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

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

#include <json.h>

#include <solv/evr.h>
#include <solv/pool.h>
#include <solv/repo.h>
#include <solv/solvable.h>

#include <pakfire/archive.h>
#include <pakfire/constants.h>
#include <pakfire/dependencies.h>
#include <pakfire/digest.h>
#include <pakfire/file.h>
#include <pakfire/filelist.h>
#include <pakfire/i18n.h>
#include <pakfire/logging.h>
#include <pakfire/package.h>
#include <pakfire/pakfire.h>
#include <pakfire/private.h>
#include <pakfire/repo.h>
#include <pakfire/string.h>
#include <pakfire/util.h>

struct pakfire_package {
	struct pakfire* pakfire;
	int nrefs;

	// Reference to this package in the SOLV pool
	Id id;
	struct pakfire_repo* repo;

	char nevra[NAME_MAX];
	char source_nevra[NAME_MAX];

	char filename[NAME_MAX];
	char path[PATH_MAX];
};

struct pakfire_package* pakfire_package_create_from_solvable(struct pakfire* pakfire, Id id) {
	struct pakfire_package* pkg = calloc(1, sizeof(*pkg));
	if (!pkg)
		return NULL;

	pkg->pakfire = pakfire_ref(pakfire);
	pkg->id = id;

	// Initialize reference counter
	pkg->nrefs = 1;

	return pkg;
}

PAKFIRE_EXPORT struct pakfire_package* pakfire_package_create(
		struct pakfire* pakfire, struct pakfire_repo* repo,
		const char* name, const char* evr, const char* arch) {
	struct pakfire_package* pkg = NULL;
	struct pakfire_repo* dummy = NULL;

	// Default to dummy repository
	if (!repo) {
		dummy = pakfire_get_repo(pakfire, PAKFIRE_REPO_DUMMY);
		if (!dummy) {
			errno = ENOENT;
			return NULL;
		}

		repo = dummy;
	}

	// Allocate a new solvable
	Id id = pakfire_repo_add_solvable(repo);
	if (!id)
		goto ERROR;

	// Create a new package object
	pkg = pakfire_package_create_from_solvable(pakfire, id);
	if (!pkg)
		goto ERROR;

	pkg->repo = pakfire_repo_ref(repo);

	// Set the given attributes
	pakfire_package_set_name(pkg, name);
	pakfire_package_set_evr(pkg, evr);
	pakfire_package_set_arch(pkg, arch);

ERROR:
	if (dummy)
		pakfire_repo_unref(dummy);

	return pkg;
}

static void pakfire_package_free(struct pakfire_package* pkg) {
	if (pkg->repo)
		pakfire_repo_unref(pkg->repo);

	pakfire_unref(pkg->pakfire);
	free(pkg);
}

PAKFIRE_EXPORT struct pakfire_package* pakfire_package_ref(struct pakfire_package* pkg) {
	pkg->nrefs++;

	return pkg;
}

PAKFIRE_EXPORT struct pakfire_package* pakfire_package_unref(struct pakfire_package* pkg) {
	if (--pkg->nrefs > 0)
		return pkg;

	pakfire_package_free(pkg);
	return NULL;
}

PAKFIRE_EXPORT struct pakfire* pakfire_package_get_pakfire(struct pakfire_package* pkg) {
	return pakfire_ref(pkg->pakfire);
}

static Solvable* get_solvable(struct pakfire_package* pkg) {
	Pool* pool = pakfire_get_solv_pool(pkg->pakfire);

	return pool_id2solvable(pool, pkg->id);
}

PAKFIRE_EXPORT int pakfire_package_eq(struct pakfire_package* pkg1, struct pakfire_package* pkg2) {
	return pkg1->id == pkg2->id;
}

PAKFIRE_EXPORT int pakfire_package_cmp(struct pakfire_package* pkg1, struct pakfire_package* pkg2) {
	Pool* pool = pakfire_get_solv_pool(pkg1->pakfire);

	Solvable* s1 = get_solvable(pkg1);
	Solvable* s2 = get_solvable(pkg2);

	// Check names
	const char* str1 = pool_id2str(pool, s1->name);
	const char* str2 = pool_id2str(pool, s2->name);

	int ret = strcmp(str1, str2);
	if (ret)
		return ret;

	// Check the version string
	ret = pakfire_package_evr_cmp(pkg1, pkg2);
	if (ret)
		return ret;

	// Check repositories
	struct pakfire_repo* repo1 = pakfire_package_get_repo(pkg1);
	struct pakfire_repo* repo2 = pakfire_package_get_repo(pkg2);

	if (repo1 && repo2) {
		ret = pakfire_repo_cmp(repo1, repo2);
	}

	pakfire_repo_unref(repo1);
	pakfire_repo_unref(repo2);

	if (ret)
		return ret;

	// Check package architectures
	str1 = pool_id2str(pool, s1->arch);
	str2 = pool_id2str(pool, s2->arch);

	return strcmp(str1, str2);
}

PAKFIRE_EXPORT int pakfire_package_evr_cmp(struct pakfire_package* pkg1, struct pakfire_package* pkg2) {
	Pool* pool = pakfire_get_solv_pool(pkg1->pakfire);

	Solvable* s1 = get_solvable(pkg1);
	Solvable* s2 = get_solvable(pkg2);

	return pool_evrcmp(pool, s1->evr, s2->evr, EVRCMP_COMPARE);
}

Id pakfire_package_id(struct pakfire_package* pkg) {
	return pkg->id;
}

PAKFIRE_EXPORT const char* pakfire_package_get_nevra(struct pakfire_package* pkg) {
	if (!*pkg->nevra) {
		Pool* pool = pakfire_get_solv_pool(pkg->pakfire);
		Solvable* s = get_solvable(pkg);

		pakfire_string_set(pkg->nevra, pool_solvable2str(pool, s));
	}

	return pkg->nevra;
}

PAKFIRE_EXPORT const char* pakfire_package_get_name(struct pakfire_package* pkg) {
	Pool* pool = pakfire_get_solv_pool(pkg->pakfire);
	Solvable* s = get_solvable(pkg);

	return pool_id2str(pool, s->name);
}

PAKFIRE_EXPORT void pakfire_package_set_name(struct pakfire_package* pkg, const char* name) {
	Pool* pool = pakfire_get_solv_pool(pkg->pakfire);
	Solvable* s = get_solvable(pkg);

	s->name = pool_str2id(pool, name, 1);
}

PAKFIRE_EXPORT const char* pakfire_package_get_evr(struct pakfire_package* pkg) {
	Pool* pool = pakfire_get_solv_pool(pkg->pakfire);
	Solvable* s = get_solvable(pkg);

	return pool_id2str(pool, s->evr);
}

PAKFIRE_EXPORT void pakfire_package_set_evr(struct pakfire_package* pkg, const char* evr) {
	Pool* pool = pakfire_get_solv_pool(pkg->pakfire);
	Solvable* s = get_solvable(pkg);

	// Skip empty epoch
	if (pakfire_string_startswith(evr, "0:"))
		evr += 2;

	s->evr = pool_str2id(pool, evr, 1);
}

char* pakfire_package_join_evr(const char* e, const char* v, const char* r) {
	char* buffer = NULL;

	// Check for valid input
	if (!e || !v || !r) {
		errno = EINVAL;
		return NULL;
	}

	// Skip any zeroes in epoch
	while (*e && *e == '0')
		e++;

	// Format string with epoch
	if (*e) {
		if (asprintf(&buffer, "%s:%s-%s", e, v, r) < 0)
			return NULL;

	// Or format it without epoch
	} else {
		if (asprintf(&buffer, "%s-%s", v, r) < 0)
			return NULL;
	}

	return buffer;
}

PAKFIRE_EXPORT const char* pakfire_package_get_arch(struct pakfire_package* pkg) {
	Pool* pool = pakfire_get_solv_pool(pkg->pakfire);
	Solvable* s = get_solvable(pkg);

	return pool_id2str(pool, s->arch);
}

PAKFIRE_EXPORT void pakfire_package_set_arch(struct pakfire_package* pkg, const char* arch) {
	Pool* pool = pakfire_get_solv_pool(pkg->pakfire);
	Solvable* s = get_solvable(pkg);

	s->arch = pool_str2id(pool, arch, 1);
}

int pakfire_package_is_source(struct pakfire_package* pkg) {
	const char* arch = pakfire_package_get_arch(pkg);
	if (!arch)
		return 1;

	return (strcmp(arch, "src") == 0);
}

static void pakfire_package_internalize_repo(struct pakfire_package* pkg) {
	struct pakfire_repo* repo = pakfire_package_get_repo(pkg);
	if (repo) {
		pakfire_repo_internalize(repo, 0);
		pakfire_repo_unref(repo);
	}
}

static unsigned long long pakfire_package_get_num(struct pakfire_package* pkg, Id type) {
	pakfire_package_internalize_repo(pkg);

	Solvable* s = get_solvable(pkg);
	return solvable_lookup_num(s, type, 0);
}

static void pakfire_package_set_num(struct pakfire_package* pkg, Id type, unsigned long long value) {
	Solvable* s = get_solvable(pkg);

	solvable_set_num(s, type, value);
}

static const char* pakfire_package_get_string(struct pakfire_package* pkg, Id key) {
	pakfire_package_internalize_repo(pkg);

	Solvable* s = get_solvable(pkg);

	const char* str = solvable_lookup_str(s, key);
	if (!str || !*str)
		return NULL;

	return str;
}

static void pakfire_package_set_string(struct pakfire_package* pkg, int key, const char* value) {
	Solvable* s = get_solvable(pkg);

	// Unset on empty string
	if (!value || !*value)
		solvable_unset(s, key);

	// Store string
	solvable_set_str(s, key, value);
}

static char** pakfire_package_get_string_array(struct pakfire_package* pkg, Id key) {
	char** strings = NULL;

	Queue ids;
	queue_init(&ids);

	Pool* pool = pakfire_get_solv_pool(pkg->pakfire);
	Solvable* s = get_solvable(pkg);
	solvable_lookup_idarray(s, key, &ids);

	if (ids.count > 0) {
		strings = calloc(ids.count + 1, sizeof(*strings));
		if (!strings) {
			queue_free(&ids);
			return NULL;
		}

		for (int i = 0; i < ids.count; i++) {
			const char* value = pool_id2str(pool, ids.elements[i]);
			strings[i] = strdup(value);
		}

		strings[ids.count] = NULL;
	}

	queue_free(&ids);

	return strings;
}

static void pakfire_package_add_string_array(struct pakfire_package* pkg, Id key, const char* value) {
	if (!value)
		return;

	Solvable* s = get_solvable(pkg);
	solvable_add_poolstr_array(s, key, value);
}

uint64_t pakfire_package_get_dbid(struct pakfire_package* pkg) {
	return pakfire_package_get_num(pkg, RPM_RPMDBID);
}

void pakfire_package_set_dbid(struct pakfire_package* pkg, uint64_t id) {
	pakfire_package_set_num(pkg, RPM_RPMDBID, id);
}

PAKFIRE_EXPORT const char* pakfire_package_get_uuid(struct pakfire_package* pkg) {
	return pakfire_package_get_string(pkg, SOLVABLE_PKGID);
}

PAKFIRE_EXPORT void pakfire_package_set_uuid(struct pakfire_package* pkg, const char* uuid) {
	pakfire_package_set_string(pkg, SOLVABLE_PKGID, uuid);
}

static enum pakfire_digest_types pakfire_package_id2digest(Id id) {
	switch (id) {
		case REPOKEY_TYPE_SHA512:
			return PAKFIRE_DIGEST_SHA2_512;

		case REPOKEY_TYPE_SHA256:
			return PAKFIRE_DIGEST_SHA2_256;
	}

	return 0;
}

PAKFIRE_EXPORT const unsigned char* pakfire_package_get_digest(
		struct pakfire_package* pkg, enum pakfire_digest_types* type) {
	Solvable* s = get_solvable(pkg);
	Id id;

	const unsigned char* checksum = solvable_lookup_bin_checksum(s, SOLVABLE_CHECKSUM, &id);

	// Convert ID to digest type
	*type = pakfire_package_id2digest(id);
	if (!*type) {
		errno = ENOTSUP;
		checksum = NULL;
	}

	return checksum;
}

PAKFIRE_EXPORT const char* pakfire_package_get_hexdigest(
		struct pakfire_package* pkg, enum pakfire_digest_types* type) {
	Solvable* s = get_solvable(pkg);
	Id id;

	const char* checksum = solvable_lookup_checksum(s, SOLVABLE_CHECKSUM, &id);

	// Convert ID to digest type
	*type = pakfire_package_id2digest(id);
	if (!*type) {
		errno = ENOTSUP;
		checksum = NULL;
	}

	return checksum;
}

PAKFIRE_EXPORT int pakfire_package_set_digest(struct pakfire_package* pkg,
		enum pakfire_digest_types type, const unsigned char* digest) {
	Solvable* s = get_solvable(pkg);
	Pool* pool = s->repo->pool;
	Id id;
	int r = 1;

	switch (type) {
		case PAKFIRE_DIGEST_SHA2_256:
			id = REPOKEY_TYPE_SHA256;
			break;

		case PAKFIRE_DIGEST_SHA2_512:
			id = REPOKEY_TYPE_SHA512;
			break;

		default:
			errno = ENOTSUP;
			return 1;
	}

	struct pakfire_repo* repo = pakfire_package_get_repo(pkg);

	Repodata* data = pakfire_repo_get_repodata(repo);
	if (!data)
		goto ERROR;

	repodata_set_bin_checksum(data, s - pool->solvables, SOLVABLE_CHECKSUM, id, digest);

	// Success
	r = 0;

ERROR:
	pakfire_repo_unref(repo);

	return r;
}

PAKFIRE_EXPORT int pakfire_package_set_hexdigest(struct pakfire_package* pkg,
		enum pakfire_digest_types type, const char* hexdigest) {
	const size_t digest_length = pakfire_digest_length(type);

	if (!digest_length) {
		errno = EINVAL;
		return 1;
	}

	// Allocate a buffer for the binary representation of the digest
	unsigned char* digest = alloca(digest_length);
	if (!digest)
		return 1;

	// Convert from hex to binary
	__pakfire_unhexlify(digest, digest_length, hexdigest);

	return pakfire_package_set_digest(pkg, type, digest);
}

PAKFIRE_EXPORT const char* pakfire_package_get_summary(struct pakfire_package* pkg) {
	return pakfire_package_get_string(pkg, SOLVABLE_SUMMARY);
}

PAKFIRE_EXPORT void pakfire_package_set_summary(struct pakfire_package* pkg, const char* summary) {
	pakfire_package_set_string(pkg, SOLVABLE_SUMMARY, summary);
}

PAKFIRE_EXPORT const char* pakfire_package_get_description(struct pakfire_package* pkg) {
	return pakfire_package_get_string(pkg, SOLVABLE_DESCRIPTION);
}

PAKFIRE_EXPORT void pakfire_package_set_description(struct pakfire_package* pkg, const char* description) {
	pakfire_package_set_string(pkg, SOLVABLE_DESCRIPTION, description);
}

PAKFIRE_EXPORT const char* pakfire_package_get_license(struct pakfire_package* pkg) {
	return pakfire_package_get_string(pkg, SOLVABLE_LICENSE);
}

PAKFIRE_EXPORT void pakfire_package_set_license(struct pakfire_package* pkg, const char* license) {
	pakfire_package_set_string(pkg, SOLVABLE_LICENSE, license);
}

PAKFIRE_EXPORT const char* pakfire_package_get_url(struct pakfire_package* pkg) {
	return pakfire_package_get_string(pkg, SOLVABLE_URL);
}

PAKFIRE_EXPORT void pakfire_package_set_url(struct pakfire_package* pkg, const char* url) {
	pakfire_package_set_string(pkg, SOLVABLE_URL, url);
}

PAKFIRE_EXPORT char* pakfire_package_get_groups(struct pakfire_package* pkg) {
	char** groups = pakfire_package_get_string_array(pkg, SOLVABLE_GROUP);
	if (!groups)
		return NULL;

	char* string = pakfire_string_join(groups, " ");

	// Free array
	for (char** group = groups; *group; group++)
		free(*group);
	free(groups);

	return string;
}

PAKFIRE_EXPORT void pakfire_package_set_groups(struct pakfire_package* pkg, const char* groups) {
	char** list = pakfire_string_split(groups, ' ');
	if (!list)
		return;

	for (char** group = list; *group; group++) {
		pakfire_package_add_string_array(pkg, SOLVABLE_GROUP, *group);
		free(*group);
	}

	free(list);
}

PAKFIRE_EXPORT const char* pakfire_package_get_vendor(struct pakfire_package* pkg) {
	return pakfire_package_get_string(pkg, SOLVABLE_VENDOR);
}

PAKFIRE_EXPORT void pakfire_package_set_vendor(struct pakfire_package* pkg, const char* vendor) {
	pakfire_package_set_string(pkg, SOLVABLE_VENDOR, vendor);
}

PAKFIRE_EXPORT const char* pakfire_package_get_distribution(struct pakfire_package* pkg) {
	return pakfire_package_get_string(pkg, SOLVABLE_DISTRIBUTION);
}

PAKFIRE_EXPORT void pakfire_package_set_distribution(struct pakfire_package* pkg, const char* distribution) {
	pakfire_package_set_string(pkg, SOLVABLE_DISTRIBUTION, distribution);
}

PAKFIRE_EXPORT const char* pakfire_package_get_maintainer(struct pakfire_package* pkg) {
	return pakfire_package_get_string(pkg, SOLVABLE_PACKAGER);
}

PAKFIRE_EXPORT void pakfire_package_set_maintainer(struct pakfire_package* pkg, const char* maintainer) {
	pakfire_package_set_string(pkg, SOLVABLE_PACKAGER, maintainer);
}

static int pakfire_package_make_cache_path(struct pakfire_package* pkg) {
	const char* filename = pakfire_package_get_filename(pkg);

	enum pakfire_digest_types digest;
	const char* hexdigest = pakfire_package_get_hexdigest(pkg, &digest);

	if (hexdigest && strlen(hexdigest) >= 3)
		return pakfire_cache_path(pkg->pakfire, pkg->path,
			"%c%c/%s/%s", hexdigest[0], hexdigest[1], hexdigest + 2, filename);

	return pakfire_cache_path(pkg->pakfire, pkg->path, "%s", filename);
}

PAKFIRE_EXPORT const char* pakfire_package_get_path(struct pakfire_package* pkg) {
	int r;

	if (!*pkg->path) {
		const char* base = pakfire_package_get_string(pkg, SOLVABLE_MEDIABASE);
		if (base) {
			const char* filename = pakfire_package_get_filename(pkg);
			if (!filename)
				return NULL;

			pakfire_string_format(pkg->path, "%s/%s", base, filename);
		} else {
			r = pakfire_package_make_cache_path(pkg);
			if (r)
				return NULL;
		}
	}

	return pkg->path;
}

PAKFIRE_EXPORT void pakfire_package_set_path(struct pakfire_package* pkg, const char* path) {
	const char* basename = pakfire_basename(path);
	const char* dirname  = pakfire_dirname(path);

	if (basename)
		pakfire_package_set_string(pkg, SOLVABLE_MEDIAFILE, basename);

	if (dirname)
		pakfire_package_set_string(pkg, SOLVABLE_MEDIABASE, dirname);

	pakfire_string_set(pkg->path, path);
}

// Removes epoch
static const char* evr2vr(const char* evr) {
	const char* p = evr;

	// Skip any leading digits
	for (; *p >= '0' && *p <= '9'; p++);

	// If after the leading digits, we found :, we return the rest of the string
	if (p != evr && *p == ':')
		return ++p;

	return evr;
}

static const char* pakfire_package_make_filename(struct pakfire_package* pkg) {
	if (!*pkg->filename) {
		const char* name = pakfire_package_get_name(pkg);
		const char* evr  = pakfire_package_get_evr(pkg);
		const char* arch = pakfire_package_get_arch(pkg);

		if (!name || !evr || !arch)
			return NULL;

		const char* vr = evr2vr(evr);

		pakfire_string_format(pkg->filename, "%s-%s.%s.pfm", name, vr, arch);
	}

	return pkg->filename;
}

PAKFIRE_EXPORT const char* pakfire_package_get_filename(struct pakfire_package* pkg) {
	const char* filename = pakfire_package_get_string(pkg, SOLVABLE_MEDIAFILE);

	// Generate the filename if not set
	if (!filename)
		filename = pakfire_package_make_filename(pkg);

	return filename;
}

PAKFIRE_EXPORT void pakfire_package_set_filename(struct pakfire_package* pkg, const char* filename) {
	pakfire_package_set_string(pkg, SOLVABLE_MEDIAFILE, filename);
}

PAKFIRE_EXPORT int pakfire_package_is_installed(struct pakfire_package* pkg) {
	Pool* pool = pakfire_get_solv_pool(pkg->pakfire);
	Solvable* s = get_solvable(pkg);

	return pool->installed == s->repo;
}

PAKFIRE_EXPORT size_t pakfire_package_get_downloadsize(struct pakfire_package* pkg) {
	return pakfire_package_get_num(pkg, SOLVABLE_DOWNLOADSIZE);
}

PAKFIRE_EXPORT void pakfire_package_set_downloadsize(struct pakfire_package* pkg, size_t downloadsize) {
	pakfire_package_set_num(pkg, SOLVABLE_DOWNLOADSIZE, downloadsize);
}

PAKFIRE_EXPORT size_t pakfire_package_get_installsize(struct pakfire_package* pkg) {
	return pakfire_package_get_num(pkg, SOLVABLE_INSTALLSIZE);
}

PAKFIRE_EXPORT void pakfire_package_set_installsize(struct pakfire_package* pkg, size_t installsize) {
	pakfire_package_set_num(pkg, SOLVABLE_INSTALLSIZE, installsize);
}

PAKFIRE_EXPORT size_t pakfire_package_get_size(struct pakfire_package* pkg) {
	if (pakfire_package_is_installed(pkg))
		return pakfire_package_get_installsize(pkg);

	return pakfire_package_get_downloadsize(pkg);
}

PAKFIRE_EXPORT const char* pakfire_package_get_build_host(struct pakfire_package* pkg) {
	return pakfire_package_get_string(pkg, SOLVABLE_BUILDHOST);
}

PAKFIRE_EXPORT void pakfire_package_set_build_host(struct pakfire_package* pkg, const char* build_host) {
	pakfire_package_set_string(pkg, SOLVABLE_BUILDHOST, build_host);
}

PAKFIRE_EXPORT const char* pakfire_package_get_build_id(struct pakfire_package* pkg) {
	return pakfire_package_get_string(pkg, SOLVABLE_BUILDVERSION);
}

PAKFIRE_EXPORT void pakfire_package_set_build_id(struct pakfire_package* pkg, const char* build_id) {
	pakfire_package_set_string(pkg, SOLVABLE_BUILDVERSION, build_id);
}

void pakfire_package_set_build_id_from_uuid(struct pakfire_package* pkg, uuid_t* build_id) {
	char buffer[UUID_STR_LEN];

	// Convert the UUID to string
	uuid_unparse_lower(*build_id, buffer);

	pakfire_package_set_build_id(pkg, buffer);
}

PAKFIRE_EXPORT time_t pakfire_package_get_build_time(struct pakfire_package* pkg) {
	return pakfire_package_get_num(pkg, SOLVABLE_BUILDTIME);
}

PAKFIRE_EXPORT void pakfire_package_set_build_time(struct pakfire_package* pkg, time_t build_time) {
	pakfire_package_set_num(pkg, SOLVABLE_BUILDTIME, build_time);
}

PAKFIRE_EXPORT time_t pakfire_package_get_install_time(struct pakfire_package* pkg) {
	return pakfire_package_get_num(pkg, SOLVABLE_INSTALLTIME);
}

PAKFIRE_EXPORT void pakfire_package_set_install_time(struct pakfire_package* pkg, time_t install_time) {
	pakfire_package_set_num(pkg, SOLVABLE_INSTALLTIME, install_time);
}

PAKFIRE_EXPORT const char* pakfire_package_get_source_package(struct pakfire_package* pkg) {
	if (!*pkg->source_nevra) {
		const char* name = pakfire_package_get_source_name(pkg);
		const char* evr  = pakfire_package_get_source_evr(pkg);
		const char* arch = pakfire_package_get_source_arch(pkg);

		// Return nothing if we don't have all information
		if (!name || !evr || !arch)
			return NULL;

		// Format package name
		pakfire_string_format(pkg->source_nevra, "%s-%s.%s", name, evr, arch);
	}

	return pkg->source_nevra;
}

PAKFIRE_EXPORT const char* pakfire_package_get_source_name(struct pakfire_package* pkg) {
	return pakfire_package_get_string(pkg, SOLVABLE_SOURCENAME);
}

PAKFIRE_EXPORT void pakfire_package_set_source_name(struct pakfire_package* pkg, const char* name) {
	pakfire_package_set_string(pkg, SOLVABLE_SOURCENAME, name);
}

PAKFIRE_EXPORT const char* pakfire_package_get_source_evr(struct pakfire_package* pkg) {
	return pakfire_package_get_string(pkg, SOLVABLE_SOURCEEVR);
}

PAKFIRE_EXPORT void pakfire_package_set_source_evr(struct pakfire_package* pkg, const char* evr) {
	// Skip empty epoch
	if (pakfire_string_startswith(evr, "0:"))
		evr += 2;

	pakfire_package_set_string(pkg, SOLVABLE_SOURCEEVR, evr);
}

PAKFIRE_EXPORT const char* pakfire_package_get_source_arch(struct pakfire_package* pkg) {
	return pakfire_package_get_string(pkg, SOLVABLE_SOURCEARCH);
}

PAKFIRE_EXPORT void pakfire_package_set_source_arch(struct pakfire_package* pkg, const char* arch) {
	pakfire_package_set_string(pkg, SOLVABLE_SOURCEARCH, arch);
}

static char** pakfire_package_get_relationlist(
		struct pakfire_package* pkg, Id type, Id marker) {
	char** array = NULL;

	Queue q;
	queue_init(&q);

	Solvable* s = get_solvable(pkg);

	// Fetch all deps
	solvable_lookup_deparray(s, type, &q, marker);

	// Nothing to do if the array was empty
	if (!q.count)
		goto ERROR;

	// Allocate array
	array = calloc(q.count + 1, sizeof(*array));
	if (!array)
		goto ERROR;

	for (int i = 0; i < q.count; i++) {
		const char* dep = pakfire_dep2str(pkg->pakfire, q.elements[i]);

		array[i] = strdup(dep);
	}

ERROR:
	queue_free(&q);

	return array;
}

static void pakfire_package_add_dep(struct pakfire_package* pkg, Id type,
		const char* dep, Id marker) {
	Solvable* s = get_solvable(pkg);

	// Parse the dependency
	Id id = pakfire_str2dep(pkg->pakfire, dep);
	if (!id)
		return;

	solvable_add_deparray(s, type, id, marker);
}

PAKFIRE_EXPORT char** pakfire_package_get_provides(struct pakfire_package* pkg) {
	return pakfire_package_get_relationlist(pkg, SOLVABLE_PROVIDES, -SOLVABLE_FILEMARKER);
}

void pakfire_package_add_provides(struct pakfire_package* pkg, const char* dep) {
	pakfire_package_add_dep(pkg, SOLVABLE_PROVIDES, dep, -SOLVABLE_FILEMARKER);
}

PAKFIRE_EXPORT char** pakfire_package_get_prerequires(struct pakfire_package* pkg) {
	return pakfire_package_get_relationlist(pkg, SOLVABLE_REQUIRES, SOLVABLE_PREREQMARKER);
}

void pakfire_package_add_prerequires(struct pakfire_package* pkg, const char* dep) {
	pakfire_package_add_dep(pkg, SOLVABLE_REQUIRES, dep, SOLVABLE_PREREQMARKER);
}

PAKFIRE_EXPORT char** pakfire_package_get_requires(struct pakfire_package* pkg) {
	return pakfire_package_get_relationlist(pkg, SOLVABLE_REQUIRES, -SOLVABLE_PREREQMARKER);
}

void pakfire_package_add_requires(struct pakfire_package* pkg, const char* dep) {
	pakfire_package_add_dep(pkg, SOLVABLE_REQUIRES, dep, -SOLVABLE_PREREQMARKER);
}

PAKFIRE_EXPORT char** pakfire_package_get_conflicts(struct pakfire_package* pkg) {
	return pakfire_package_get_relationlist(pkg, SOLVABLE_CONFLICTS, 0);
}

void pakfire_package_add_conflicts(struct pakfire_package* pkg, const char* dep) {
	pakfire_package_add_dep(pkg, SOLVABLE_CONFLICTS, dep, 0);
}

PAKFIRE_EXPORT char** pakfire_package_get_obsoletes(struct pakfire_package* pkg) {
	return pakfire_package_get_relationlist(pkg, SOLVABLE_OBSOLETES, 0);
}

void pakfire_package_add_obsoletes(struct pakfire_package* pkg, const char* dep) {
	pakfire_package_add_dep(pkg, SOLVABLE_OBSOLETES, dep, 0);
}

PAKFIRE_EXPORT char** pakfire_package_get_recommends(struct pakfire_package* pkg) {
	return pakfire_package_get_relationlist(pkg, SOLVABLE_RECOMMENDS, 0);
}

void pakfire_package_add_recommends(struct pakfire_package* pkg, const char* dep) {
	pakfire_package_add_dep(pkg, SOLVABLE_RECOMMENDS, dep, 0);
}

PAKFIRE_EXPORT char** pakfire_package_get_suggests(struct pakfire_package* pkg) {
	return pakfire_package_get_relationlist(pkg, SOLVABLE_SUGGESTS, 0);
}

void pakfire_package_add_suggests(struct pakfire_package* pkg, const char* dep) {
	pakfire_package_add_dep(pkg, SOLVABLE_SUGGESTS, dep, 0);
}

PAKFIRE_EXPORT char** pakfire_package_get_supplements(struct pakfire_package* pkg) {
	return pakfire_package_get_relationlist(pkg, SOLVABLE_SUPPLEMENTS, 0);
}

void pakfire_package_add_supplements(struct pakfire_package* pkg, const char* dep) {
	pakfire_package_add_dep(pkg, SOLVABLE_SUPPLEMENTS, dep, 0);
}

PAKFIRE_EXPORT char** pakfire_package_get_enhances(struct pakfire_package* pkg) {
	return pakfire_package_get_relationlist(pkg, SOLVABLE_ENHANCES, 0);
}

void pakfire_package_add_enhances(struct pakfire_package* pkg, const char* dep) {
	pakfire_package_add_dep(pkg, SOLVABLE_ENHANCES, dep, 0);
}

PAKFIRE_EXPORT int pakfire_package_get_reverse_requires(struct pakfire_package* pkg,
		struct pakfire_packagelist** list) {
	Queue matches;
	queue_init(&matches);

	// Reset pointer
	*list = NULL;

	Pool* pool = pakfire_get_solv_pool(pkg->pakfire);

	// Search for any matches
	pool_whatmatchessolvable(pool, SOLVABLE_REQUIRES, pkg->id, &matches, 0);

	// Create a new package list
	int r = pakfire_packagelist_create_from_queue(list, pkg->pakfire, &matches);
	if (r)
		goto ERROR;

ERROR:
	queue_free(&matches);

	return r;
}

static int pakfire_package_has_rich_deps_in_deparray(
		struct pakfire_package* pkg, Id type) {
	int r = 0;

	Solvable* s = get_solvable(pkg);

	Queue q;
	queue_init(&q);

	// Fetch all deps
	solvable_lookup_deparray(s, type, &q, 0);

	// Nothing to do if the array was empty
	if (!q.count)
		goto ERROR;

	for (int i = 0; i < q.count; i++) {
		const char* dep = pakfire_dep2str(pkg->pakfire, q.elements[i]);

		// Is this a rich dependency?
		if (dep && *dep == '(') {
			r = 1;
			break;
		}
	}

ERROR:
	queue_free(&q);

	return r;
}

int pakfire_package_has_rich_deps(struct pakfire_package* pkg) {
	static const Id types[] = {
		// Requires (includes pre-requires)
		SOLVABLE_REQUIRES,
		SOLVABLE_PROVIDES,
		SOLVABLE_CONFLICTS,
		SOLVABLE_OBSOLETES,
		SOLVABLE_RECOMMENDS,
		SOLVABLE_SUGGESTS,
		SOLVABLE_SUPPLEMENTS,
		SOLVABLE_ENHANCES,
		0,
	};

	for (const Id* type = types; *type; type++) {
		int r = pakfire_package_has_rich_deps_in_deparray(pkg, *type);
		if (r)
			return r;
	}

	// No match
	return 0;
}

PAKFIRE_EXPORT struct pakfire_repo* pakfire_package_get_repo(struct pakfire_package* pkg) {
	if (!pkg->repo) {
		Solvable* s = get_solvable(pkg);

		pkg->repo = pakfire_repo_create_from_repo(pkg->pakfire, s->repo);
	}

	return pakfire_repo_ref(pkg->repo);
}

static void pakfire_package_dump_add_line(char** str, const char* key, const char* val) {
	if (val)
		asprintf(str, "%s%-15s: %s\n", *str, key ? key : "", val);
}

static void pakfire_package_dump_add_lines(char** str, const char* key, const char* val) {
	char** lines = pakfire_string_split(val, '\n');
	if (!lines)
		return;

	while (*lines) {
		pakfire_package_dump_add_line(str, key, *lines);
		lines++;
	}
}

static void pakfire_package_dump_add_line_date(char** str, const char* key, time_t date) {
	char buffer[1024];
	int r;

	// Format time
	r = pakfire_strftime(buffer, "%a, %d %b %Y %T %z", date);
	if (r)
		return;

	pakfire_package_dump_add_line(str, key, buffer);
}

static void pakfire_package_dump_add_line_size(char** str, const char* key, size_t size) {
	char buffer[128];

	// Format size in human-readable format
	int r = pakfire_format_size(buffer, size);
	if (r < 0)
		return;

	pakfire_package_dump_add_line(str, key, buffer);
}

static int pakfire_sort_dependencies(const void* p1, const void* p2) {
	const char* dep1 = *(const char**)p1;
	const char* dep2 = *(const char**)p2;

	return strcmp(dep1, dep2);
}

PAKFIRE_EXPORT char* pakfire_package_dump(struct pakfire_package* pkg, int flags) {
	char* string = "";

	// Name
	const char* name = pakfire_package_get_name(pkg);
	pakfire_package_dump_add_line(&string, _("Name"), name);

	// EVR
	const char* evr = pakfire_package_get_evr(pkg);
	pakfire_package_dump_add_line(&string, _("Version"), evr);

	// Arch
	const char* arch = pakfire_package_get_arch(pkg);
	pakfire_package_dump_add_line(&string, _("Arch"), arch);

	// Size
	size_t size = pakfire_package_get_size(pkg);
	if (size)
		pakfire_package_dump_add_line_size(&string, _("Size"), size);

	// Installed Size
	if (pakfire_package_is_installed(pkg)) {
		size_t installsize = pakfire_package_get_installsize(pkg);
		if (installsize)
			pakfire_package_dump_add_line_size(&string, _("Installed Size"), installsize);

	// Download Size
	} else {
		size_t downloadsize = pakfire_package_get_downloadsize(pkg);
		if (downloadsize)
			pakfire_package_dump_add_line_size(&string, _("Download Size"), downloadsize);
	}

	// Repository
	struct pakfire_repo* repo = pakfire_package_get_repo(pkg);
	if (repo) {
		if (!pakfire_repo_name_equals(repo, PAKFIRE_REPO_DUMMY)) {
			const char* repo_name = pakfire_repo_get_name(repo);
			pakfire_package_dump_add_line(&string, _("Repo"), repo_name);
		}

		pakfire_repo_unref(repo);
	}

	// Summary
	const char* summary = pakfire_package_get_summary(pkg);
	pakfire_package_dump_add_line(&string, _("Summary"), summary);

	// Description
	const char* description = pakfire_package_get_description(pkg);
	if (description)
		pakfire_package_dump_add_lines(&string, _("Description"), description);

	// Groups
	const char* groups = pakfire_package_get_groups(pkg);
	if (groups) {
		pakfire_package_dump_add_lines(&string, _("Groups"), groups);
	}

	// URL
	const char* url = pakfire_package_get_url(pkg);
	pakfire_package_dump_add_line(&string, _("URL"), url);

	// License
	const char* license = pakfire_package_get_license(pkg);
	pakfire_package_dump_add_line(&string, _("License"), license);

	if (flags & PAKFIRE_PKG_DUMP_LONG) {
		// Install Time
		time_t install_time = pakfire_package_get_install_time(pkg);
		if (install_time) {
			pakfire_package_dump_add_line_date(&string, _("Install Time"), install_time);
		}

		// Maintainer
		const char* maintainer = pakfire_package_get_maintainer(pkg);
		pakfire_package_dump_add_line(&string, _("Maintainer"), maintainer);

		// Vendor
		const char* vendor = pakfire_package_get_vendor(pkg);
		pakfire_package_dump_add_line(&string, _("Vendor"), vendor);

		// UUID
		const char* uuid = pakfire_package_get_uuid(pkg);
		pakfire_package_dump_add_line(&string, _("UUID"), uuid);

		// Build ID
		const char* build_id = pakfire_package_get_build_id(pkg);
		if (build_id)
			pakfire_package_dump_add_line(&string, _("Build ID"), build_id);

		enum pakfire_digest_types digest = 0;

		// Digest
		const char* hexdigest = pakfire_package_get_hexdigest(pkg, &digest);
		switch (digest) {
			case PAKFIRE_DIGEST_SHA2_512:
				pakfire_package_dump_add_line(&string, _("SHA512 Digest"), hexdigest);
				break;

			case PAKFIRE_DIGEST_SHA2_256:
				pakfire_package_dump_add_line(&string, _("SHA256 Digest"), hexdigest);
				break;

			case PAKFIRE_DIGEST_SHA3_512:
			case PAKFIRE_DIGEST_SHA3_256:
			case PAKFIRE_DIGEST_BLAKE2B512:
			case PAKFIRE_DIGEST_BLAKE2S256:
			case PAKFIRE_DIGEST_UNDEFINED:
				break;
		}

		// Source package
		const char* source_package = pakfire_package_get_source_package(pkg);
		if (source_package)
			pakfire_package_dump_add_line(&string, _("Source Package"), source_package);

		// Build time
		time_t build_time = pakfire_package_get_build_time(pkg);
		pakfire_package_dump_add_line_date(&string, _("Build Time"), build_time);

		// Build host
		const char* build_host = pakfire_package_get_build_host(pkg);
		pakfire_package_dump_add_line(&string, _("Build Host"), build_host);

		// Dependencies

		const struct relation {
			const char* name;
			char** (*get)(struct pakfire_package* pkg);
		} relations[] = {
			{ _("Provides"),     pakfire_package_get_provides, },
			{ _("Pre-Requires"), pakfire_package_get_prerequires, },
			{ _("Requires"),     pakfire_package_get_requires, },
			{ _("Conflicts"),    pakfire_package_get_conflicts, },
			{ _("Obsoletes"),    pakfire_package_get_obsoletes, },
			{ _("Recommends"),   pakfire_package_get_recommends, },
			{ _("Suggests"),     pakfire_package_get_suggests, },
			{ _("Supplements"),  pakfire_package_get_supplements, },
			{ _("Enhances"),     pakfire_package_get_enhances, },
			{ NULL, NULL},
		};

		for (const struct relation* relation = relations; relation->name; relation++) {
			char** deps = relation->get(pkg);
			if (deps) {
				name = relation->name;
				size_t count = 0;

				// Count elements in the list
				for (char** dep = deps; *dep; dep++)
					count++;

				// Sort the list
				qsort(deps, count, sizeof(*deps), pakfire_sort_dependencies);

				// Write it to the console
				for (char** dep = deps; *dep; dep++) {
					pakfire_package_dump_add_line(&string, name, *dep);
					free(*dep);

					// Clear name after first line
					name = NULL;
				}
				free(deps);
			}
		}
	}

	if (flags & PAKFIRE_PKG_DUMP_FILELIST) {
		struct pakfire_filelist* filelist = pakfire_package_get_filelist(pkg);

		const char* prefix = _("Filelist");

		for (unsigned int i = 0; i < pakfire_filelist_size(filelist); i++) {
			struct pakfire_file* file = pakfire_filelist_get(filelist, i);

			const char* path = pakfire_file_get_path(file);
			pakfire_package_dump_add_line(&string, prefix, path);

			pakfire_file_unref(file);

			// Only prefix the first line
			prefix = NULL;
		}

		pakfire_filelist_unref(filelist);
	}

	return string;
}

PAKFIRE_EXPORT struct pakfire_archive* pakfire_package_get_archive(struct pakfire_package* pkg) {
	struct pakfire_archive* archive = NULL;

	// Otherwise open the archive from the cache
	const char* path = pakfire_package_get_path(pkg);
	if (!path)
		return NULL;

	// Open archive
	int r = pakfire_archive_open(&archive, pkg->pakfire, path);
	if (r)
		return NULL;

	return archive;
}

static int pakfire_package_fetch_legacy_filelist(struct pakfire_package* pkg, struct pakfire_filelist* filelist) {
	pakfire_package_internalize_repo(pkg);

	struct pakfire_repo* repo = pakfire_package_get_repo(pkg);
	Solvable* s = get_solvable(pkg);
	Repo* _repo = pakfire_repo_get_repo(repo);
	pakfire_repo_unref(repo);

	int found_marker = 0;

	Id id, *ids;
	ids = _repo->idarraydata + s->provides;
	while((id = *ids++) != 0) {
		const char* path = pakfire_dep2str(pkg->pakfire, id);

		if (found_marker) {
			struct pakfire_file* file;

			int r = pakfire_file_create(&file, pkg->pakfire);
			if (r)
				return r;

			// Set path
			pakfire_file_set_path(file, path);

			r = pakfire_filelist_append(filelist, file);
			if (r)
				return r;

			pakfire_file_unref(file);
			continue;
		}

		if (strcmp(path, "solvable:filemarker") == 0)
			++found_marker;
	}

	return 0;
}

static int pakfire_package_fetch_filelist(struct pakfire_package* pkg, struct pakfire_filelist* filelist) {
	int r;

	pakfire_package_internalize_repo(pkg);

	Solvable* s = get_solvable(pkg);

	Dataiterator di;
	dataiterator_init(&di, s->repo->pool, s->repo, pkg->id,
		SOLVABLE_FILELIST, NULL, SEARCH_FILES | SEARCH_COMPLETE_FILELIST);

	while (dataiterator_step(&di)) {
		struct pakfire_file* file;

		r = pakfire_file_create(&file, pkg->pakfire);
		if (r)
			return r;

		pakfire_file_set_path(file, di.kv.str);

		// Append to filelist
		pakfire_filelist_append(filelist, file);
		pakfire_file_unref(file);
	}
	dataiterator_free(&di);

	// If the file list is empty, we fall back to read files
	// in the older format.
	if (pakfire_filelist_is_empty(filelist)) {
		r = pakfire_package_fetch_legacy_filelist(pkg, filelist);
		if (r)
			return r;
	}

	// Sort the list
	pakfire_filelist_sort(filelist);

	return 0;
}

PAKFIRE_EXPORT struct pakfire_filelist* pakfire_package_get_filelist(struct pakfire_package* pkg) {
	struct pakfire_filelist* filelist = NULL;

	// Create a new filelist
	int r = pakfire_filelist_create(&filelist, pkg->pakfire);
	if (r)
		goto ERROR;

	// Fetch all entries from the repository database
	r = pakfire_package_fetch_filelist(pkg, filelist);
	if (r)
		goto ERROR;

	return filelist;

ERROR:
	if (filelist)
		pakfire_filelist_unref(filelist);

	return NULL;
}

static int pakfire_package_append_file(struct pakfire_package* pkg, const char* path) {
	// Fetch repodata
	struct pakfire_repo* repo = pakfire_package_get_repo(pkg);
	Repodata* repodata = pakfire_repo_get_repodata(repo);
	pakfire_repo_unref(repo);

	const char* basename = pakfire_basename(path);
	const char* dirname  = pakfire_dirname(path);

	// Convert directory into ID
	Id did = repodata_str2dir(repodata, dirname, 1);
	if (!did)
		did = repodata_str2dir(repodata, "/", 1);

	// Add data to list
	repodata_add_dirstr(repodata, pkg->id,
		SOLVABLE_FILELIST, did, basename);

	return 0;
}

static int __pakfire_package_set_filelist(struct pakfire* pakfire,
		struct pakfire_file* file, void* data) {
	struct pakfire_package* pkg = (struct pakfire_package*)data;

	// Fetch the path
	const char* path = pakfire_file_get_path(file);

	return pakfire_package_append_file(pkg, path);
}

PAKFIRE_EXPORT int pakfire_package_set_filelist(
		struct pakfire_package* pkg, struct pakfire_filelist* filelist) {
	return pakfire_filelist_walk(filelist, __pakfire_package_set_filelist, pkg);
}

int pakfire_package_set_filelist_from_string(struct pakfire_package* pkg, const char* files) {
	char* p = NULL;
	int r = 0;

	// Copy files
	char* buffer = strdup(files);
	if (!buffer)
		goto ERROR;

	// Walk through all files
	char* path = strtok_r(buffer, "\n", &p);
	while (path) {
		r = pakfire_package_append_file(pkg, path);
		if (r)
			goto ERROR;

		path = strtok_r(NULL, "\n", &p);
	}

ERROR:
	if (buffer)
		free(buffer);

	return r;
}

static int _pakfire_package_add_json_dependencies(
		struct pakfire_package* pkg,
		struct json_object* json,
		const char* name,
		char** (*func)(struct pakfire_package* pkg)) {
	// Fetch dependencies
	char** dependencies = func(pkg);

	// Nothing to do if there are no dependencies
	if (!dependencies)
		return 0;

	// Add dependencies
	int r = pakfire_json_add_string_array(pkg->pakfire, json, name, dependencies);
	if (r)
		goto ERROR;

ERROR:
	if (dependencies) {
		for (char** dep = dependencies; *dep; dep++)
			free(*dep);
		free(dependencies);
	}

	return r;
}

static int pakfire_package_add_json_dependencies(
		struct pakfire_package* pkg, struct json_object* md) {
	int r = 0;

	// Create new dependencies object
	struct json_object* object = json_object_new_object();
	if (!object)
		return 1;

	// Pre-requires
	r = _pakfire_package_add_json_dependencies(pkg, object,
			"prerequires", pakfire_package_get_prerequires);
	if (r)
		goto ERROR;

	// Requires
	r = _pakfire_package_add_json_dependencies(pkg, object,
			"requires", pakfire_package_get_requires);
	if (r)
		goto ERROR;

	// Provides
	r = _pakfire_package_add_json_dependencies(pkg, object,
			"provides", pakfire_package_get_provides);
	if (r)
		goto ERROR;

	// Conflicts
	r = _pakfire_package_add_json_dependencies(pkg, object,
			"conflicts", pakfire_package_get_conflicts);
	if (r)
		goto ERROR;

	// Obsoletes
	r = _pakfire_package_add_json_dependencies(pkg, object,
			"obsoletes", pakfire_package_get_obsoletes);
	if (r)
		goto ERROR;

	// Recommends
	r = _pakfire_package_add_json_dependencies(pkg, object,
			"recommends", pakfire_package_get_recommends);
	if (r)
		goto ERROR;

	// Suggests
	r = _pakfire_package_add_json_dependencies(pkg, object,
			"suggests", pakfire_package_get_suggests);
	if (r)
		goto ERROR;

	// Supplements
	r = _pakfire_package_add_json_dependencies(pkg, object,
			"supplements", pakfire_package_get_supplements);
	if (r)
		goto ERROR;

	// Enhances
	r = _pakfire_package_add_json_dependencies(pkg, object,
			"enhances", pakfire_package_get_enhances);
	if (r)
		goto ERROR;

	// Add object
	r = json_object_object_add(md, "dependencies", object);
	if (r)
		goto ERROR;

ERROR:
	if (r)
		json_object_put(object);

	return r;
}

static int pakfire_package_add_build_metadata(struct pakfire_package* pkg,
		struct json_object* md) {
	int r;

	// Create a new JSON object
	struct json_object* object = json_object_new_object();
	if (!object)
		return 1;

	// Add pakfire version that generated this metadata
	r = pakfire_json_add_string(pkg->pakfire, object, "pakfire", PACKAGE_VERSION);
	if (r)
		goto ERROR;

	// Write build host
	const char* build_host = pakfire_package_get_build_host(pkg);
	if (build_host) {
		r = pakfire_json_add_string(pkg->pakfire, object, "host", build_host);
		if (r)
			goto ERROR;
	}

	// Write build id
	const char* build_id = pakfire_package_get_build_id(pkg);
	if (build_id) {
		r = pakfire_json_add_string(pkg->pakfire, object, "id", build_id);
		if (r)
			goto ERROR;
	}

	// Write build host
	time_t build_time = pakfire_package_get_build_time(pkg);
	if (build_time) {
		r = pakfire_json_add_integer(pkg->pakfire, object, "time", build_time);
		if (r)
			goto ERROR;
	}

	// Source package name
	const char* name = pakfire_package_get_source_name(pkg);
	if (name) {
		r = pakfire_json_add_string(pkg->pakfire, object, "source-name", name);
		if (r)
			goto ERROR;
	}

	// Source package EVR
	const char* evr = pakfire_package_get_source_evr(pkg);
	if (evr) {
		r = pakfire_json_add_string(pkg->pakfire, object, "source-evr", evr);
		if (r)
			goto ERROR;
	}

	// Source package arch
	const char* arch = pakfire_package_get_source_arch(pkg);
	if (arch) {
		r = pakfire_json_add_string(pkg->pakfire, object, "source-arch", arch);
		if (r)
			goto ERROR;
	}

	// Add object
	r = json_object_object_add(md, "build", object);
	if (r)
		goto ERROR;

ERROR:
	if (r)
		json_object_put(object);

	return r;
}

struct json_object* pakfire_package_to_json(struct pakfire_package* pkg) {
	struct json_object* md = json_object_new_object();
	int r = 0;

	// Name
	const char* name = pakfire_package_get_name(pkg);
	if (name) {
		r = pakfire_json_add_string(pkg->pakfire, md, "name", name);
		if (r)
			goto ERROR;
	}

	// EVR
	const char* evr = pakfire_package_get_evr(pkg);
	if (evr) {
		r = pakfire_json_add_string(pkg->pakfire, md, "evr", evr);
		if (r)
			goto ERROR;
	}

	// Arch
	const char* arch = pakfire_package_get_arch(pkg);
	if (arch) {
		r = pakfire_json_add_string(pkg->pakfire, md, "arch", arch);
		if (r)
			goto ERROR;
	}

	// Vendor
	const char* vendor = pakfire_package_get_vendor(pkg);
	if (vendor) {
		r = pakfire_json_add_string(pkg->pakfire, md, "vendor", vendor);
		if (r)
			goto ERROR;
	}

	// Distribution
	const char* distribution = pakfire_package_get_distribution(pkg);
	if (distribution) {
		r = pakfire_json_add_string(pkg->pakfire, md, "distribution", distribution);
		if (r)
			goto ERROR;
	}

	// UUID
	const char* uuid = pakfire_package_get_uuid(pkg);
	if (uuid) {
		r = pakfire_json_add_string(pkg->pakfire, md, "uuid", uuid);
		if (r)
			goto ERROR;
	}

	// Groups
	char* groups = pakfire_package_get_groups(pkg);
	if (groups) {
		r = pakfire_json_add_string(pkg->pakfire, md, "groups", groups);
		free(groups);
		if (r)
			goto ERROR;
	}

	// Maintainer
	const char* maintainer = pakfire_package_get_maintainer(pkg);
	if (maintainer) {
		r = pakfire_json_add_string(pkg->pakfire, md, "maintainer", maintainer);
		if (r)
			goto ERROR;
	}

	// URL
	const char* url = pakfire_package_get_url(pkg);
	if (url) {
		r = pakfire_json_add_string(pkg->pakfire, md, "url", url);
		if (r)
			goto ERROR;
	}

	// License
	const char* license = pakfire_package_get_license(pkg);
	if (license) {
		r = pakfire_json_add_string(pkg->pakfire, md, "license", license);
		if (r)
			goto ERROR;
	}

	// Summary
	const char* summary = pakfire_package_get_summary(pkg);
	if (summary) {
		r = pakfire_json_add_string(pkg->pakfire, md, "summary", summary);
		if (r)
			goto ERROR;
	}

	// Description
	const char* description = pakfire_package_get_description(pkg);
	if (description) {
		r = pakfire_json_add_string(pkg->pakfire, md, "description", description);
		if (r)
			goto ERROR;
	}

	// Installed package size
	size_t installsize = pakfire_package_get_installsize(pkg);
	r = pakfire_json_add_integer(pkg->pakfire, md, "size", installsize);
	if (r)
		goto ERROR;

	// Generate dependency metadata
	r = pakfire_package_add_json_dependencies(pkg, md);
	if (r)
		goto ERROR;

	// Generate build metadata
	r = pakfire_package_add_build_metadata(pkg, md);
	if (r)
		goto ERROR;

ERROR:
	if (r)
		json_object_put(md);

	return md;
}