logging: Make the legacy logger configurable

[people/ms/pakfire.git] / src / libpakfire / filelist.c

/*#############################################################################
#                                                                             #
# Pakfire - The IPFire package management system                              #
# Copyright (C) 2014 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 <stdlib.h>
#include <sys/queue.h>

#include <archive.h>

// Enable legacy logging
#define PAKFIRE_LEGACY_LOGGING

#include <pakfire/file.h>
#include <pakfire/filelist.h>
#include <pakfire/i18n.h>
#include <pakfire/logging.h>
#include <pakfire/pakfire.h>
#include <pakfire/private.h>
#include <pakfire/progress.h>
#include <pakfire/string.h>
#include <pakfire/util.h>

struct pakfire_filelist_element {
	TAILQ_ENTRY(pakfire_filelist_element) nodes;

	struct pakfire_file* file;
};

struct pakfire_filelist {
	struct pakfire_ctx* ctx;
	struct pakfire* pakfire;
	int nrefs;

	TAILQ_HEAD(entries, pakfire_filelist_element) files;
};

PAKFIRE_EXPORT int pakfire_filelist_create(struct pakfire_filelist** list, struct pakfire* pakfire) {
	struct pakfire_filelist* l = calloc(1, sizeof(*l));
	if (!l)
		return -ENOMEM;

	// Store a reference to the context
	l->ctx = pakfire_ctx(pakfire);

	l->pakfire = pakfire_ref(pakfire);
	l->nrefs = 1;

	// Initialise files
	TAILQ_INIT(&l->files);

	*list = l;
	return 0;
}

static void pakfire_filelist_free(struct pakfire_filelist* list) {
	pakfire_filelist_clear(list);
	pakfire_unref(list->pakfire);
	if (list->ctx)
		pakfire_ctx_unref(list->ctx);
	free(list);
}

PAKFIRE_EXPORT struct pakfire_filelist* pakfire_filelist_ref(struct pakfire_filelist* list) {
	list->nrefs++;

	return list;
}

PAKFIRE_EXPORT struct pakfire_filelist* pakfire_filelist_unref(struct pakfire_filelist* list) {
	if (--list->nrefs > 0)
		return list;

	pakfire_filelist_free(list);
	return NULL;
}

PAKFIRE_EXPORT size_t pakfire_filelist_length(struct pakfire_filelist* list) {
	struct pakfire_filelist_element* element = NULL;
	size_t size = 0;

	TAILQ_FOREACH(element, &list->files, nodes)
		size++;

	return size;
}

size_t pakfire_filelist_total_size(struct pakfire_filelist* list) {
	struct pakfire_filelist_element* element = NULL;
	size_t size = 0;

	TAILQ_FOREACH(element, &list->files, nodes)
		size += pakfire_file_get_size(element->file);

	return size;
}

PAKFIRE_EXPORT int pakfire_filelist_is_empty(struct pakfire_filelist* list) {
	return TAILQ_EMPTY(&list->files);
}

PAKFIRE_EXPORT void pakfire_filelist_clear(struct pakfire_filelist* list) {
	struct pakfire_filelist_element* element = NULL;

	while (!TAILQ_EMPTY(&list->files)) {
		// Fetch the first element
		element = TAILQ_FIRST(&list->files);

		// Remove it from the list
		TAILQ_REMOVE(&list->files, element, nodes);

		// Dereference the file
		pakfire_file_unref(element->file);

		// Free it all
		free(element);
	}
}

PAKFIRE_EXPORT struct pakfire_file* pakfire_filelist_get(struct pakfire_filelist* list, size_t index) {
	struct pakfire_filelist_element* element = NULL;

	// Fetch the first element
	element = TAILQ_FIRST(&list->files);

	while (element && index--)
		element = TAILQ_NEXT(element, nodes);

	if (!element)
		return NULL;

	return pakfire_file_ref(element->file);
}

PAKFIRE_EXPORT int pakfire_filelist_add(struct pakfire_filelist* list, struct pakfire_file* file) {
	struct pakfire_filelist_element* element = NULL;
	struct pakfire_filelist_element* e = NULL;

	// Allocate a new element
	element = calloc(1, sizeof *element);
	if (!element) {
		ERROR(list->pakfire, "Could not allocate a new filelist element: %m\n");
		return 1;
	}

	// Reference the file
	element->file = pakfire_file_ref(file);

	// Fetch the last element
	e = TAILQ_LAST(&list->files, entries);

	// Skip all elements that are "greater than" the element we want to add
	while (e) {
		if (pakfire_file_cmp(e->file, file) <= 0)
			break;

		e = TAILQ_PREV(e, entries, nodes);
	}

	// If we found an element on the list, we will append after it,
	// otherwise we add right at the start.
	if (e)
		TAILQ_INSERT_AFTER(&list->files, e, element, nodes);
	else
		TAILQ_INSERT_HEAD(&list->files, element, nodes);

	return 0;
}

static int pakfire_filelist_remove(struct pakfire_filelist* list, struct pakfire_file* file) {
	struct pakfire_filelist_element* element = NULL;

	TAILQ_FOREACH(element, &list->files, nodes) {
		if (element->file == file) {
			// Remove the element from the list
			TAILQ_REMOVE(&list->files, element, nodes);

			// Free the element
			pakfire_file_unref(element->file);
			free(element);

			return 0;
		}
	}

	return 0;
}

static int __pakfire_filelist_remove_one(
		struct pakfire* pakfire, struct pakfire_file* file, void* data) {
	struct pakfire_filelist* list = (struct pakfire_filelist*)data;

	// Remove the file from the given filelist
	return pakfire_filelist_remove(list, file);
}

int pakfire_filelist_remove_all(
		struct pakfire_filelist* list, struct pakfire_filelist* removees) {
	return pakfire_filelist_walk(removees, __pakfire_filelist_remove_one, list, 0);
}

static int pakfire_filelist_match_patterns(const char* path,
		const char** patterns, const int flags) {
	char buffer[PATH_MAX];
	int r;

	// Check inputs
	if (!path || !patterns)
		return -EINVAL;

	for (const char** pattern = patterns; *pattern; pattern++) {
		// Try to find a simple match
		if (pakfire_path_match(*pattern, path))
			return 1;

		// If requested perform extended matching
		if (flags & PAKFIRE_FILELIST_EXTENDED_MATCHING) {
			// / matches everything
			if (strcmp(*pattern, "/") == 0)
				return 1;

			// Try to match any sub-directories and files
			r = pakfire_string_format(buffer, "%s/**", *pattern);
			if (r)
				return 1;

			if (pakfire_path_match(buffer, path))
				return 1;
		}
	}

	// No match
	return 0;
}

struct pakfire_filelist_matches {
	const char* root;
	const char** includes;
	const char** excludes;
	const int flags;
};

static int pakfire_filelist_scan_filter(struct archive* archive, void* p,
		struct archive_entry* entry) {
	const struct pakfire_filelist_matches* matches = p;

	// Descend if possible
	if (archive_read_disk_can_descend(archive))
		archive_read_disk_descend(archive);

	// Fetch the path
	const char* path = archive_entry_pathname(entry);

	// Make the path relative to the root
	path = pakfire_path_relpath(matches->root, path);

	// Skip the root
	if (!path || !*path)
		return 0;

	// Should we skip any directories?
	if (matches->flags & PAKFIRE_FILELIST_NO_DIRECTORIES) {
		mode_t filetype = archive_entry_filetype(entry);

		if (filetype == S_IFDIR)
			return 0;
	}

	// Skip excludes
	if (matches->excludes &&
			pakfire_filelist_match_patterns(path, matches->excludes, matches->flags))
		return 0;

	// Skip what is not included
	if (matches->includes &&
			!pakfire_filelist_match_patterns(path, matches->includes, matches->flags))
		return 0;

	// Store the new path
	archive_entry_set_pathname(entry, path);

	return 1;
}

int pakfire_filelist_scan(struct pakfire_filelist* list, const char* root,
		const char** includes, const char** excludes, int flags) {
	struct archive* reader = NULL;
	struct pakfire_file* file = NULL;
	struct archive_entry* entry = NULL;
	struct pakfire_filelist_matches matches = {
		.root     = root,
		.includes = includes,
		.excludes = excludes,
		.flags    = flags,
	};
	int r = 1;

	// Root must be absolute
	if (!pakfire_path_is_absolute(root)) {
		errno = EINVAL;
		return 1;
	}

	DEBUG(list->pakfire, "Scanning %s...\n", root);

	if (includes) {
		DEBUG(list->pakfire, "  Includes:\n");

		for (const char** include = includes; *include; include++)
			DEBUG(list->pakfire, "    %s\n", *include);
	}

	if (excludes) {
		DEBUG(list->pakfire, "  Excludes:\n");

		for (const char** exclude = excludes; *exclude; exclude++)
			DEBUG(list->pakfire, "    %s\n", *exclude);
	}

	// Check if the path exists
	if (!pakfire_path_exists(root)) {
		DEBUG(list->pakfire, "Path to scan (%s) does not exist\n", root);
		r = 0;
		goto ERROR;
	}

	// Create a new disk reader
	reader = pakfire_make_archive_disk_reader(list->pakfire, 1);
	if (!reader)
		goto ERROR;

	// Start reading from here
	r = archive_read_disk_open(reader, root);
	if (r) {
		ERROR(list->pakfire, "Could not open %s: %s\n", root,
			archive_error_string(reader));
		goto ERROR;
	}

	// Configure filter function
	r = archive_read_disk_set_metadata_filter_callback(reader,
		pakfire_filelist_scan_filter, &matches);
	if (r) {
		ERROR(list->pakfire, "Could not set filter callback: %s\n",
			archive_error_string(reader));
		goto ERROR;
	}

	// Walk through all files
	for (;;) {
		r = archive_read_next_header(reader, &entry);

		// Handle the return code
		switch (r) {
			// Fall through if everything is okay
			case ARCHIVE_OK:
				break;

			// Return OK when we reached the end of the archive
			case ARCHIVE_EOF:
				r = 0;
				goto ERROR;

			// Raise any other errors
			default:
				ERROR(list->pakfire, "Could not read next file: %s\n",
					archive_error_string(reader));
				goto ERROR;
		}

		// Create file
		r = pakfire_file_create_from_archive_entry(&file, list->pakfire, entry);
		if (r)
			goto ERROR;

		// Append it to the list
		r = pakfire_filelist_add(list, file);
		if (r) {
			pakfire_file_unref(file);
			goto ERROR;
		}

		pakfire_file_unref(file);
	}

ERROR:
	if (reader)
		archive_read_free(reader);

	return r;
}

int pakfire_filelist_contains(struct pakfire_filelist* list, const char* pattern) {
	struct pakfire_filelist_element* element = NULL;

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

	TAILQ_FOREACH(element, &list->files, nodes) {
		const char* path = pakfire_file_get_path(element->file);
		if (!path)
			return -1;

		if (pakfire_path_match(pattern, path))
			return 1;
	}

	return 0;
}

int pakfire_filelist_walk(struct pakfire_filelist* list,
		pakfire_filelist_walk_callback callback, void* data, int flags) {
	struct pakfire_progress* progress = NULL;
	struct pakfire_filelist_element* element = NULL;
	int r = 0;

	// Show progress when iterating over the filelist
	if (flags & PAKFIRE_FILELIST_SHOW_PROGRESS) {
		r = pakfire_progress_create(&progress, list->ctx,
			PAKFIRE_PROGRESS_SHOW_PERCENTAGE|PAKFIRE_PROGRESS_SHOW_ETA, NULL);
		if (r)
			goto ERROR;

		// Set title
		r = pakfire_progress_set_title(progress, "%s", _("Processing Files..."));
		if (r)
			goto ERROR;

		const size_t length = pakfire_filelist_length(list);

		// Start progress
		r = pakfire_progress_start(progress, length);
		if (r)
			goto ERROR;
	}

	// Call the callback once for every element on the list
	TAILQ_FOREACH(element, &list->files, nodes) {
		// Increment the progress
		if (progress)
			pakfire_progress_increment(progress, 1);

		// Call the callback
		r = callback(list->pakfire, element->file, data);
		if (r)
			break;
	}

	// Done!
	if (progress) {
		r = pakfire_progress_finish(progress);
		if (r)
			goto ERROR;
	}

ERROR:
	// Finish progress
	if (progress)
		pakfire_progress_unref(progress);

	return r;
}

static int __pakfire_filelist_dump(
		struct pakfire* pakfire, struct pakfire_file* file, void* data) {
	int* flags = (int*)data;

	char* s = pakfire_file_dump(file, *flags);
	if (s) {
		INFO(pakfire, "%s\n", s);
		free(s);
	}

	return 0;
}

int pakfire_filelist_dump(struct pakfire_filelist* list, int flags) {
	return pakfire_filelist_walk(list, __pakfire_filelist_dump, &flags, 0);
}

/*
	Verifies all files on the filelist
*/
int pakfire_filelist_verify(struct pakfire_filelist* list, struct pakfire_filelist* errors) {
	struct pakfire_filelist_element* element = NULL;
	struct pakfire_progress* progress = NULL;
	int status;
	int r;

	const size_t length = pakfire_filelist_length(list);

	DEBUG(list->pakfire, "Verifying filelist (%zu file(s))...\n", length);

	// Setup progress
	r = pakfire_progress_create(&progress, list->ctx,
		PAKFIRE_PROGRESS_SHOW_PERCENTAGE|PAKFIRE_PROGRESS_SHOW_ETA, NULL);
	if (r)
		goto ERROR;

	// Add title
	r = pakfire_progress_set_title(progress, "%s", _("Verifying Files..."));
	if (r)
		goto ERROR;

	// Start the progress indicator
	r = pakfire_progress_start(progress, length);
	if (r)
		goto ERROR;

	// Iterate over the entire list
	TAILQ_FOREACH(element, &list->files, nodes) {
		// Verify the file
		r = pakfire_file_verify(element->file, &status);
		if (r)
			goto ERROR;

		// If the verification failed, we append it to the errors list
		if (status) {
			// Append the file to the error list
			r = pakfire_filelist_add(errors, element->file);
			if (r)
				goto ERROR;
		}

		// Increment progress
		r = pakfire_progress_increment(progress, 1);
		if (r)
			goto ERROR;
	}

	// Finish
	r = pakfire_progress_finish(progress);
	if (r)
		goto ERROR;

ERROR:
	if (progress)
		pakfire_progress_unref(progress);

	return r;
}

int pakfire_filelist_cleanup(struct pakfire_filelist* list, int flags) {
	struct pakfire_filelist_element* element = NULL;
	int r;

	// Nothing to do if the filelist is empty
	if (pakfire_filelist_is_empty(list))
		return 0;

	// Walk through the list backwards
	TAILQ_FOREACH_REVERSE(element, &list->files, entries, nodes) {
		r = pakfire_file_cleanup(element->file, flags);
		if (r)
			return r;
	}

	return 0;
}

static int __pakfire_filelist_matches_class(struct pakfire* pakfire,
		struct pakfire_file* file, void* p) {
	int* class = (int*)p;

	return pakfire_file_matches_class(file, *class);
}

/*
	Returns true if any file on the list matches class
*/
int pakfire_filelist_matches_class(struct pakfire_filelist* list, int class) {
	return pakfire_filelist_walk(list, __pakfire_filelist_matches_class, &class, 0);
}