[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 <json.h>

#include <pakfire/archive.h>
#include <pakfire/compress.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/string.h>
#include <pakfire/util.h>

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 pakfire_filelist* filelist;

	// Scriptlets
	struct pakfire_scriptlet** scriptlets;
	unsigned int num_scriptlets;

	// Digests
	unsigned int digests;
};

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);
	}

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

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

int pakfire_packager_create(struct pakfire_packager** packager,
		struct pakfire* pakfire, 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_ref(pakfire);

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

	// Use the default digests
	p->digests = PAKFIRE_PACKAGER_DIGESTS;

	// Set build host
	pakfire_package_set_build_host(pkg, pakfire_hostname());

	// Set build time
	pakfire_package_set_build_time(pkg, p->time_created);

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

	// Create filelist
	r = pakfire_filelist_create(&p->filelist, p->pakfire);
	if (r)
		goto ERROR;

	// Add a requirement for the cryptographic algorithms we are using
	if (p->digests & PAKFIRE_DIGEST_SHA3_512)
		pakfire_package_add_requires(p->pkg, "pakfire(Digest-SHA3-512)");
	if (p->digests & PAKFIRE_DIGEST_SHA3_256)
		pakfire_package_add_requires(p->pkg, "pakfire(Digest-SHA3-256)");
	if (p->digests & PAKFIRE_DIGEST_BLAKE2B512)
		pakfire_package_add_requires(p->pkg, "pakfire(Digest-BLAKE2b512)");
	if (p->digests & PAKFIRE_DIGEST_BLAKE2S256)
		pakfire_package_add_requires(p->pkg, "pakfire(Digest-BLAKE2s256)");
	if (p->digests & PAKFIRE_DIGEST_SHA2_512)
		pakfire_package_add_requires(p->pkg, "pakfire(Digest-SHA2-512)");
	if (p->digests & PAKFIRE_DIGEST_SHA2_256)
		pakfire_package_add_requires(p->pkg, "pakfire(Digest-SHA2-256)");

	*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 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, 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;
	}

	// 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,
		"pakfire-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_packager_make_metadata(struct pakfire_packager* packager) {
	char* result = NULL;

	// Convert all package metadata to JSON
	struct json_object* md = pakfire_package_to_json(packager->pkg);
	if (!md)
		goto ERROR;

	// Serialize JSON to file
	const char* s = json_object_to_json_string_ext(md, 0);
	if (!s)
		goto ERROR;

	// Copy result onto heap
	result = strdup(s);
	if (!result)
		goto ERROR;

ERROR:
	// Free metadata
	if (md)
		json_object_put(md);

	return result;
}

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

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

	// Write buffer
	int r = pakfire_packager_write_file_from_buffer(packager, a,
		".PKGINFO", 0444, buffer);

	free(buffer);

	return r;
}

static int pakfire_packager_write_scriptlet(struct pakfire_packager* packager,
		struct archive* a, 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, ".scriptlets/%s", type);
	if (r)
		return r;

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

	// Write file
	return pakfire_packager_write_file_from_buffer(packager, a, 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* a = NULL;
	int r = 1;

	const char* nevra = pakfire_package_get_nevra(packager->pkg);

	// Add requires feature markers
	if (pakfire_package_has_rich_deps(packager->pkg))
		pakfire_package_add_requires(packager->pkg, "pakfire(RichDependencies)");

	// Add filelist
	r = pakfire_package_set_filelist(packager->pkg, packager->filelist);
	if (r)
		goto ERROR;

	const size_t installsize = pakfire_filelist_total_size(packager->filelist);

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

	// Dump package metadata
	char* dump = pakfire_package_dump(packager->pkg, PAKFIRE_PKG_DUMP_LONG);
	if (dump) {
		INFO(packager->pakfire, "%s\n", dump);
		free(dump);
	}

	// Open a new archive
	a = archive_write_new();
	if (!a) {
		ERROR(packager->pakfire, "archive_write_new() failed\n");
		r = 1;
		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;
	}

	// Store any extended attributes in the SCHILY headers
	r = archive_write_set_format_option(a, "pax", "xattrheader", "SCHILY");
	if (r) {
		ERROR(packager->pakfire, "Could not set xattrheader option: %s\n",
			archive_error_string(a));
		return r;
	}

	// Enable Zstd
	r = archive_write_add_filter_zstd(a);
	if (r) {
		ERROR(packager->pakfire, "Could not enable Zstandard compression: %s\n",
			archive_error_string(a));
		return r;
	}

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

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

	// Do not pad the last block
	archive_write_set_bytes_in_last_block(a, 1);

	// 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;
	}

	// 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);
	if (r) {
		ERROR(packager->pakfire, "Could not add metadata file 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, packager->scriptlets[i]);
		if (r) {
			ERROR(packager->pakfire, "Could not add scriptlet to the archive: %m\n");
			goto ERROR;
		}
	}

	// Write the payload
	r = pakfire_compress(packager->pakfire, a, packager->filelist, nevra,
		PAKFIRE_COMPRESS_SHOW_THROUGHPUT, PAKFIRE_PACKAGER_DIGESTS);

	// Flush all buffers to disk
	fflush(f);

	// Success
	r = 0;

ERROR:
	if (a)
		archive_write_free(a);

	return r;
}

int pakfire_packager_finish_to_directory(struct pakfire_packager* packager,
		const char* target, char** result) {
	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)
		goto ERROR;

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

	// Create a temporary file in the target directory
	r = pakfire_string_format(tmppath, "%s.XXXXXX", path);
	if (r)
		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);

	// Store result path if requested
	if (result) {
		*result = strdup(path);
		if (!*result) {
			r = 1;
			goto ERROR;
		}
	}

	// Success
	r = 0;

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

	return r;
}

int pakfire_packager_add_file(struct pakfire_packager* packager, struct pakfire_file* file) {
	// Check input
	if (!file) {
		errno = EINVAL;
		return 1;
	}

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

	// Files cannot have an empty path
	if (!*path) {
		ERROR(packager->pakfire, "Cannot add a file with an empty path\n");
		errno = EPERM;
		return 1;

	// Hidden files cannot be added
	} else if (*path == '.') {
		ERROR(packager->pakfire, "Hidden files cannot be added to a package: %s\n", path);
		errno = EPERM;
		return 1;
	}

	DEBUG(packager->pakfire, "Adding file to payload: %s\n", path);

	// Overwrite a couple of things for source archives
	if (pakfire_package_is_source(packager->pkg)) {
		// Reset permissions
		pakfire_file_set_perms(file, 0644);

		// Reset file ownership
		pakfire_file_set_user(file, "root");
		pakfire_file_set_group(file, "root");
	}

	// Append the file to the filelist
	return pakfire_filelist_append(packager->filelist, file);
}

int pakfire_packager_add(struct pakfire_packager* packager,
		const char* sourcepath, const char* path) {
	struct pakfire_file* file = NULL;
	int r = 1;

	// Create file
	r = pakfire_file_create_from_path(&file, packager->pakfire, sourcepath);
	if (r)
		goto ERROR;

	// Assign a new path for inside the archive
	if (path) {
		r = pakfire_file_set_path(file, path);
		if (r)
			goto ERROR;
	}

	// Call the main function
	r = pakfire_packager_add_file(packager, file);

ERROR:
	if (file)
		pakfire_file_unref(file);

	return r;
}

int pakfire_packager_add_files(struct pakfire_packager* packager,
		struct pakfire_filelist* filelist, int cleanup) {
	struct pakfire_file* file = NULL;
	int r;

	// Fetch length of the filelist
	const size_t length = pakfire_filelist_size(filelist);

	// Add all files to the package
	for (unsigned int i = 0; i < length; i++) {
		file = pakfire_filelist_get(filelist, i);

		// Add the file to the package
		r = pakfire_packager_add_file(packager, file);
		if (r) {
			pakfire_file_unref(file);
			goto ERROR;
		}

		// Remove the file after it was packaged
		if (cleanup) {
			r = pakfire_file_cleanup(file);
			if (r) {
				pakfire_file_unref(file);
				goto ERROR;
			}
		}

		pakfire_file_unref(file);
	}

ERROR:
	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;
}
Commit	Line	Data
6aeb48e6 MT	1	/*#############################################################################
	2	# #
	3	# Pakfire - The IPFire package management system #
	4	# Copyright (C) 2021 Pakfire development team #
	5	# #
	6	# This program is free software: you can redistribute it and/or modify #
	7	# it under the terms of the GNU General Public License as published by #
	8	# the Free Software Foundation, either version 3 of the License, or #
	9	# (at your option) any later version. #
	10	# #
	11	# This program is distributed in the hope that it will be useful, #
	12	# but WITHOUT ANY WARRANTY; without even the implied warranty of #
	13	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the #
	14	# GNU General Public License for more details. #
	15	# #
	16	# You should have received a copy of the GNU General Public License #
	17	# along with this program. If not, see <http://www.gnu.org/licenses/>. #
	18	# #
	19	#############################################################################*/
	20
	21	#include <errno.h>
1ea1f35b MT	22	#include <fcntl.h>
1ea1f35b MT	23	#include <linux/limits.h>
6aeb48e6	24	#include <stdlib.h>
da08f989 MT	25	#include <sys/stat.h>
da08f989 MT	26	#include <sys/types.h>
05cfc2c9	27	#include <time.h>
da08f989	28	#include <unistd.h>
6aeb48e6	29
1ea1f35b	30	#include <archive.h>
da08f989	31	#include <archive_entry.h>
1ea1f35b	32
b59c9fa2 MT	33	#include <json.h>
b59c9fa2 MT	34
2adc4a4a	35	#include <pakfire/archive.h>
6bf9841b	36	#include <pakfire/compress.h>
436677a3	37	#include <pakfire/constants.h>
1ea1f35b	38	#include <pakfire/logging.h>
6aeb48e6 MT	39	#include <pakfire/package.h>
	40	#include <pakfire/packager.h>
	41	#include <pakfire/pakfire.h>
677e9e5b	42	#include <pakfire/pwd.h>
d973a13d	43	#include <pakfire/string.h>
f57ad279	44	#include <pakfire/util.h>
6aeb48e6 MT	45
6aeb48e6 MT	46	struct pakfire_packager {
ac4c607b	47	struct pakfire* pakfire;
6aeb48e6	48	int nrefs;
05cfc2c9	49	time_t time_created;
6aeb48e6	50
31480bee	51	struct pakfire_package* pkg;
bb06d548	52	char filename[PATH_MAX];
1ea1f35b	53
738b3582 MT	54	// Reader
	55	struct archive* reader;
	56
	57	// Payload
6bf9841b	58	struct pakfire_filelist* filelist;
106d2edd	59
9ca45f4f	60	// Scriptlets
106d2edd MT	61	struct pakfire_scriptlet** scriptlets;
106d2edd MT	62	unsigned int num_scriptlets;
9ca45f4f MT	63
	64	// Digests
	65	unsigned int digests;
6aeb48e6 MT	66	};
6aeb48e6 MT	67
1ea1f35b	68	static void pakfire_packager_free(struct pakfire_packager* packager) {
106d2edd MT	69	// Scriptlets
	70	if (packager->scriptlets) {
	71	for (unsigned int i = 0; i < packager->num_scriptlets; i++)
9dd7b1aa	72	pakfire_scriptlet_unref(packager->scriptlets[i]);
106d2edd MT	73	free(packager->scriptlets);
	74	}
	75
738b3582	76	if (packager->reader)
66817062	77	archive_read_free(packager->reader);
738b3582	78
6bf9841b MT	79	if (packager->filelist)
6bf9841b MT	80	pakfire_filelist_unref(packager->filelist);
1ea1f35b MT	81	pakfire_package_unref(packager->pkg);
1ea1f35b MT	82	pakfire_unref(packager->pakfire);
51105783	83	free(packager);
1ea1f35b MT	84	}
1ea1f35b MT	85
22b8e37b	86	int pakfire_packager_create(struct pakfire_packager** packager,
5d7a93ec	87	struct pakfire* pakfire, struct pakfire_package* pkg) {
6aeb48e6 MT	88	struct pakfire_packager* p = calloc(1, sizeof(*p));
	89	if (!p)
	90	return ENOMEM;
	91
e282863a MT	92	int r = 1;
e282863a MT	93
05cfc2c9 MT	94	// Save creation time
	95	p->time_created = time(NULL);
	96
6aeb48e6 MT	97	// Initialize reference counting
	98	p->nrefs = 1;
	99
	100	// Store a reference to Pakfire
5d7a93ec	101	p->pakfire = pakfire_ref(pakfire);
6aeb48e6 MT	102
	103	// Store a reference to the package
	104	p->pkg = pakfire_package_ref(pkg);
	105
9ca45f4f MT	106	// Use the default digests
	107	p->digests = PAKFIRE_PACKAGER_DIGESTS;
	108
cd2c2cfb MT	109	// Set build host
	110	pakfire_package_set_build_host(pkg, pakfire_hostname());
	111
	112	// Set build time
	113	pakfire_package_set_build_time(pkg, p->time_created);
	114
0682aeb3	115	// Create reader
66817062 MT	116	p->reader = pakfire_make_archive_disk_reader(p->pakfire, 1);
66817062 MT	117	if (!p->reader)
1ba1869e	118	goto ERROR;
1ea1f35b	119
6bf9841b MT	120	// Create filelist
6bf9841b MT	121	r = pakfire_filelist_create(&p->filelist, p->pakfire);
0682aeb3	122	if (r)
738b3582	123	goto ERROR;
738b3582	124
6bf9841b	125	// Add a requirement for the cryptographic algorithms we are using
9ca45f4f MT	126	if (p->digests & PAKFIRE_DIGEST_SHA3_512)
	127	pakfire_package_add_requires(p->pkg, "pakfire(Digest-SHA3-512)");
	128	if (p->digests & PAKFIRE_DIGEST_SHA3_256)
	129	pakfire_package_add_requires(p->pkg, "pakfire(Digest-SHA3-256)");
	130	if (p->digests & PAKFIRE_DIGEST_BLAKE2B512)
	131	pakfire_package_add_requires(p->pkg, "pakfire(Digest-BLAKE2b512)");
	132	if (p->digests & PAKFIRE_DIGEST_BLAKE2S256)
	133	pakfire_package_add_requires(p->pkg, "pakfire(Digest-BLAKE2s256)");
	134	if (p->digests & PAKFIRE_DIGEST_SHA2_512)
	135	pakfire_package_add_requires(p->pkg, "pakfire(Digest-SHA2-512)");
	136	if (p->digests & PAKFIRE_DIGEST_SHA2_256)
	137	pakfire_package_add_requires(p->pkg, "pakfire(Digest-SHA2-256)");
6bf9841b	138
6aeb48e6 MT	139	*packager = p;
	140
	141	return 0;
1ba1869e MT	142
	143	ERROR:
	144	pakfire_packager_free(p);
	145
	146	return r;
6aeb48e6 MT	147	}
6aeb48e6 MT	148
22b8e37b	149	struct pakfire_packager* pakfire_packager_ref(
6aeb48e6 MT	150	struct pakfire_packager* packager) {
	151	++packager->nrefs;
	152
	153	return packager;
	154	}
	155
22b8e37b	156	struct pakfire_packager* pakfire_packager_unref(
6aeb48e6 MT	157	struct pakfire_packager* packager) {
	158	if (--packager->nrefs > 0)
	159	return packager;
	160
	161	pakfire_packager_free(packager);
6aeb48e6 MT	162	return NULL;
6aeb48e6 MT	163	}
da08f989	164
22b8e37b	165	const char* pakfire_packager_filename(struct pakfire_packager* packager) {
bb06d548 MT	166	if (!*packager->filename) {
	167	const char* filename = pakfire_package_get_filename(packager->pkg);
	168
	169	// Add arch
	170	if (pakfire_package_is_source(packager->pkg))
	171	pakfire_string_set(packager->filename, filename);
	172	else {
	173	const char* arch = pakfire_package_get_arch(packager->pkg);
	174
	175	pakfire_string_format(packager->filename, "%s/%s", arch, filename);
	176	}
	177	}
	178
	179	return packager->filename;
96d2c7bc MT	180	}
96d2c7bc MT	181
28700a5b	182	static struct archive_entry* pakfire_packager_create_file(
95b81a98	183	struct pakfire_packager* packager, const char* filename, size_t size, mode_t mode) {
98e85f1c MT	184	// Create a new file entry
	185	struct archive_entry* entry = archive_entry_new();
	186	if (!entry)
28700a5b	187	return NULL;
98e85f1c MT	188
	189	// Set filename
	190	archive_entry_set_pathname(entry, filename);
	191
	192	// This is a regular file
	193	archive_entry_set_filetype(entry, AE_IFREG);
95b81a98	194	archive_entry_set_perm(entry, mode);
98e85f1c	195
28700a5b MT	196	// Set size
	197	archive_entry_set_size(entry, size);
	198
05cfc2c9 MT	199	// Set ownership
	200	archive_entry_set_uname(entry, "root");
	201	archive_entry_set_uid(entry, 0);
	202	archive_entry_set_gname(entry, "root");
	203	archive_entry_set_gid(entry, 0);
	204
	205	// Set times
	206	archive_entry_set_birthtime(entry, packager->time_created, 0);
	207	archive_entry_set_ctime(entry, packager->time_created, 0);
	208	archive_entry_set_mtime(entry, packager->time_created, 0);
	209	archive_entry_set_atime(entry, packager->time_created, 0);
	210
28700a5b MT	211	return entry;
	212	}
	213
	214	static int pakfire_packager_write_file_from_buffer(struct pakfire_packager* packager,
bfdad796	215	struct archive* a, const char* filename, mode_t mode, const char* buffer) {
28700a5b MT	216	size_t size = strlen(buffer);
	217
	218	// Create a new file
7e346194 MT	219	struct archive_entry* entry = pakfire_packager_create_file(packager, filename, size, mode);
	220	if (!entry) {
	221	ERROR(packager->pakfire, "Could not create file '%s'\n", filename);
28700a5b	222	return 1;
7e346194	223	}
98e85f1c MT	224
	225	// This is the end of the header
	226	int r = archive_write_header(a, entry);
	227	if (r) {
	228	ERROR(packager->pakfire, "Error writing header: %s\n", archive_error_string(a));
265a7974	229	goto ERROR;
98e85f1c MT	230	}
	231
	232	// Write content
	233	r = archive_write_data(a, buffer, strlen(buffer));
	234	if (r < 0) {
	235	ERROR(packager->pakfire, "Error writing data: %s\n", archive_error_string(a));
265a7974	236	goto ERROR;
98e85f1c MT	237	}
98e85f1c MT	238
265a7974 MT	239	// Success
	240	r = 0;
	241
	242	ERROR:
98e85f1c MT	243	archive_entry_free(entry);
98e85f1c MT	244
265a7974	245	return r;
98e85f1c MT	246	}
98e85f1c MT	247
436677a3 MT	248	static int pakfire_packager_write_format(struct pakfire_packager* packager,
	249	struct archive* a) {
	250	const char buffer[] = TO_STRING(PACKAGE_FORMAT) "\n";
	251
7e346194 MT	252	DEBUG(packager->pakfire, "Writing package format\n");
7e346194 MT	253
bfdad796	254	int r = pakfire_packager_write_file_from_buffer(packager, a,
0dbfb5e1	255	"pakfire-format", 0444, buffer);
a6dd151e MT	256	if (r)
	257	return r;
	258
	259	// Add package format marker
	260	pakfire_package_add_requires(packager->pkg,
	261	"pakfire(PackageFormat-" TO_STRING(PACKAGE_FORMAT) ")");
	262
	263	return 0;
436677a3 MT	264	}
436677a3 MT	265
b59c9fa2 MT	266	static char* pakfire_packager_make_metadata(struct pakfire_packager* packager) {
b59c9fa2 MT	267	char* result = NULL;
98e85f1c	268
b59c9fa2 MT	269	// Convert all package metadata to JSON
	270	struct json_object* md = pakfire_package_to_json(packager->pkg);
	271	if (!md)
98e85f1c MT	272	goto ERROR;
98e85f1c MT	273
b59c9fa2	274	// Serialize JSON to file
ef4a2e77	275	const char* s = json_object_to_json_string_ext(md, 0);
b59c9fa2	276	if (!s)
98e85f1c MT	277	goto ERROR;
98e85f1c MT	278
b59c9fa2 MT	279	// Copy result onto heap
	280	result = strdup(s);
	281	if (!result)
98e85f1c	282	goto ERROR;
98e85f1c MT	283
98e85f1c MT	284	ERROR:
b59c9fa2 MT	285	// Free metadata
	286	if (md)
	287	json_object_put(md);
98e85f1c	288
b59c9fa2	289	return result;
98e85f1c MT	290	}
	291
	292	static int pakfire_packager_write_metadata(struct pakfire_packager* packager,
bfdad796	293	struct archive* a) {
98e85f1c	294	// Make metadata
b59c9fa2	295	char* buffer = pakfire_packager_make_metadata(packager);
98e85f1c MT	296	if (!buffer)
	297	return 1;
	298
b59c9fa2	299	DEBUG(packager->pakfire, "Generated package metadata:\n%s\n", buffer);
98e85f1c MT	300
98e85f1c MT	301	// Write buffer
bfdad796	302	int r = pakfire_packager_write_file_from_buffer(packager, a,
9f6b177b	303	".PKGINFO", 0444, buffer);
98e85f1c MT	304
	305	free(buffer);
	306
	307	return r;
	308	}
	309
106d2edd	310	static int pakfire_packager_write_scriptlet(struct pakfire_packager* packager,
bfdad796	311	struct archive* a, struct pakfire_scriptlet* scriptlet) {
106d2edd MT	312	char filename[PATH_MAX];
	313	size_t size;
	314	int r;
	315
	316	// Fetch type
	317	const char* type = pakfire_scriptlet_get_type(scriptlet);
	318
	319	DEBUG(packager->pakfire, "Writing scriptlet '%s' to package\n", type);
	320
	321	// Make filename
9f6b177b	322	r = pakfire_string_format(filename, ".scriptlets/%s", type);
a60955af	323	if (r)
106d2edd MT	324	return r;
	325
	326	// Fetch scriptlet
	327	const char* data = pakfire_scriptlet_get_data(scriptlet, &size);
	328
	329	// Write file
bfdad796	330	return pakfire_packager_write_file_from_buffer(packager, a, filename, 0544, data);
106d2edd MT	331	}
106d2edd MT	332
436677a3 MT	333	/*
	334	This function is being called at the end when all data has been added to the package.
	335
	336	It will create a new archive and write the package to the given file descriptor.
	337	*/
22b8e37b	338	int pakfire_packager_finish(struct pakfire_packager* packager, FILE* f) {
1b4e7c7b	339	struct archive* a = NULL;
96d2c7bc	340	int r = 1;
436677a3	341
6bf9841b	342	const char* nevra = pakfire_package_get_nevra(packager->pkg);
1b4e7c7b	343
555b6dd2 MT	344	// Add requires feature markers
	345	if (pakfire_package_has_rich_deps(packager->pkg))
	346	pakfire_package_add_requires(packager->pkg, "pakfire(RichDependencies)");
	347
260006f2 MT	348	// Add filelist
	349	r = pakfire_package_set_filelist(packager->pkg, packager->filelist);
	350	if (r)
	351	goto ERROR;
	352
6bf9841b MT	353	const size_t installsize = pakfire_filelist_total_size(packager->filelist);
6bf9841b MT	354
508e2030	355	// Store total install size
6bf9841b	356	pakfire_package_set_installsize(packager->pkg, installsize);
fafe383d	357
508e2030 MT	358	// Dump package metadata
	359	char* dump = pakfire_package_dump(packager->pkg, PAKFIRE_PKG_DUMP_LONG);
	360	if (dump) {
	361	INFO(packager->pakfire, "%s\n", dump);
	362	free(dump);
	363	}
	364
436677a3	365	// Open a new archive
1b4e7c7b	366	a = archive_write_new();
436677a3 MT	367	if (!a) {
436677a3 MT	368	ERROR(packager->pakfire, "archive_write_new() failed\n");
260006f2	369	r = 1;
436677a3 MT	370	goto ERROR;
	371	}
	372
	373	// Use the PAX format
96d2c7bc	374	r = archive_write_set_format_pax(a);
436677a3 MT	375	if (r) {
	376	ERROR(packager->pakfire, "Could not set format to PAX: %s\n",
	377	archive_error_string(a));
	378	goto ERROR;
	379	}
	380
63476763 MT	381	// Store any extended attributes in the SCHILY headers
	382	r = archive_write_set_format_option(a, "pax", "xattrheader", "SCHILY");
	383	if (r) {
	384	ERROR(packager->pakfire, "Could not set xattrheader option: %s\n",
	385	archive_error_string(a));
	386	return r;
	387	}
	388
	389	// Enable Zstd
	390	r = archive_write_add_filter_zstd(a);
	391	if (r) {
	392	ERROR(packager->pakfire, "Could not enable Zstandard compression: %s\n",
	393	archive_error_string(a));
	394	return r;
	395	}
	396
	397	// Set compression level to highest
	398	r = archive_write_set_filter_option(a, NULL, "compression-level", "22");
	399	if (r) {
	400	ERROR(packager->pakfire, "Could not set Zstandard compression level: %s\n",
	401	archive_error_string(a));
	402	return r;
	403	}
	404
	405	// Add feature marker
	406	pakfire_package_add_requires(packager->pkg, "pakfire(Compress-Zstandard)");
	407
	408	// Do not pad the last block
	409	archive_write_set_bytes_in_last_block(a, 1);
	410
436677a3 MT	411	// Write archive to f
	412	r = archive_write_open_FILE(a, f);
	413	if (r) {
	414	ERROR(packager->pakfire, "archive_write_open_FILE() failed: %s\n",
	415	archive_error_string(a));
	416	goto ERROR;
	417	}
	418
	419	// Start with the format file
	420	r = pakfire_packager_write_format(packager, a);
265a7974 MT	421	if (r) {
	422	ERROR(packager->pakfire, "Could not add format file to archive: %s\n",
	423	archive_error_string(a));
436677a3	424	goto ERROR;
265a7974	425	}
436677a3	426
98e85f1c	427	// Write the metadata
bfdad796	428	r = pakfire_packager_write_metadata(packager, a);
265a7974 MT	429	if (r) {
	430	ERROR(packager->pakfire, "Could not add metadata file to archive: %s\n",
	431	archive_error_string(a));
98e85f1c	432	goto ERROR;
265a7974	433	}
98e85f1c	434
d8856104 MT	435	// Write scriptlets
	436	for (unsigned int i = 0; i < packager->num_scriptlets; i++) {
	437	r = pakfire_packager_write_scriptlet(packager, a, packager->scriptlets[i]);
	438	if (r) {
	439	ERROR(packager->pakfire, "Could not add scriptlet to the archive: %m\n");
	440	goto ERROR;
	441	}
	442	}
	443
bfdad796	444	// Write the payload
6bf9841b MT	445	r = pakfire_compress(packager->pakfire, a, packager->filelist, nevra,
6bf9841b MT	446	PAKFIRE_COMPRESS_SHOW_THROUGHPUT, PAKFIRE_PACKAGER_DIGESTS);
265a7974	447
2013270b MT	448	// Flush all buffers to disk
	449	fflush(f);
	450
96d2c7bc MT	451	// Success
96d2c7bc MT	452	r = 0;
436677a3 MT	453
	454	ERROR:
	455	if (a)
265a7974	456	archive_write_free(a);
436677a3	457
96d2c7bc	458	return r;
436677a3 MT	459	}
436677a3 MT	460
22b8e37b	461	int pakfire_packager_finish_to_directory(struct pakfire_packager* packager,
45448dbd	462	const char* target, char** result) {
48c6f2e7	463	char path[PATH_MAX];
bb06d548	464	char tmppath[PATH_MAX];
48c6f2e7 MT	465	int r = 1;
	466
	467	// target cannot be empty
	468	if (!target) {
	469	errno = EINVAL;
	470	return 1;
	471	}
	472
bb06d548 MT	473	// Get the filename of the package
	474	const char* filename = pakfire_packager_filename(packager);
	475	if (!filename) {
b1772bfb	476	ERROR(packager->pakfire, "Could not generate filename for package: %m\n");
bb06d548 MT	477	r = 1;
	478	goto ERROR;
	479	}
	480
	481	// Make the package path
	482	r = pakfire_string_format(path, "%s/%s", target, filename);
a60955af	483	if (r)
bb06d548 MT	484	goto ERROR;
	485
	486	// Create the parent directory
520ce66c	487	r = pakfire_mkparentdir(path, 0755);
bb06d548 MT	488	if (r)
	489	goto ERROR;
	490
48c6f2e7	491	// Create a temporary file in the target directory
bb06d548	492	r = pakfire_string_format(tmppath, "%s.XXXXXX", path);
a60955af	493	if (r)
bb06d548	494	goto ERROR;
48c6f2e7 MT	495
48c6f2e7 MT	496	// Create a temporary result file
bb06d548	497	FILE* f = pakfire_mktemp(tmppath);
48c6f2e7 MT	498	if (!f)
	499	goto ERROR;
	500
	501	// Write the finished package
	502	r = pakfire_packager_finish(packager, f);
bb06d548 MT	503	fclose(f);
bb06d548 MT	504
48c6f2e7	505	if (r) {
b1772bfb	506	ERROR(packager->pakfire, "pakfire_packager_finish() failed: %m\n");
48c6f2e7 MT	507	goto ERROR;
	508	}
	509
48c6f2e7	510	// Move the temporary file to destination
bb06d548 MT	511	r = rename(tmppath, path);
bb06d548 MT	512	if (r) {
b1772bfb	513	ERROR(packager->pakfire, "Could not move %s to %s: %m\n", tmppath, path);
48c6f2e7	514	goto ERROR;
bb06d548	515	}
48c6f2e7	516
bb06d548	517	INFO(packager->pakfire, "Package written to %s\n", path);
48c6f2e7	518
45448dbd MT	519	// Store result path if requested
	520	if (result) {
	521	*result = strdup(path);
	522	if (!*result) {
	523	r = 1;
	524	goto ERROR;
	525	}
	526	}
	527
48c6f2e7 MT	528	// Success
	529	r = 0;
	530
	531	ERROR:
	532	// Remove temporary file
bb06d548 MT	533	if (r && *tmppath)
bb06d548 MT	534	unlink(tmppath);
48c6f2e7	535
bb06d548	536	return r;
48c6f2e7 MT	537	}
48c6f2e7 MT	538
80a108bf	539	int pakfire_packager_add_file(struct pakfire_packager* packager, struct pakfire_file* file) {
85b59296 MT	540	// Check input
85b59296 MT	541	if (!file) {
255d4488 MT	542	errno = EINVAL;
	543	return 1;
	544	}
da08f989	545
85b59296 MT	546	// Fetch path
85b59296 MT	547	const char* path = pakfire_file_get_path(file);
da08f989	548
85b59296 MT	549	// Files cannot have an empty path
	550	if (!*path) {
	551	ERROR(packager->pakfire, "Cannot add a file with an empty path\n");
	552	errno = EPERM;
	553	return 1;
da08f989	554
85b59296 MT	555	// Hidden files cannot be added
	556	} else if (*path == '.') {
	557	ERROR(packager->pakfire, "Hidden files cannot be added to a package: %s\n", path);
	558	errno = EPERM;
	559	return 1;
738b3582	560	}
da08f989	561
85b59296 MT	562	DEBUG(packager->pakfire, "Adding file to payload: %s\n", path);
85b59296 MT	563
2ed2b519 MT	564	// Overwrite a couple of things for source archives
	565	if (pakfire_package_is_source(packager->pkg)) {
	566	// Reset permissions
85b59296	567	pakfire_file_set_perms(file, 0644);
2ed2b519 MT	568
2ed2b519 MT	569	// Reset file ownership
85b59296 MT	570	pakfire_file_set_user(file, "root");
85b59296 MT	571	pakfire_file_set_group(file, "root");
2ed2b519 MT	572	}
2ed2b519 MT	573
6bf9841b MT	574	// Append the file to the filelist
6bf9841b MT	575	return pakfire_filelist_append(packager->filelist, file);
da08f989	576	}
106d2edd	577
85b59296 MT	578	int pakfire_packager_add(struct pakfire_packager* packager,
	579	const char* sourcepath, const char* path) {
	580	struct pakfire_file* file = NULL;
	581	int r = 1;
	582
61b0856b MT	583	// Create file
61b0856b MT	584	r = pakfire_file_create_from_path(&file, packager->pakfire, sourcepath);
85b59296 MT	585	if (r)
	586	goto ERROR;
	587
61b0856b MT	588	// Assign a new path for inside the archive
	589	if (path) {
	590	r = pakfire_file_set_path(file, path);
	591	if (r)
	592	goto ERROR;
	593	}
	594
85b59296 MT	595	// Call the main function
	596	r = pakfire_packager_add_file(packager, file);
	597
	598	ERROR:
	599	if (file)
	600	pakfire_file_unref(file);
	601
	602	return r;
	603	}
	604
814b7fee MT	605	int pakfire_packager_add_files(struct pakfire_packager* packager,
	606	struct pakfire_filelist* filelist, int cleanup) {
	607	struct pakfire_file* file = NULL;
	608	int r;
	609
	610	// Fetch length of the filelist
	611	const size_t length = pakfire_filelist_size(filelist);
	612
	613	// Add all files to the package
	614	for (unsigned int i = 0; i < length; i++) {
	615	file = pakfire_filelist_get(filelist, i);
	616
	617	// Add the file to the package
	618	r = pakfire_packager_add_file(packager, file);
	619	if (r) {
	620	pakfire_file_unref(file);
	621	goto ERROR;
	622	}
	623
	624	// Remove the file after it was packaged
	625	if (cleanup) {
	626	r = pakfire_file_cleanup(file);
	627	if (r) {
	628	pakfire_file_unref(file);
	629	goto ERROR;
	630	}
	631	}
	632
	633	pakfire_file_unref(file);
	634	}
	635
	636	ERROR:
	637	return r;
	638	}
	639
106d2edd MT	640	int pakfire_packager_add_scriptlet(struct pakfire_packager* packager,
	641	struct pakfire_scriptlet* scriptlet) {
	642	if (!scriptlet) {
	643	errno = EINVAL;
	644	return 1;
	645	}
	646
	647	// Extend array
	648	packager->scriptlets = reallocarray(packager->scriptlets,
	649	packager->num_scriptlets + 1, sizeof(*packager->scriptlets));
	650	if (!packager->scriptlets)
	651	return 1;
	652
	653	// Append scriptlet
	654	packager->scriptlets[packager->num_scriptlets++] = pakfire_scriptlet_ref(scriptlet);
	655
	656	return 0;
	657	}