xref: /freebsd/usr.sbin/pkg/config.c (revision c1557708f1fae1bb9c8e23e3bbb2aa2b055e1211)

/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2014-2025 Baptiste Daroussin <bapt@FreeBSD.org>
 * Copyright (c) 2013 Bryan Drewery <bdrewery@FreeBSD.org>
 *
 * 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 AUTHOR 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 AUTHOR 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.
 */

#include <sys/param.h>
#include <sys/queue.h>
#include <sys/utsname.h>
#include <sys/sysctl.h>

#include <dirent.h>
#include <ucl.h>
#include <err.h>
#include <errno.h>
#include <libutil.h>
#include <paths.h>
#include <stdbool.h>
#include <unistd.h>
#include <ctype.h>

#include "config.h"

struct config_value {
	char *value;
	STAILQ_ENTRY(config_value) next;
};

struct config_entry {
	uint8_t type;
	const char *key;
	const char *val;
	char *value;
	STAILQ_HEAD(, config_value) *list;
	bool envset;
	bool main_only;				/* Only set in pkg.conf. */
};

static struct repositories repositories = STAILQ_HEAD_INITIALIZER(repositories);

static struct config_entry c[] = {
	[PACKAGESITE] = {
		PKG_CONFIG_STRING,
		"PACKAGESITE",
		URL_SCHEME_PREFIX "http://pkg.FreeBSD.org/${ABI}/latest",
		NULL,
		NULL,
		false,
		false,
	},
	[ABI] = {
		PKG_CONFIG_STRING,
		"ABI",
		NULL,
		NULL,
		NULL,
		false,
		true,
	},
	[MIRROR_TYPE] = {
		PKG_CONFIG_STRING,
		"MIRROR_TYPE",
		"SRV",
		NULL,
		NULL,
		false,
		false,
	},
	[ASSUME_ALWAYS_YES] = {
		PKG_CONFIG_BOOL,
		"ASSUME_ALWAYS_YES",
		"NO",
		NULL,
		NULL,
		false,
		true,
	},
	[SIGNATURE_TYPE] = {
		PKG_CONFIG_STRING,
		"SIGNATURE_TYPE",
		NULL,
		NULL,
		NULL,
		false,
		false,
	},
	[FINGERPRINTS] = {
		PKG_CONFIG_STRING,
		"FINGERPRINTS",
		NULL,
		NULL,
		NULL,
		false,
		false,
	},
	[REPOS_DIR] = {
		PKG_CONFIG_LIST,
		"REPOS_DIR",
		NULL,
		NULL,
		NULL,
		false,
		true,
	},
	[PUBKEY] = {
		PKG_CONFIG_STRING,
		"PUBKEY",
		NULL,
		NULL,
		NULL,
		false,
		false
	},
	[PKG_ENV] = {
		PKG_CONFIG_OBJECT,
		"PKG_ENV",
		NULL,
		NULL,
		NULL,
		false,
		false,
	}
};

static char *
pkg_get_myabi(void)
{
	struct utsname uts;
	char machine_arch[255];
	char *abi;
	size_t len;
	int error;

	error = uname(&uts);
	if (error)
		return (NULL);

	len = sizeof(machine_arch);
	error = sysctlbyname("hw.machine_arch", machine_arch, &len, NULL, 0);
	if (error)
		return (NULL);
	machine_arch[len] = '\0';

	/*
	 * Use __FreeBSD_version rather than kernel version (uts.release) for
	 * use in jails. This is equivalent to the value of uname -U.
	 */
	error = asprintf(&abi, "%s:%d:%s", uts.sysname, __FreeBSD_version/100000,
	    machine_arch);
	if (error < 0)
		return (NULL);

	return (abi);
}

static void
subst_packagesite(const char *abi)
{
	char *newval;
	const char *variable_string;
	const char *oldval;

	if (c[PACKAGESITE].value != NULL)
		oldval = c[PACKAGESITE].value;
	else
		oldval = c[PACKAGESITE].val;

	if ((variable_string = strstr(oldval, "${ABI}")) == NULL)
		return;

	asprintf(&newval, "%.*s%s%s",
	    (int)(variable_string - oldval), oldval, abi,
	    variable_string + strlen("${ABI}"));
	if (newval == NULL)
		errx(EXIT_FAILURE, "asprintf");

	free(c[PACKAGESITE].value);
	c[PACKAGESITE].value = newval;
}

static int
boolstr_to_bool(const char *str)
{
	if (str != NULL && (strcasecmp(str, "true") == 0 ||
	    strcasecmp(str, "yes") == 0 || strcasecmp(str, "on") == 0 ||
	    str[0] == '1'))
		return (true);

	return (false);
}

static void
config_parse(const ucl_object_t *obj)
{
	FILE *buffp;
	char *buf = NULL;
	size_t bufsz = 0;
	const ucl_object_t *cur, *seq, *tmp;
	ucl_object_iter_t it = NULL, itseq = NULL, it_obj = NULL;
	struct config_entry *temp_config;
	struct config_value *cv;
	const char *key, *evkey;
	int i;
	size_t j;

	/* Temporary config for configs that may be disabled. */
	temp_config = calloc(CONFIG_SIZE, sizeof(struct config_entry));
	buffp = open_memstream(&buf, &bufsz);
	if (buffp == NULL)
		err(EXIT_FAILURE, "open_memstream()");

	while ((cur = ucl_iterate_object(obj, &it, true))) {
		key = ucl_object_key(cur);
		if (key == NULL)
			continue;
		if (buf != NULL)
			memset(buf, 0, bufsz);
		rewind(buffp);

			for (j = 0; j < strlen(key); ++j)
				fputc(toupper(key[j]), buffp);
			fflush(buffp);

		for (i = 0; i < CONFIG_SIZE; i++) {
			if (strcmp(buf, c[i].key) == 0)
				break;
		}

		/* Silently skip unknown keys to be future compatible. */
		if (i == CONFIG_SIZE)
			continue;

		/* env has priority over config file */
		if (c[i].envset)
			continue;

		/* Parse sequence value ["item1", "item2"] */
		switch (c[i].type) {
		case PKG_CONFIG_LIST:
			if (cur->type != UCL_ARRAY) {
				warnx("Skipping invalid array "
				    "value for %s.\n", c[i].key);
				continue;
			}
			temp_config[i].list =
			    malloc(sizeof(*temp_config[i].list));
			STAILQ_INIT(temp_config[i].list);

			while ((seq = ucl_iterate_object(cur, &itseq, true))) {
				if (seq->type != UCL_STRING)
					continue;
				cv = malloc(sizeof(struct config_value));
				cv->value =
				    strdup(ucl_object_tostring(seq));
				STAILQ_INSERT_TAIL(temp_config[i].list, cv,
				    next);
			}
			break;
		case PKG_CONFIG_BOOL:
			temp_config[i].value =
			    strdup(ucl_object_toboolean(cur) ? "yes" : "no");
			break;
		case PKG_CONFIG_OBJECT:
			if (strcmp(c[i].key, "PKG_ENV") == 0) {
				while ((tmp =
				    ucl_iterate_object(cur, &it_obj, true))) {
					evkey = ucl_object_key(tmp);
					if (evkey != NULL && *evkey != '\0') {
						setenv(evkey, ucl_object_tostring_forced(tmp), 1);
					}
				}
			}
			break;
		default:
			/* Normal string value. */
			temp_config[i].value = strdup(ucl_object_tostring(cur));
			break;
		}
	}

	/* Repo is enabled, copy over all settings from temp_config. */
	for (i = 0; i < CONFIG_SIZE; i++) {
		if (c[i].envset)
			continue;
		/* Prevent overriding ABI, ASSUME_ALWAYS_YES, etc. */
		if (c[i].main_only == true)
			continue;
		switch (c[i].type) {
		case PKG_CONFIG_LIST:
			c[i].list = temp_config[i].list;
			break;
		default:
			c[i].value = temp_config[i].value;
			break;
		}
	}

	free(temp_config);
	fclose(buffp);
	free(buf);
}


static void
parse_mirror_type(struct repository *r, const char *mt)
{
	if (strcasecmp(mt, "srv") == 0)
		r->mirror_type = MIRROR_SRV;
	r->mirror_type = MIRROR_NONE;
}

static void
repo_free(struct repository *r)
{
	free(r->name);
	free(r->url);
	free(r->fingerprints);
	free(r->pubkey);
	free(r);
}

static bool
parse_signature_type(struct repository *repo, const char *st)
{
	if (strcasecmp(st, "FINGERPRINTS") == 0)
		repo->signature_type = SIGNATURE_FINGERPRINT;
	else if (strcasecmp(st, "PUBKEY") == 0)
		repo->signature_type = SIGNATURE_PUBKEY;
	else if (strcasecmp(st, "NONE") == 0)
		repo->signature_type = SIGNATURE_NONE;
	else {
		warnx("Signature type %s is not supported for bootstrapping,"
		    " ignoring repository %s", st, repo->name);
		return (false);
	}
	return (true);
}

static struct repository *
find_repository(const char *name)
{
	struct repository *repo;
	STAILQ_FOREACH(repo, &repositories, next) {
		if (strcmp(repo->name, name) == 0)
			return (repo);
	}
	return (NULL);
}

static void
parse_repo(const ucl_object_t *o)
{
	const ucl_object_t *cur;
	const char *key, *reponame;
	ucl_object_iter_t it = NULL;
	bool newrepo = false;
	struct repository *repo;

	reponame = ucl_object_key(o);
	repo = find_repository(reponame);
	if (repo == NULL) {
		repo = calloc(1, sizeof(struct repository));
		if (repo == NULL)
			err(EXIT_FAILURE, "calloc");

		repo->name = strdup(reponame);
		if (repo->name == NULL)
			err(EXIT_FAILURE, "strdup");
		newrepo = true;
	}
	while ((cur = ucl_iterate_object(o, &it, true))) {
		key = ucl_object_key(cur);
		if (key == NULL)
			continue;
		if (strcasecmp(key, "url") == 0) {
			free(repo->url);
			repo->url = strdup(ucl_object_tostring(cur));
			if (repo->url == NULL)
				err(EXIT_FAILURE, "strdup");
		} else if (strcasecmp(key, "mirror_type") == 0) {
			parse_mirror_type(repo, ucl_object_tostring(cur));
		} else if (strcasecmp(key, "signature_type") == 0) {
			if (!parse_signature_type(repo, ucl_object_tostring(cur))) {
				if (newrepo)
					repo_free(repo);
				else
					STAILQ_REMOVE(&repositories, repo, repository, next);
				return;
			}
		} else if (strcasecmp(key, "fingerprints") == 0) {
			free(repo->fingerprints);
			repo->fingerprints = strdup(ucl_object_tostring(cur));
			if (repo->fingerprints == NULL)
				err(EXIT_FAILURE, "strdup");
		} else if (strcasecmp(key, "pubkey") == 0) {
			free(repo->pubkey);
			repo->pubkey = strdup(ucl_object_tostring(cur));
			if (repo->pubkey == NULL)
				err(EXIT_FAILURE, "strdup");
		} else if (strcasecmp(key, "enabled") == 0) {
			if ((cur->type != UCL_BOOLEAN) ||
			    !ucl_object_toboolean(cur)) {
				if (newrepo)
					repo_free(repo);
				else
					STAILQ_REMOVE(&repositories, repo, repository, next);
				return;
			}
		}
	}
	/* At least we need an url */
	if (repo->url == NULL) {
		repo_free(repo);
		return;
	}
	if (newrepo)
		STAILQ_INSERT_TAIL(&repositories, repo, next);
	return;
}

/*-
 * Parse new repo style configs in style:
 * Name:
 *   URL:
 *   MIRROR_TYPE:
 * etc...
 */
static void
parse_repo_file(ucl_object_t *obj, const char *requested_repo)
{
	ucl_object_iter_t it = NULL;
	const ucl_object_t *cur;
	const char *key;

	while ((cur = ucl_iterate_object(obj, &it, true))) {
		key = ucl_object_key(cur);

		if (key == NULL)
			continue;

		if (cur->type != UCL_OBJECT)
			continue;

		if (requested_repo != NULL && strcmp(requested_repo, key) != 0)
			continue;
		parse_repo(cur);
	}
}


static int
read_conf_file(const char *confpath, const char *requested_repo,
    pkg_conf_file_t conftype)
{
	struct ucl_parser *p;
	ucl_object_t *obj = NULL;
	char *abi = pkg_get_myabi(), *major, *minor;
	struct utsname uts;
	int ret;

	if (uname(&uts))
		err(EXIT_FAILURE, "uname");
	if (abi == NULL)
		errx(EXIT_FAILURE, "Failed to determine ABI");

	p = ucl_parser_new(0);
	asprintf(&major, "%d",  __FreeBSD_version/100000);
	if (major == NULL)
		err(EXIT_FAILURE, "asprintf");
	asprintf(&minor, "%d",  (__FreeBSD_version / 1000) % 100);
	if (minor == NULL)
		err(EXIT_FAILURE, "asprintf");
	ucl_parser_register_variable(p, "ABI", abi);
	ucl_parser_register_variable(p, "OSNAME", uts.sysname);
	ucl_parser_register_variable(p, "RELEASE", major);
	ucl_parser_register_variable(p, "VERSION_MAJOR", major);
	ucl_parser_register_variable(p, "VERSION_MINOR", minor);

	if (!ucl_parser_add_file(p, confpath)) {
		if (errno != ENOENT)
			errx(EXIT_FAILURE, "Unable to parse configuration "
			    "file %s: %s", confpath, ucl_parser_get_error(p));
		/* no configuration present */
		ret = 1;
		goto out;
	}

	obj = ucl_parser_get_object(p);
	if (obj->type != UCL_OBJECT)
		warnx("Invalid configuration format, ignoring the "
		    "configuration file %s", confpath);
	else {
		if (conftype == CONFFILE_PKG)
			config_parse(obj);
		else if (conftype == CONFFILE_REPO)
			parse_repo_file(obj, requested_repo);
	}
	ucl_object_unref(obj);

	ret = 0;
out:
	ucl_parser_free(p);
	free(abi);
	free(major);
	free(minor);

	return (ret);
}

static void
load_repositories(const char *repodir, const char *requested_repo)
{
	struct dirent *ent;
	DIR *d;
	char *p;
	size_t n;
	char path[MAXPATHLEN];

	if ((d = opendir(repodir)) == NULL)
		return;

	while ((ent = readdir(d))) {
		/* Trim out 'repos'. */
		if ((n = strlen(ent->d_name)) <= 5)
			continue;
		p = &ent->d_name[n - 5];
		if (strcmp(p, ".conf") == 0) {
			snprintf(path, sizeof(path), "%s%s%s",
			    repodir,
			    repodir[strlen(repodir) - 1] == '/' ? "" : "/",
			    ent->d_name);
			if (access(path, F_OK) != 0)
				continue;
			if (read_conf_file(path, requested_repo,
			    CONFFILE_REPO)) {
				goto cleanup;
			}
		}
	}

cleanup:
	closedir(d);
}

int
config_init(const char *requested_repo)
{
	char *val;
	int i;
	const char *localbase;
	char *abi, *env_list_item;
	char confpath[MAXPATHLEN];
	struct config_value *cv;

	for (i = 0; i < CONFIG_SIZE; i++) {
		val = getenv(c[i].key);
		if (val != NULL) {
			c[i].envset = true;
			switch (c[i].type) {
			case PKG_CONFIG_LIST:
				/* Split up comma-separated items from env. */
				c[i].list = malloc(sizeof(*c[i].list));
				STAILQ_INIT(c[i].list);
				for (env_list_item = strtok(val, ",");
				    env_list_item != NULL;
				    env_list_item = strtok(NULL, ",")) {
					cv =
					    malloc(sizeof(struct config_value));
					cv->value =
					    strdup(env_list_item);
					STAILQ_INSERT_TAIL(c[i].list, cv,
					    next);
				}
				break;
			default:
				c[i].val = val;
				break;
			}
		}
	}

	/* Read LOCALBASE/etc/pkg.conf first. */
	localbase = getlocalbase();
	snprintf(confpath, sizeof(confpath), "%s/etc/pkg.conf", localbase);

	if (access(confpath, F_OK) == 0 && read_conf_file(confpath, NULL,
	    CONFFILE_PKG))
		goto finalize;

	/* Then read in all repos from REPOS_DIR list of directories. */
	if (c[REPOS_DIR].list == NULL) {
		c[REPOS_DIR].list = malloc(sizeof(*c[REPOS_DIR].list));
		STAILQ_INIT(c[REPOS_DIR].list);
		cv = malloc(sizeof(struct config_value));
		cv->value = strdup("/etc/pkg");
		STAILQ_INSERT_TAIL(c[REPOS_DIR].list, cv, next);
		cv = malloc(sizeof(struct config_value));
		if (asprintf(&cv->value, "%s/etc/pkg/repos", localbase) < 0)
			goto finalize;
		STAILQ_INSERT_TAIL(c[REPOS_DIR].list, cv, next);
	}

	STAILQ_FOREACH(cv, c[REPOS_DIR].list, next)
		load_repositories(cv->value, requested_repo);

finalize:
	if (c[ABI].val == NULL && c[ABI].value == NULL) {
		abi = pkg_get_myabi();
		if (abi == NULL)
			errx(EXIT_FAILURE, "Failed to determine the system "
			    "ABI");
		c[ABI].val = abi;
	}

	return (0);
}

int
config_string(pkg_config_key k, const char **val)
{
	if (c[k].type != PKG_CONFIG_STRING)
		return (-1);

	if (c[k].value != NULL)
		*val = c[k].value;
	else
		*val = c[k].val;

	return (0);
}

int
config_bool(pkg_config_key k, bool *val)
{
	const char *value;

	if (c[k].type != PKG_CONFIG_BOOL)
		return (-1);

	*val = false;

	if (c[k].value != NULL)
		value = c[k].value;
	else
		value = c[k].val;

	if (boolstr_to_bool(value))
		*val = true;

	return (0);
}

struct repositories *
config_get_repositories(void)
{
	if (STAILQ_EMPTY(&repositories)) {
		/* Fall back to PACKAGESITE - deprecated - */
		struct repository *r = calloc(1, sizeof(*r));
		if (r == NULL)
			err(EXIT_FAILURE, "calloc");
		r->name = strdup("fallback");
		if (r->name == NULL)
			err(EXIT_FAILURE, "strdup");
		subst_packagesite(c[ABI].value != NULL ? c[ABI].value : c[ABI].val);
		r->url = c[PACKAGESITE].value;
		if (c[SIGNATURE_TYPE].value != NULL)
			if (!parse_signature_type(r, c[SIGNATURE_TYPE].value))
				exit(EXIT_FAILURE);
		if (c[MIRROR_TYPE].value != NULL)
			parse_mirror_type(r, c[MIRROR_TYPE].value);
		if (c[PUBKEY].value != NULL)
			r->pubkey = c[PUBKEY].value;
		if (c[FINGERPRINTS].value != NULL)
			r->fingerprints = c[FINGERPRINTS].value;
		STAILQ_INSERT_TAIL(&repositories, r, next);
	}
	return (&repositories);
}

void
config_finish(void) {
	int i;

	for (i = 0; i < CONFIG_SIZE; i++)
		free(c[i].value);
}