/*	$NetBSD: iterate.c,v 1.2.14.1 2020/12/08 18:45:58 martin Exp $	*/

/*-
 * Copyright (c) 2007 Joerg Sonnenberger <joerg@NetBSD.org>.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#if HAVE_CONFIG_H
#include "config.h"
#endif

#include <nbcompat.h>

#if HAVE_ERR_H
#include <err.h>
#endif
#if HAVE_ERRNO_H
#include <errno.h>
#endif

#include "lib.h"

/*
 * We define a couple of different caches to hold frequently accessed data.
 *
 * Firstly, we cache the results of readdir() on the package database directory
 * when using iterate_pkg_db_cached().  This helps a lot during recursive calls
 * and avoids exponential system calls, but is not suitable for situations
 * where the database directory may be updated, for example during installs.
 * In those situations the regular iterate_pkg_db() must be used.
 *
 * Secondly, we have a cache for matches of pattern lookups, avoiding expensive
 * pkg_match() calls each time.
 */
struct pkg_db_list {
	char *pkgname;
	SLIST_ENTRY(pkg_db_list) entries;
};
SLIST_HEAD(pkg_db_list_head, pkg_db_list);

struct pkg_match_list {
	char *pattern;
	char *pkgname;
	SLIST_ENTRY(pkg_match_list) entries;
};
SLIST_HEAD(pkg_match_list_head, pkg_match_list);

static struct pkg_db_list_head pkg_list_cache;
static struct pkg_match_list_head pkg_match_cache[PKG_HASH_SIZE];

/*
 * Generic iteration function:
 * - get new entries from srciter, stop on NULL
 * - call matchiter for those entries, stop on non-null return value.
 */
int
iterate_pkg_generic_src(int (*matchiter)(const char *, void *),
    void *match_cookie, const char *(*srciter)(void *), void *src_cookie)
{
	int retval;
	const char *entry;

	retval = 0;

	while ((entry = (*srciter)(src_cookie)) != NULL) {
		if ((retval = (*matchiter)(entry, match_cookie)) != 0)
			break;
	}

	return retval;
}

struct pkg_dir_iter_arg {
	DIR *dirp;
	int filter_suffix;
	int allow_nonfiles;
};

static const char *
pkg_dir_iter(void *cookie)
{
	struct pkg_dir_iter_arg *arg = cookie;
	struct dirent *dp;
	size_t len;

	while ((dp = readdir(arg->dirp)) != NULL) {
#if defined(DT_UNKNOWN) && defined(DT_DIR)
		if (arg->allow_nonfiles == 0 &&
		    dp->d_type != DT_UNKNOWN && dp->d_type != DT_REG)
			continue;
#endif
		len = strlen(dp->d_name);
		/* .tbz or .tgz suffix length + some prefix*/
		if (len < 5)
			continue;
		if (arg->filter_suffix == 0 ||
		    memcmp(dp->d_name + len - 4, ".tgz", 4) == 0 ||
		    memcmp(dp->d_name + len - 4, ".tbz", 4) == 0)
			return dp->d_name;
	}
	return NULL;
}

/*
 * Call matchiter for every package in the directory.
 */
int
iterate_local_pkg_dir(const char *dir, int filter_suffix, int allow_nonfiles,
    int (*matchiter)(const char *, void *), void *cookie)
{
	struct pkg_dir_iter_arg arg;
	int retval;

	if ((arg.dirp = opendir(dir)) == NULL)
		return -1;

	arg.filter_suffix = filter_suffix;
	arg.allow_nonfiles = allow_nonfiles;
	retval = iterate_pkg_generic_src(matchiter, cookie, pkg_dir_iter, &arg);

	if (closedir(arg.dirp) == -1)
		return -1;
	return retval;
}

static const char *
pkg_db_iter(void *cookie)
{
	DIR *dirp = cookie;
	struct dirent *dp;

	while ((dp = readdir(dirp)) != NULL) {
		if (strcmp(dp->d_name, ".") == 0)
			continue;
		if (strcmp(dp->d_name, "..") == 0)
			continue;
		if (strcmp(dp->d_name, "pkgdb.byfile.db") == 0)
			continue;
		if (strcmp(dp->d_name, ".cookie") == 0)
			continue;
		if (strcmp(dp->d_name, "pkg-vulnerabilities") == 0)
			continue;
#if defined(DT_UNKNOWN) && defined(DT_DIR)
		if (dp->d_type != DT_UNKNOWN && dp->d_type != DT_DIR)
			continue;
#endif
		return dp->d_name;
	}
	return NULL;
}

/*
 * Call matchiter for every installed package.
 */
int
iterate_pkg_db(int (*matchiter)(const char *, void *), void *cookie)
{
	DIR *dirp;
	int retval;

	if ((dirp = opendir(pkgdb_get_dir())) == NULL) {
		if (errno == ENOENT)
			return 0; /* No pkgdb directory == empty pkgdb */
		return -1;
	}

	retval = iterate_pkg_generic_src(matchiter, cookie, pkg_db_iter, dirp);

	if (closedir(dirp) == -1)
		return -1;
	return retval;
}

struct pkg_db_iter_arg {
	struct pkg_db_list_head head;
	struct pkg_db_list *list;
};

static const char *
pkg_db_iter_cached(void *cookie)
{
	struct pkg_db_iter_arg *arg = cookie;

	if (arg->list == NULL)
		arg->list = SLIST_FIRST(&arg->head);
	else
		arg->list = SLIST_NEXT(arg->list, entries);

	if (arg->list != NULL)
		return arg->list->pkgname;

	return NULL;
}

/*
 * Call matchiter for every installed package, using cached data to
 * significantly increase performance during recursive calls.
 *
 * This is not suitable for every situation, for example when finding new
 * matches after package installation/removal.  In those situations the
 * regular iterate_pkg_db() must be used.
 */
static int
iterate_pkg_db_cached(int (*matchiter)(const char *, void *), void *cookie)
{
	DIR *dirp;
	struct pkg_db_iter_arg arg;
	struct pkg_db_list *pkg;
	const char *pkgdir;
	int retval;

	if (SLIST_EMPTY(&pkg_list_cache)) {
		SLIST_INIT(&pkg_list_cache);

		if ((dirp = opendir(pkgdb_get_dir())) == NULL) {
			if (errno == ENOENT)
				return 0; /* Empty pkgdb */
			return -1;
		}

		while ((pkgdir = pkg_db_iter(dirp)) != NULL) {
			pkg = xmalloc(sizeof(struct pkg_db_list));
			pkg->pkgname = xstrdup(pkgdir);
			SLIST_INSERT_HEAD(&pkg_list_cache, pkg, entries);
		}

		if (closedir(dirp) == -1)
			return -1;
	}

	arg.head = pkg_list_cache;
	arg.list = NULL;

	retval = iterate_pkg_generic_src(matchiter, cookie,
	    pkg_db_iter_cached, &arg);

	return retval;
}

static int
match_by_basename(const char *pkg, void *cookie)
{
	const char *target = cookie;
	const char *pkg_version;

	if ((pkg_version = strrchr(pkg, '-')) == NULL) {
		warnx("Entry %s in pkgdb is not a valid package name", pkg);
		return 0;
	}
	if (strncmp(pkg, target, pkg_version - pkg) == 0 &&
	    pkg + strlen(target) == pkg_version)
		return 1;
	else
		return 0;
}

static int
match_by_pattern(const char *pkg, void *cookie)
{
	const char *pattern = cookie;

	return pkg_match(pattern, pkg);
}

struct add_matching_arg {
	lpkg_head_t *pkghead;
	int got_match;
	int (*match_fn)(const char *pkg, void *cookie);
	void *cookie;
};

static int
match_and_add(const char *pkg, void *cookie)
{
	struct add_matching_arg *arg = cookie;
	lpkg_t *lpp;

	if ((*arg->match_fn)(pkg, arg->cookie) == 1) {
		arg->got_match = 1;

		lpp = alloc_lpkg(pkg);
		TAILQ_INSERT_TAIL(arg->pkghead, lpp, lp_link);
	}
	return 0;
}

/*
 * Find all installed packages with the given basename and add them
 * to pkghead.
 * Returns -1 on error, 0 if no match was found and 1 otherwise.
 */
int
add_installed_pkgs_by_basename(const char *pkgbase, lpkg_head_t *pkghead)
{
	struct add_matching_arg arg;

	arg.pkghead = pkghead;
	arg.got_match = 0;
	arg.match_fn = match_by_basename;
	arg.cookie = __UNCONST(pkgbase);

	if (iterate_pkg_db(match_and_add, &arg) == -1) {
		warnx("could not process pkgdb");
		return -1;
	}
	return arg.got_match;
}

/*
 * Match all installed packages against pattern, add the matches to pkghead.
 * Returns -1 on error, 0 if no match was found and 1 otherwise.
 */
int
add_installed_pkgs_by_pattern(const char *pattern, lpkg_head_t *pkghead)
{
	struct add_matching_arg arg;

	arg.pkghead = pkghead;
	arg.got_match = 0;
	arg.match_fn = match_by_pattern;
	arg.cookie = __UNCONST(pattern);

	if (iterate_pkg_db(match_and_add, &arg) == -1) {
		warnx("could not process pkgdb");
		return -1;
	}
	return arg.got_match;
}

struct best_installed_match_arg {
	const char *pattern;
	char *best_current_match;
};

static int
match_best_installed(const char *pkg, void *cookie)
{
	struct best_installed_match_arg *arg = cookie;

	switch (pkg_order(arg->pattern, pkg, arg->best_current_match)) {
	case 0:
	case 2:
		/*
		 * Either current package doesn't match or
		 * the older match is better. Nothing to do.
		 */
		break;
	case 1:
		/* Current package is better, remember it. */
		free(arg->best_current_match);
		arg->best_current_match = xstrdup(pkg);
		break;
	}
	return 0;
}

/*
 * Returns a copy of the name of best matching package.
 * If no package matched the pattern or an error occured, return NULL.
 *
 * If use_cached is set, return a cached match entry if it exists, and also use
 * the iterate_pkg_db cache, otherwise clear any matching cache entry and use
 * regular iterate_pkg_db().
 */
char *
find_best_matching_installed_pkg(const char *pattern, int use_cached)
{
	struct best_installed_match_arg arg;
	struct pkg_match_list *pkg;
	int idx = PKG_HASH_ENTRY(pattern), rv;

	if (pattern == NULL)
		return NULL;

	SLIST_FOREACH(pkg, &pkg_match_cache[idx], entries) {
		if (strcmp(pattern, pkg->pattern) == 0) {
			if (use_cached)
				return xstrdup(pkg->pkgname);
			SLIST_REMOVE(&pkg_match_cache[idx], pkg,
			    pkg_match_list, entries);
			free(pkg->pattern);
			free(pkg->pkgname);
			free(pkg);
			break;
		}
	}

	arg.pattern = pattern;
	arg.best_current_match = NULL;

	if (use_cached)
		rv = iterate_pkg_db_cached(match_best_installed, &arg);
	else
		rv = iterate_pkg_db(match_best_installed, &arg);

	if (rv == -1) {
		warnx("could not process pkgdb");
		return NULL;
	}

	if (arg.best_current_match != NULL) {
		pkg = xmalloc(sizeof(struct pkg_match_list));
		pkg->pattern = xstrdup(pattern);
		pkg->pkgname = xstrdup(arg.best_current_match);
		SLIST_INSERT_HEAD(&pkg_match_cache[idx],
		    pkg, entries);
	}

	return arg.best_current_match;
}

struct call_matching_arg {
	const char *pattern;
	int (*call_fn)(const char *pkg, void *cookie);
	void *cookie;
};

static int
match_and_call(const char *pkg, void *cookie)
{
	struct call_matching_arg *arg = cookie;

	if (pkg_match(arg->pattern, pkg) == 1) {
		return (*arg->call_fn)(pkg, arg->cookie);
	} else
		return 0;
}

/*
 * Find all packages that match the given pattern and call the function
 * for each of them. Iteration stops if the callback return non-0.
 * Returns -1 on error, 0 if the iteration finished or whatever the
 * callback returned otherwise.
 */
int
match_installed_pkgs(const char *pattern, int (*cb)(const char *, void *),
    void *cookie)
{
	struct call_matching_arg arg;

	arg.pattern = pattern;
	arg.call_fn = cb;
	arg.cookie = cookie;

	return iterate_pkg_db(match_and_call, &arg);
}

struct best_file_match_arg {
	const char *pattern;
	char *best_current_match_filtered;
	char *best_current_match;
	int filter_suffix;
};

static int
match_best_file(const char *filename, void *cookie)
{
	struct best_file_match_arg *arg = cookie;
	const char *active_filename;
	char *filtered_filename;

	if (arg->filter_suffix) {
		size_t len;

		len = strlen(filename);
		if (len < 5 ||
		    (memcmp(filename + len - 4, ".tgz", 4) != 0 &&
		     memcmp(filename + len - 4, ".tbz", 4) != 0)) {
			warnx("filename %s does not contain a recognized suffix", filename);
			return -1;
		}
		filtered_filename = xmalloc(len - 4 + 1);
		memcpy(filtered_filename, filename, len - 4);
		filtered_filename[len - 4] = '\0';
		active_filename = filtered_filename;
	} else {
		filtered_filename = NULL;
		active_filename = filename;
	}

	switch (pkg_order(arg->pattern, active_filename, arg->best_current_match_filtered)) {
	case 0:
	case 2:
		/*
		 * Either current package doesn't match or
		 * the older match is better. Nothing to do.
		 */
		free(filtered_filename);
		return 0;
	case 1:
		/* Current package is better, remember it. */
		free(arg->best_current_match);
		free(arg->best_current_match_filtered);
		arg->best_current_match = xstrdup(filename);
		if (filtered_filename != NULL)
			arg->best_current_match_filtered = filtered_filename;
		else
			arg->best_current_match_filtered = xstrdup(active_filename);
		return 0;
	default:
		errx(EXIT_FAILURE, "Invalid error from pkg_order");
		/* NOTREACHED */
	}
}

/*
 * Returns a copy of the name of best matching file.
 * If no package matched the pattern or an error occured, return NULL.
 */
char *
find_best_matching_file(const char *dir, const char *pattern, int filter_suffix, int allow_nonfiles)
{
	struct best_file_match_arg arg;

	arg.filter_suffix = filter_suffix;
	arg.pattern = pattern;
	arg.best_current_match = NULL;
	arg.best_current_match_filtered = NULL;

	if (iterate_local_pkg_dir(dir, filter_suffix, allow_nonfiles, match_best_file, &arg) == -1) {
		warnx("could not process directory");
		return NULL;
	}
	free(arg.best_current_match_filtered);

	return arg.best_current_match;
}

struct call_matching_file_arg {
	const char *pattern;
	int (*call_fn)(const char *pkg, void *cookie);
	void *cookie;
	int filter_suffix;
};

static int
match_file_and_call(const char *filename, void *cookie)
{
	struct call_matching_file_arg *arg = cookie;
	const char *active_filename;
	char *filtered_filename;
	int ret;

	if (arg->filter_suffix) {
		size_t len;

		len = strlen(filename);
		if (len < 5 ||
		    (memcmp(filename + len - 4, ".tgz", 4) != 0 &&
		     memcmp(filename + len - 4, ".tbz", 4) != 0)) {
			warnx("filename %s does not contain a recognized suffix", filename);
			return -1;
		}
		filtered_filename = xmalloc(len - 4 + 1);
		memcpy(filtered_filename, filename, len - 4);
		filtered_filename[len - 4] = '\0';
		active_filename = filtered_filename;
	} else {
		filtered_filename = NULL;
		active_filename = filename;
	}

	ret = pkg_match(arg->pattern, active_filename);
	free(filtered_filename);

	if (ret == 1)
		return (*arg->call_fn)(filename, arg->cookie);
	else
		return 0;
}

/*
 * Find all packages that match the given pattern and call the function
 * for each of them. Iteration stops if the callback return non-0.
 * Returns -1 on error, 0 if the iteration finished or whatever the
 * callback returned otherwise.
 */
int
match_local_files(const char *dir, int filter_suffix, int allow_nonfiles, const char *pattern,
    int (*cb)(const char *, void *), void *cookie)
{
	struct call_matching_file_arg arg;

	arg.pattern = pattern;
	arg.call_fn = cb;
	arg.cookie = cookie;
	arg.filter_suffix = filter_suffix;

	return iterate_local_pkg_dir(dir, filter_suffix, allow_nonfiles, match_file_and_call, &arg);
}