compress: Create a unified extraction function

[people/ms/pakfire.git] / src / libpakfire / snapshot.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 <linux/limits.h>
#include <stdio.h>
#include <stdlib.h>

#include <archive.h>

#include <pakfire/compress.h>
#include <pakfire/db.h>
#include <pakfire/file.h>
#include <pakfire/filelist.h>
#include <pakfire/i18n.h>
#include <pakfire/logging.h>
#include <pakfire/repo.h>
#include <pakfire/snapshot.h>
#include <pakfire/util.h>

static struct archive* pakfire_snapshot_create_archive(
		struct pakfire* pakfire, const char* path) {
	struct archive* a = archive_write_new();
	if (!a) {
		ERROR(pakfire, "archive_write_new() failed\n");
		return NULL;
	}

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

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

	// Set compression level to fastest
	r = archive_write_set_filter_option(a, NULL, "compression-level", "1");
	if (r) {
		ERROR(pakfire, "Could not set Zstandard compression level: %s\n",
			archive_error_string(a));
		goto ERROR;
	}

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

	// Write archive to file
	r = archive_write_open_filename(a, path);
	if (r)
		goto ERROR;

	return a;

ERROR:
	archive_write_free(a);

	return NULL;
}

int pakfire_snapshot_create(struct pakfire* pakfire, const char* path) {
	struct pakfire_filelist* filelist = NULL;
	struct archive* a = NULL;
	int r = 1;

	// Check input
	if (!path) {
		errno = EINVAL;
		return 1;
	}

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

	const char* root = pakfire_get_path(pakfire);

	INFO(pakfire, "Creating snapshot of %s to %s...\n", root, path);

	// Scan for all files
	r = pakfire_filelist_scan(filelist, root, NULL, NULL);
	if (r)
		goto ERROR;

	const size_t size = pakfire_filelist_size(filelist);

	// Check if we have any files
	if (!size) {
		ERROR(pakfire, "The snapshot is unexpectedly empty\n");
		r = 1;
		goto ERROR;
	}

	// Sort the filelist in place
	pakfire_filelist_sort(filelist);

	a = pakfire_snapshot_create_archive(pakfire, path);
	if (!a) {
		ERROR(pakfire, "Could not open archive for writing\n");
		goto ERROR;
	}

	for (unsigned int i = 0; i < size; i++) {
		struct pakfire_file* file = pakfire_filelist_get(filelist, i);
		if (!file)
			continue;

		FILE* f = NULL;

		// Make archive entry
		struct archive_entry* entry = pakfire_file_archive_entry(file);
		if (!entry) {
			ERROR(pakfire, "Could not make archive entry from file: %m\n");
			r = 1;
			goto OUT;
		}

		// Write header
		r = archive_write_header(a, entry);
		if (r) {
			ERROR(pakfire, "Could not write header: %s\n", archive_error_string(a));
			goto OUT;
		}

		// Copy payload
		if (archive_entry_filetype(entry) == AE_IFREG) {
			f = pakfire_file_open(file);
			if (!f) {
				r = 1;
				goto OUT;
			}

			r = pakfire_archive_copy_data_from_file(pakfire, a, f);
			if (r) {
				ERROR(pakfire, "Could not copy %s\n", archive_entry_pathname(entry));
				goto OUT;
			}
		}

		// Write trailer
		r = archive_write_finish_entry(a);
		if (r)
			goto OUT;

OUT:
		if (file)
			pakfire_file_unref(file);
		if (f)
			fclose(f);

		// Move on to ERROR
		if (r)
			goto ERROR;
	}

	// Close archive
	r = archive_write_close(a);
	if (r) {
		ERROR(pakfire, "Could not close archive: %s\n", archive_error_string(a));
		goto ERROR;
	}

	// Success
	r = 0;

ERROR:
	if (filelist)
		pakfire_filelist_unref(filelist);
	if (a)
		archive_write_free(a);

	return r;
}

static int pakfire_snapshot_extract(struct pakfire* pakfire, const char* path) {
	struct stat st;
	int r = 1;

	// Check input
	if (!path) {
		errno = EINVAL;
		return 1;
	}

	// Stat the input file
	r = stat(path, &st);
	if (r) {
		ERROR(pakfire, "Could not stat snapshot: %m\n");
		return 1;
	}

	struct archive* archive = archive_read_new();
	if (!archive)
		return 1;

	// All snapshots are tarballs
	archive_read_support_format_tar(archive);

	// And they are compressed using ZSTD
	archive_read_support_filter_zstd(archive);

	// Open the given file for reading
	r = archive_read_open_filename(archive, path, 64 * 1024);
	if (r) {
		ERROR(pakfire, "Could not open archive: %s\n", archive_error_string(archive));
		goto ERROR;
	}

	// Extract snapshot
	r = pakfire_extract(pakfire, archive, st.st_size, NULL, _("Extracting snapshot..."), 0);
	if (r)
		goto ERROR;

ERROR:
	if (archive)
		archive_read_free(archive);

	return r;
}

int pakfire_snapshot_restore(struct pakfire* pakfire, const char* path) {
	struct pakfire_db* db = NULL;

	// Check input
	if (!path) {
		errno = EINVAL;
		return 1;
	}

	// Extract the archive
	int r = pakfire_snapshot_extract(pakfire, path);
	if (r)
		return r;

	struct pakfire_repo* repo = pakfire_get_installed_repo(pakfire);
	if (!repo)
		goto ERROR;

	// Reload the database
	r = pakfire_db_open(&db, pakfire, PAKFIRE_DB_READWRITE);
	if (r)
		goto ERROR;

	r = pakfire_db_load(db, repo);

ERROR:
	if (repo)
		pakfire_repo_unref(repo);
	if (db)
		pakfire_db_unref(db);

	return r;
}