[people/ms/pakfire.git] / src / libpakfire / packager.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 <fcntl.h>
#include <linux/limits.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <time.h>
#include <unistd.h>

#include <archive.h>
#include <archive_entry.h>

#include <pakfire/archive.h>
#include <pakfire/constants.h>
#include <pakfire/logging.h>
#include <pakfire/package.h>
#include <pakfire/packager.h>
#include <pakfire/pakfire.h>
#include <pakfire/pwd.h>
#include <pakfire/util.h>

#define BUFFER_SIZE 64 * 1024

struct pakfire_packager {
	struct pakfire* pakfire;
	int nrefs;
	time_t time_created;

	struct pakfire_package* pkg;
	char filename[PATH_MAX];

	// Reader
	struct archive* reader;

	// Payload
	struct archive* payload;
	FILE* fpayload;
	struct archive* mtree;
	FILE* fmtree;
	size_t installsize;

	struct pakfire_scriptlet** scriptlets;
	unsigned int num_scriptlets;
};

static int pakfire_packager_create_mtree(struct pakfire* pakfire, struct archive** mtree,
		FILE** f, const char** fields) {
	char path[] = PAKFIRE_PRIVATE_DIR "/tmp/.pakfire-mtree.XXXXXX";
	int r;

	// Create an mtree
	*mtree = archive_write_new();
	if (!*mtree) {
		ERROR(pakfire, "archive_write_new() failed\n");
		goto ERROR;
	}

	// Use mtree format
	r = archive_write_set_format_mtree(*mtree);
	if (r) {
		ERROR(pakfire, "Could not set format to mtree: %s\n",
			archive_error_string(*mtree));
		goto ERROR;
	}

	// Always compress using Zstd
	r = archive_write_add_filter_zstd(*mtree);
	if (r) {
		ERROR(pakfire, "Could not enable Zstandard compression: %s\n",
			archive_error_string(*mtree));
		goto ERROR;
	}

	// Enable mtree fields
	if (fields) {
		for (const char** field = fields; *field; field++) {
			r = archive_write_set_options(*mtree, *field);
			if (r) {
				ERROR(pakfire, "Could not set mtree options %s: %s\n",
					*field, archive_error_string(*mtree));
				goto ERROR;
			}
		}
	}

	// Create a new temporary file
	*f = pakfire_mktemp(path);
	if (!*f)
		goto ERROR;

	// Unlink the file straight away
	unlink(path);

	// Write mtree to file
	r = archive_write_open_FILE(*mtree, *f);
	if (r)
		goto ERROR;

	return 0;

ERROR:
	if (*mtree) {
		archive_write_free(*mtree);
		*mtree = NULL;
	}

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

	return 1;
}

static int pakfire_packager_create_payload(struct pakfire_packager* p) {
	char path[] = PAKFIRE_PRIVATE_DIR "/tmp/.pakfire-payload.XXXXXX";

	// Do not compress source packages
	const int compress = !pakfire_package_is_source(p->pkg);

	p->payload = archive_write_new();
	if (!p->payload) {
		ERROR(p->pakfire, "archive_write_new() failed\n");
		return 1;
	}

	// Use the PAX format
	int r = archive_write_set_format_pax(p->payload);
	if (r) {
		ERROR(p->pakfire, "Could not set format to PAX: %s\n",
			archive_error_string(p->payload));
		return r;
	}

	// Add filters to compress the payload
	if (compress) {
		// Enable Zstd
		r = archive_write_add_filter_zstd(p->payload);
		if (r) {
			ERROR(p->pakfire, "Could not enable Zstandard compression: %s\n",
				archive_error_string(p->payload));
			return r;
		}

		// Set compression level to highest
		r = archive_write_set_filter_option(p->payload, NULL, "compression-level", "22");
		if (r) {
			ERROR(p->pakfire, "Could not set Zstandard compression level: %s\n",
				archive_error_string(p->payload));
			return r;
		}

		// Add feature marker
		pakfire_package_add_requires(p->pkg, "pakfire(Compress-Zstandard)");

		// Do not pad the last block
		archive_write_set_bytes_in_last_block(p->payload, 1);
	}

	// Create a new temporary file
	p->fpayload = pakfire_mktemp(path);
	if (!p->fpayload)
		return 1;

	// Unlink the file straight away
	unlink(path);

	// Write archive to file
	r = archive_write_open_FILE(p->payload, p->fpayload);
	if (r)
		return r;

	static const char* mtree_fields[] = {
		// Disable the default
		"!all",

		// Enable standard file fields
		"device",
		"gname",
		"link",
		"mode",
		"nlink",
		"size",
		"time",
		"type",
		"uname",

		// Enable cryptographic checksums
		"sha512",
		"sha256",

		NULL,
	};

	// Create an mtree
	r = pakfire_packager_create_mtree(p->pakfire, &p->mtree, &p->fmtree, mtree_fields);
	if (r) {
		ERROR(p->pakfire, "Could not create mtree\n");
		return r;
	}

	return 0;
}

static void pakfire_packager_free(struct pakfire_packager* packager) {
	// Scriptlets
	if (packager->scriptlets) {
		for (unsigned int i = 0; i < packager->num_scriptlets; i++)
			pakfire_scriptlet_unref(packager->scriptlets[i]);
		free(packager->scriptlets);
	}

	// Payload
	if (packager->payload)
		archive_write_free(packager->payload);

	if (packager->fpayload)
		fclose(packager->fpayload);

	// mtree
	if (packager->mtree)
		archive_write_free(packager->mtree);

	if (packager->fmtree)
		fclose(packager->fmtree);

	if (packager->reader)
		archive_read_free(packager->reader);

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

int pakfire_packager_create(struct pakfire_packager** packager,
		struct pakfire_package* pkg) {
	struct pakfire_packager* p = calloc(1, sizeof(*p));
	if (!p)
		return ENOMEM;

	int r = 1;

	// Save creation time
	p->time_created = time(NULL);

	// Initialize reference counting
	p->nrefs = 1;

	// Store a reference to Pakfire
	p->pakfire = pakfire_package_get_pakfire(pkg);

	// Store a reference to the package
	p->pkg = pakfire_package_ref(pkg);

	// Create reader
	p->reader = pakfire_make_archive_disk_reader(p->pakfire, 1);
	if (!p->reader)
		goto ERROR;

	// Start payload
	r = pakfire_packager_create_payload(p);
	if (r)
		goto ERROR;

	*packager = p;

	return 0;

ERROR:
	pakfire_packager_free(p);

	return r;
}

struct pakfire_packager* pakfire_packager_ref(
		struct pakfire_packager* packager) {
	++packager->nrefs;

	return packager;
}

struct pakfire_packager* pakfire_packager_unref(
		struct pakfire_packager* packager) {
	if (--packager->nrefs > 0)
		return packager;

	pakfire_packager_free(packager);

	return NULL;
}

const char* pakfire_packager_filename(struct pakfire_packager* packager) {
	if (!*packager->filename) {
		const char* filename = pakfire_package_get_filename(packager->pkg);

		// Add arch
		if (pakfire_package_is_source(packager->pkg))
			pakfire_string_set(packager->filename, filename);
		else {
			const char* arch = pakfire_package_get_arch(packager->pkg);

			pakfire_string_format(packager->filename, "%s/%s", arch, filename);
		}
	}

	return packager->filename;
}

static int pakfire_packager_copy_data(struct pakfire_packager* packager,
		struct archive* a, FILE* f) {
	char buffer[BUFFER_SIZE];

	rewind(f);

	while (!feof(f)) {
		// Read a block from file
		size_t bytes_read = fread(buffer, 1, sizeof(buffer), f);

		// Check if any error occured
		if (ferror(f)) {
			ERROR(packager->pakfire, "Error reading from file: %m\n");
			return 1;
		}

		// Write the block to the archive
		ssize_t bytes_written = archive_write_data(a, buffer, bytes_read);
		if (bytes_written < 0) {
			ERROR(packager->pakfire, "Error writing data to archive: %s\n",
				archive_error_string(a));
			return 1;
		}
	}

	return 0;
}

static struct archive_entry* pakfire_packager_create_file(
		struct pakfire_packager* packager, const char* filename, size_t size, mode_t mode) {
	// Create a new file entry
	struct archive_entry* entry = archive_entry_new();
	if (!entry)
		return NULL;

	// Set filename
	archive_entry_set_pathname(entry, filename);

	// This is a regular file
    archive_entry_set_filetype(entry, AE_IFREG);
    archive_entry_set_perm(entry, mode);

	// Set size
	archive_entry_set_size(entry, size);

	// Set ownership
	archive_entry_set_uname(entry, "root");
	archive_entry_set_uid(entry, 0);
	archive_entry_set_gname(entry, "root");
	archive_entry_set_gid(entry, 0);

	// Set times
	archive_entry_set_birthtime(entry, packager->time_created, 0);
	archive_entry_set_ctime(entry, packager->time_created, 0);
	archive_entry_set_mtime(entry, packager->time_created, 0);
	archive_entry_set_atime(entry, packager->time_created, 0);

	return entry;
}

static int pakfire_packager_write_file_from_buffer(struct pakfire_packager* packager,
		struct archive* a, struct archive* mtree, const char* filename, mode_t mode, const char* buffer) {
	size_t size = strlen(buffer);

	// Create a new file
	struct archive_entry* entry = pakfire_packager_create_file(packager, filename, size, mode);
	if (!entry) {
		ERROR(packager->pakfire, "Could not create file '%s'\n", filename);
		return 1;
	}

	// This is the end of the header
	int r = archive_write_header(a, entry);
	if (r) {
		ERROR(packager->pakfire, "Error writing header: %s\n", archive_error_string(a));
		goto ERROR;
	}

	// Write content
	r = archive_write_data(a, buffer, strlen(buffer));
	if (r < 0) {
		ERROR(packager->pakfire, "Error writing data: %s\n", archive_error_string(a));
		goto ERROR;
	}

	// Add this file to the mtree
	if (mtree) {
		r = archive_write_header(mtree, entry);
		if (r) {
			ERROR(packager->pakfire, "Error adding file to mtree: %s\n",
				archive_error_string(mtree));
			goto ERROR;
		}
	}

	// Success
	r = 0;

ERROR:
	archive_entry_free(entry);

	return r;
}

static int pakfire_packager_write_format(struct pakfire_packager* packager,
		struct archive* a) {
	const char buffer[] = TO_STRING(PACKAGE_FORMAT) "\n";

	DEBUG(packager->pakfire, "Writing package format\n");

	int r = pakfire_packager_write_file_from_buffer(packager, a, NULL,
		PAKFIRE_ARCHIVE_FN_FORMAT, 0444, buffer);
	if (r)
		return r;

	// Add package format marker
	pakfire_package_add_requires(packager->pkg,
		"pakfire(PackageFormat-" TO_STRING(PACKAGE_FORMAT) ")");

	return 0;
}

static char* pakfire_package_make_metadata(struct pakfire_packager* packager) {
	struct pakfire_package* pkg = packager->pkg;

	char* buffer = NULL;
	int r;

	// Print version information
	r = asprintf(&buffer, "# Pakfire %s\n\n", PACKAGE_VERSION);
	if (r < 0)
		goto ERROR;

	// Write package information
	r = asprintf(&buffer, "%s# Package information\npackage\n", buffer);
	if (r < 0)
		goto ERROR;

	// Write package name
	r = asprintf(&buffer, "%s\tname        = %s\n", buffer, pakfire_package_get_name(pkg));
	if (r < 0)
		goto ERROR;

	// Write package EVR
	r = asprintf(&buffer, "%s\tevr         = %s\n", buffer, pakfire_package_get_evr(pkg));
	if (r < 0)
		goto ERROR;

	// Write package arch
	r = asprintf(&buffer, "%s\tarch        = %s\n", buffer, pakfire_package_get_arch(pkg));
	if (r < 0)
		goto ERROR;

	// Write package UUID
	r = asprintf(&buffer, "%s\tuuid        = %s\n", buffer, pakfire_package_get_uuid(pkg));
	if (r < 0)
		goto ERROR;

	// Write package groups
	const char* groups = pakfire_package_get_groups(pkg);
	if (groups) {
		r = asprintf(&buffer, "%s\tgroups      = %s\n", buffer, groups);
		if (r < 0)
			goto ERROR;
	}

	// Write package maintainer
	const char* maintainer = pakfire_package_get_maintainer(pkg);
	if (maintainer) {
		r = asprintf(&buffer, "%s\tmaintainer  = %s\n", buffer, maintainer);
		if (r < 0)
			goto ERROR;
	}

	// Write package url
	const char* url = pakfire_package_get_url(pkg);
	if (url) {
		r = asprintf(&buffer, "%s\turl         = %s\n", buffer, url);
		if (r < 0)
			goto ERROR;
	}

	// Write package license
	const char* license = pakfire_package_get_license(pkg);
	if (license) {
		r = asprintf(&buffer, "%s\tlicense     = %s\n", buffer, license);
		if (r < 0)
			goto ERROR;
	}

	// Write package summary
	const char* summary = pakfire_package_get_summary(pkg);
	if (summary) {
		r = asprintf(&buffer, "%s\tsummary     = %s\n", buffer, summary);
		if (r < 0)
			goto ERROR;
	}

	// XXX description

	size_t size = pakfire_package_get_installsize(pkg);
	r = asprintf(&buffer, "%s\tsize        = %zu\n", buffer, size);
	if (r < 0)
		goto ERROR;

	// End package block
	r = asprintf(&buffer, "%send\n\n", buffer);
	if (r < 0)
		goto ERROR;

	// Write build information
	r = asprintf(&buffer, "%s# Build information\nbuild\n", buffer);
	if (r < 0)
		goto ERROR;

	// Write build host
	const char* build_host = pakfire_package_get_build_host(pkg);
	if (build_host) {
		r = asprintf(&buffer, "%s\thost        = %s\n", buffer, build_host);
		if (r < 0)
			goto ERROR;
	}

	// Write build id
	const char* build_id = pakfire_package_get_build_id(pkg);
	if (build_id) {
		r = asprintf(&buffer, "%s\tid          = %s\n", buffer, build_id);
		if (r < 0)
			goto ERROR;
	}

	// Write build host
	time_t build_time = pakfire_package_get_build_time(pkg);
	if (build_host) {
		r = asprintf(&buffer, "%s\ttime        = %lu\n", buffer, build_time);
		if (r < 0)
			goto ERROR;
	}

	// End build block
	r = asprintf(&buffer, "%send\n\n", buffer);
	if (r < 0)
		goto ERROR;

#if 0
	// Write distribution information
	r = asprintf(&buffer, "%s# Distribution information\ndistribution\n", buffer);
	if (r < 0)
		goto ERROR;

	// End distribution block
	r = asprintf(&buffer, "%send\n\n", buffer);
	if (r < 0)
		goto ERROR;
#endif

	// Write dependency information
	r = asprintf(&buffer, "%s# Dependency information\ndependencies\n", buffer);
	if (r < 0)
		goto ERROR;

	const struct dependencies {
		const char* type;
		char** (*func)(struct pakfire_package* pkg);
	} dependencies[] = {
		{ "prerequires", pakfire_package_get_prerequires },
		{ "requires",    pakfire_package_get_requires },
		{ "provides",    pakfire_package_get_provides },
		{ "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 },
	};

	for (const struct dependencies* d = dependencies; d->type; d++) {
		char** list = d->func(pkg);
		if (!list)
			continue;

		// Write header
		r = asprintf(&buffer, "%s\t%s\n", buffer, d->type);
		if (r < 0) {
			goto ERROR;
		}

		for (char** dep = list; *dep; dep++) {
			asprintf(&buffer, "%s\t\t%s\n", buffer, *dep);
			free(*dep);
		}
		free(list);

		// End block
		r = asprintf(&buffer, "%s\tend\n", buffer);
		if (r < 0)
			goto ERROR;
	}

	// End dependencies block
	r = asprintf(&buffer, "%send\n\n", buffer);
	if (r < 0)
		goto ERROR;

	// EOF
	r = asprintf(&buffer, "%s# EOF\n", buffer);
	if (r < 0)
		goto ERROR;

	return buffer;

ERROR:
	if (buffer)
		free(buffer);

	return NULL;
}

static int pakfire_packager_write_metadata(struct pakfire_packager* packager,
		struct archive* a, struct archive* mtree) {
	// Make metadata
	char* buffer = pakfire_package_make_metadata(packager);
	if (!buffer)
		return 1;

	DEBUG(packager->pakfire, "Generated package metadata:\n%s", buffer);

	// Write buffer
	int r = pakfire_packager_write_file_from_buffer(packager, a, mtree,
		PAKFIRE_ARCHIVE_FN_METADATA, 0444, buffer);

	free(buffer);

	return r;
}

static int pakfire_packager_write_archive(struct pakfire_packager* packager,
		struct archive* a, struct archive* mtree, const char* filename,
		struct archive** payload, FILE* f) {
	struct stat st;

	DEBUG(packager->pakfire, "Writing '%s' to package\n", filename);

	// Close the payload
	if (*payload) {
		archive_write_free(*payload);
		*payload = NULL;
	}

	// Reset fd to beginning of the file
	rewind(f);

	int fd = fileno(f);

	// Stat the payload file
	int r = fstat(fd, &st);
	if (r) {
		ERROR(packager->pakfire, "stat() on fd %d failed: %m\n", fd);
		return 1;
	}

	// Create a new file
	struct archive_entry* entry = pakfire_packager_create_file(packager,
			filename, st.st_size, 0444);
	if (!entry)
		return 1;

	// This is the end of the header
	r = archive_write_header(a, entry);
	if (r) {
		ERROR(packager->pakfire, "Error writing header: %s\n", archive_error_string(a));
		goto ERROR;
	}

	// Copy data
	r = pakfire_packager_copy_data(packager, a, f);
	if (r) {
		const char* error = archive_error_string(a);
		if (!error)
			error = strerror(errno);

		ERROR(packager->pakfire, "Could not copy payload: %s\n", error);
		goto ERROR;
	}

	// Add this file to the mtree
	if (mtree) {
		r = archive_write_header(mtree, entry);
		if (r) {
			ERROR(packager->pakfire, "Error adding file to mtree: %s\n",
				archive_error_string(mtree));
			goto ERROR;
		}

		r = pakfire_packager_copy_data(packager, mtree, f);
		if (r) {
			ERROR(packager->pakfire, "Error copying data to mtree: %s\n",
				archive_error_string(mtree));
			goto ERROR;
		}
	}

	// Success
	r = 0;

ERROR:
	archive_entry_free(entry);

	return r;
}

static int pakfire_packager_write_scriptlet(struct pakfire_packager* packager,
		struct archive* a, struct archive* mtree, struct pakfire_scriptlet* scriptlet) {
	char filename[PATH_MAX];
	size_t size;
	int r;

	// Fetch type
	const char* type = pakfire_scriptlet_get_type(scriptlet);

	DEBUG(packager->pakfire, "Writing scriptlet '%s' to package\n", type);

	// Make filename
	r = pakfire_string_format(filename, "scriptlet/%s", type);
	if (r < 0)
		return r;

	// Fetch scriptlet
	const char* data = pakfire_scriptlet_get_data(scriptlet, &size);

	// Write file
	return pakfire_packager_write_file_from_buffer(packager, a, mtree, filename, 0544, data);
}

/*
	This function is being called at the end when all data has been added to the package.

	It will create a new archive and write the package to the given file descriptor.
*/
int pakfire_packager_finish(struct pakfire_packager* packager, FILE* f) {
	struct archive* mtree = NULL;
	FILE* fmtree = NULL;
	int r = 1;

	// Store total instal size
	pakfire_package_set_installsize(packager->pkg, packager->installsize);

	// Open a new archive
	struct archive* a = archive_write_new();
	if (!a) {
		ERROR(packager->pakfire, "archive_write_new() failed\n");
		goto ERROR;
	}

	// Use the PAX format
	r = archive_write_set_format_pax(a);
	if (r) {
		ERROR(packager->pakfire, "Could not set format to PAX: %s\n",
			archive_error_string(a));
		goto ERROR;
	}

	// Write archive to f
	r = archive_write_open_FILE(a, f);
	if (r) {
		ERROR(packager->pakfire, "archive_write_open_FILE() failed: %s\n",
			archive_error_string(a));
		goto ERROR;
	}

	static const char* mtree_fields[] = {
		// Disable everything
		"!all",

		// File type is mandatory
		"type",

		// Include the file size
		"size",

		// Add the checksums
		"sha512",
		"sha256",

		NULL,
	};

	// Create an mtree for the checksums
	r = pakfire_packager_create_mtree(packager->pakfire, &mtree, &fmtree, mtree_fields);
	if (r) {
		ERROR(packager->pakfire, "Could not create mtree\n");
		goto ERROR;
	}

	// Start with the format file
	r = pakfire_packager_write_format(packager, a);
	if (r) {
		ERROR(packager->pakfire, "Could not add format file to archive: %s\n",
			archive_error_string(a));
		goto ERROR;
	}

	// Write the metadata
	r = pakfire_packager_write_metadata(packager, a, mtree);
	if (r) {
		ERROR(packager->pakfire, "Could not add metadata file to archive: %s\n",
			archive_error_string(a));
		goto ERROR;
	}

	// Write the filelist in mtree format
	r = pakfire_packager_write_archive(packager, a, mtree, PAKFIRE_ARCHIVE_FN_FILELIST,
		&packager->mtree, packager->fmtree);
	if (r) {
		ERROR(packager->pakfire, "Could not add filelist to archive: %s\n",
			archive_error_string(a));
		goto ERROR;
	}

	// Write the payload
	r = pakfire_packager_write_archive(packager, a, mtree, PAKFIRE_ARCHIVE_FN_PAYLOAD,
		&packager->payload, packager->fpayload);
	if (r) {
		ERROR(packager->pakfire, "Could not add payload to archive: %s\n",
			archive_error_string(a));
		goto ERROR;
	}

	// Write scriptlets
	for (unsigned int i = 0; i < packager->num_scriptlets; i++) {
		r = pakfire_packager_write_scriptlet(packager, a, mtree, packager->scriptlets[i]);
		if (r) {
			ERROR(packager->pakfire, "Could not add scriptlet to the archive: %m\n");
			goto ERROR;
		}
	}

	// Finish checksums
	r = archive_write_finish_entry(mtree);
	if (r) {
		ERROR(packager->pakfire, "Could not finish mtree: %s\n",
			archive_error_string(mtree));
		goto ERROR;
	}

	// Write checksums
	r = pakfire_packager_write_archive(packager, a, NULL, PAKFIRE_ARCHIVE_FN_CHECKSUMS,
		&mtree, fmtree);
	if (r) {
		ERROR(packager->pakfire, "Could not add checksums to archive: %s\n",
			archive_error_string(a));
		goto ERROR;
	}

	// Success
	r = 0;

ERROR:
	if (a)
		archive_write_free(a);
	if (mtree)
		archive_write_free(mtree);
	if (fmtree)
		fclose(fmtree);

	return r;
}

int pakfire_packager_finish_to_directory(struct pakfire_packager* packager,
		const char* target) {
	char path[PATH_MAX];
	char tmppath[PATH_MAX];
	int r = 1;

	// target cannot be empty
	if (!target) {
		errno = EINVAL;
		return 1;
	}

	// Get the filename of the package
	const char* filename = pakfire_packager_filename(packager);
	if (!filename) {
		ERROR(packager->pakfire, "Could not generate filename for package: %m\n");
		r = 1;
		goto ERROR;
	}

	// Make the package path
	r = pakfire_string_format(path, "%s/%s", target, filename);
	if (r < 0)
		goto ERROR;

	// Create the parent directory
	r = pakfire_mkparentdir(path, 0);
	if (r)
		goto ERROR;

	// Create a temporary file in the target directory
	r = pakfire_string_format(tmppath, "%s.XXXXXX", path);
	if (r < 0)
		goto ERROR;

	// Create a temporary result file
	FILE* f = pakfire_mktemp(tmppath);
	if (!f)
		goto ERROR;

	// Write the finished package
	r = pakfire_packager_finish(packager, f);
	fclose(f);

	if (r) {
		ERROR(packager->pakfire, "pakfire_packager_finish() failed: %m\n");
		goto ERROR;
	}

	// Move the temporary file to destination
	r = rename(tmppath, path);
	if (r) {
		ERROR(packager->pakfire, "Could not move %s to %s: %m\n", tmppath, path);
		goto ERROR;
	}

	INFO(packager->pakfire, "Package written to %s\n", path);

	// Success
	r = 0;

ERROR:
	// Remove temporary file
	if (r && *tmppath)
		unlink(tmppath);

	return r;
}

int pakfire_packager_add(struct pakfire_packager* packager,
		const char* sourcepath, const char* path) {
	FILE* f = NULL;

	// Check if path is set
	if (!sourcepath)
		return EINVAL;

	// Use basename if path isn't set
	if (!path) {
		path = strrchr(sourcepath, '/');
		if (path)
			path++;
	}

	// Payload has already been closed
	if (!packager->payload)
		return EINVAL;

	// Create a new file entry
	struct archive_entry* entry = archive_entry_new();
	if (!entry)
		return ENOMEM;

	DEBUG(packager->pakfire, "Adding '%s' to archive (from %s)\n", path, sourcepath);

	// Set the source path
	archive_entry_copy_sourcepath(entry, sourcepath);

	// Set path in archive
	if (path)
		archive_entry_set_pathname(entry, path);

	// Read all attributes from file
	int r = archive_read_disk_entry_from_file(packager->reader, entry, -1, NULL);
	if (r) {
		ERROR(packager->pakfire, "Could not read attributes from %s: %m\n", path);
		goto ERROR;
	}

	// Write the header
	r = archive_write_header(packager->payload, entry);
	if (r) {
		ERROR(packager->pakfire, "Error writing file header: %s\n",
			archive_error_string(packager->payload));
		goto ERROR;
	}

	// Copy the data of regular files
	if (archive_entry_filetype(entry) == AE_IFREG) {
		f = fopen(sourcepath, "r");
		if (!f) {
			ERROR(packager->pakfire, "Could not open %s: %m\n", sourcepath);
			r = errno;
			goto ERROR;
		}

		r = pakfire_packager_copy_data(packager, packager->payload, f);
		if (r)
			goto ERROR;
	}

	// Write to mtree
	r = archive_write_header(packager->mtree, entry);
	if (r) {
		ERROR(packager->pakfire, "Adding file to mtree failed: %s\n",
			archive_error_string(packager->mtree));
		goto ERROR;
	}

	// Increment installsize
	packager->installsize += archive_entry_size(entry);

	// Successful
	r = 0;

ERROR:
	if (entry)
		archive_entry_free(entry);

	if (f)
		fclose(f);

	return r;
}

int pakfire_packager_add_scriptlet(struct pakfire_packager* packager,
		struct pakfire_scriptlet* scriptlet) {
	if (!scriptlet) {
		errno = EINVAL;
		return 1;
	}

	// Extend array
	packager->scriptlets = reallocarray(packager->scriptlets,
		packager->num_scriptlets + 1, sizeof(*packager->scriptlets));
	if (!packager->scriptlets)
		return 1;

	// Append scriptlet
	packager->scriptlets[packager->num_scriptlets++] = pakfire_scriptlet_ref(scriptlet);

	return 0;
}