1/*-
2 * Copyright (c) 2014 Baptiste Daroussin <bapt@FreeBSD.org>
3 * Copyright (c) 2013 Bryan Drewery <bdrewery@FreeBSD.org>
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 *    notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 *    notice, this list of conditions and the following disclaimer in the
13 *    documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 */
27
28#include <sys/cdefs.h>
29__FBSDID("$FreeBSD: releng/10.3/usr.sbin/pkg/config.c 287809 2015-09-15 05:46:55Z bapt $");
30
31#include <sys/param.h>
32#include <sys/queue.h>
33#include <sys/sbuf.h>
34#include <sys/types.h>
35#include <sys/utsname.h>
36#include <sys/sysctl.h>
37
38#include <assert.h>
39#include <dirent.h>
40#include <ucl.h>
41#include <ctype.h>
42#include <err.h>
43#include <errno.h>
44#include <fcntl.h>
45#include <inttypes.h>
46#include <paths.h>
47#include <stdbool.h>
48#include <string.h>
49#include <unistd.h>
50
51#include "config.h"
52
53#define roundup2(x, y)	(((x)+((y)-1))&(~((y)-1))) /* if y is powers of two */
54
55struct config_value {
56       char *value;
57       STAILQ_ENTRY(config_value) next;
58};
59
60struct config_entry {
61	uint8_t type;
62	const char *key;
63	const char *val;
64	char *value;
65	STAILQ_HEAD(, config_value) *list;
66	bool envset;
67	bool main_only;				/* Only set in pkg.conf. */
68};
69
70static struct config_entry c[] = {
71	[PACKAGESITE] = {
72		PKG_CONFIG_STRING,
73		"PACKAGESITE",
74		URL_SCHEME_PREFIX "http://pkg.FreeBSD.org/${ABI}/latest",
75		NULL,
76		NULL,
77		false,
78		false,
79	},
80	[ABI] = {
81		PKG_CONFIG_STRING,
82		"ABI",
83		NULL,
84		NULL,
85		NULL,
86		false,
87		true,
88	},
89	[MIRROR_TYPE] = {
90		PKG_CONFIG_STRING,
91		"MIRROR_TYPE",
92		"SRV",
93		NULL,
94		NULL,
95		false,
96		false,
97	},
98	[ASSUME_ALWAYS_YES] = {
99		PKG_CONFIG_BOOL,
100		"ASSUME_ALWAYS_YES",
101		"NO",
102		NULL,
103		NULL,
104		false,
105		true,
106	},
107	[SIGNATURE_TYPE] = {
108		PKG_CONFIG_STRING,
109		"SIGNATURE_TYPE",
110		NULL,
111		NULL,
112		NULL,
113		false,
114		false,
115	},
116	[FINGERPRINTS] = {
117		PKG_CONFIG_STRING,
118		"FINGERPRINTS",
119		NULL,
120		NULL,
121		NULL,
122		false,
123		false,
124	},
125	[REPOS_DIR] = {
126		PKG_CONFIG_LIST,
127		"REPOS_DIR",
128		NULL,
129		NULL,
130		NULL,
131		false,
132		true,
133	},
134	[PUBKEY] = {
135		PKG_CONFIG_STRING,
136		"PUBKEY",
137		NULL,
138		NULL,
139		NULL,
140		false,
141		false
142	}
143};
144
145static int
146pkg_get_myabi(char *dest, size_t sz)
147{
148	struct utsname uts;
149	char machine_arch[255];
150	size_t len;
151	int error;
152
153	error = uname(&uts);
154	if (error)
155		return (errno);
156
157	len = sizeof(machine_arch);
158	error = sysctlbyname("hw.machine_arch", machine_arch, &len, NULL, 0);
159	if (error)
160		return (errno);
161	machine_arch[len] = '\0';
162
163	/*
164	 * Use __FreeBSD_version rather than kernel version (uts.release) for
165	 * use in jails. This is equivalent to the value of uname -U.
166	 */
167	snprintf(dest, sz, "%s:%d:%s", uts.sysname, __FreeBSD_version/100000,
168	    machine_arch);
169
170	return (error);
171}
172
173static void
174subst_packagesite(const char *abi)
175{
176	struct sbuf *newval;
177	const char *variable_string;
178	const char *oldval;
179
180	if (c[PACKAGESITE].value != NULL)
181		oldval = c[PACKAGESITE].value;
182	else
183		oldval = c[PACKAGESITE].val;
184
185	if ((variable_string = strstr(oldval, "${ABI}")) == NULL)
186		return;
187
188	newval = sbuf_new_auto();
189	sbuf_bcat(newval, oldval, variable_string - oldval);
190	sbuf_cat(newval, abi);
191	sbuf_cat(newval, variable_string + strlen("${ABI}"));
192	sbuf_finish(newval);
193
194	free(c[PACKAGESITE].value);
195	c[PACKAGESITE].value = strdup(sbuf_data(newval));
196}
197
198static int
199boolstr_to_bool(const char *str)
200{
201	if (str != NULL && (strcasecmp(str, "true") == 0 ||
202	    strcasecmp(str, "yes") == 0 || strcasecmp(str, "on") == 0 ||
203	    str[0] == '1'))
204		return (true);
205
206	return (false);
207}
208
209static void
210config_parse(const ucl_object_t *obj, pkg_conf_file_t conftype)
211{
212	struct sbuf *buf = sbuf_new_auto();
213	const ucl_object_t *cur, *seq;
214	ucl_object_iter_t it = NULL, itseq = NULL;
215	struct config_entry *temp_config;
216	struct config_value *cv;
217	const char *key;
218	int i;
219	size_t j;
220
221	/* Temporary config for configs that may be disabled. */
222	temp_config = calloc(CONFIG_SIZE, sizeof(struct config_entry));
223
224	while ((cur = ucl_iterate_object(obj, &it, true))) {
225		key = ucl_object_key(cur);
226		if (key == NULL)
227			continue;
228		sbuf_clear(buf);
229
230		if (conftype == CONFFILE_PKG) {
231			for (j = 0; j < strlen(key); ++j)
232				sbuf_putc(buf, key[j]);
233			sbuf_finish(buf);
234		} else if (conftype == CONFFILE_REPO) {
235			if (strcasecmp(key, "url") == 0)
236				sbuf_cpy(buf, "PACKAGESITE");
237			else if (strcasecmp(key, "mirror_type") == 0)
238				sbuf_cpy(buf, "MIRROR_TYPE");
239			else if (strcasecmp(key, "signature_type") == 0)
240				sbuf_cpy(buf, "SIGNATURE_TYPE");
241			else if (strcasecmp(key, "fingerprints") == 0)
242				sbuf_cpy(buf, "FINGERPRINTS");
243			else if (strcasecmp(key, "pubkey") == 0)
244				sbuf_cpy(buf, "PUBKEY");
245			else if (strcasecmp(key, "enabled") == 0) {
246				if ((cur->type != UCL_BOOLEAN) ||
247				    !ucl_object_toboolean(cur))
248					goto cleanup;
249			} else
250				continue;
251			sbuf_finish(buf);
252		}
253
254		for (i = 0; i < CONFIG_SIZE; i++) {
255			if (strcmp(sbuf_data(buf), c[i].key) == 0)
256				break;
257		}
258
259		/* Silently skip unknown keys to be future compatible. */
260		if (i == CONFIG_SIZE)
261			continue;
262
263		/* env has priority over config file */
264		if (c[i].envset)
265			continue;
266
267		/* Parse sequence value ["item1", "item2"] */
268		switch (c[i].type) {
269		case PKG_CONFIG_LIST:
270			if (cur->type != UCL_ARRAY) {
271				warnx("Skipping invalid array "
272				    "value for %s.\n", c[i].key);
273				continue;
274			}
275			temp_config[i].list =
276			    malloc(sizeof(*temp_config[i].list));
277			STAILQ_INIT(temp_config[i].list);
278
279			while ((seq = ucl_iterate_object(cur, &itseq, true))) {
280				if (seq->type != UCL_STRING)
281					continue;
282				cv = malloc(sizeof(struct config_value));
283				cv->value =
284				    strdup(ucl_object_tostring(seq));
285				STAILQ_INSERT_TAIL(temp_config[i].list, cv,
286				    next);
287			}
288			break;
289		case PKG_CONFIG_BOOL:
290			temp_config[i].value =
291			    strdup(ucl_object_toboolean(cur) ? "yes" : "no");
292			break;
293		default:
294			/* Normal string value. */
295			temp_config[i].value = strdup(ucl_object_tostring(cur));
296			break;
297		}
298	}
299
300	/* Repo is enabled, copy over all settings from temp_config. */
301	for (i = 0; i < CONFIG_SIZE; i++) {
302		if (c[i].envset)
303			continue;
304		/* Prevent overriding ABI, ASSUME_ALWAYS_YES, etc. */
305		if (conftype != CONFFILE_PKG && c[i].main_only == true)
306			continue;
307		switch (c[i].type) {
308		case PKG_CONFIG_LIST:
309			c[i].list = temp_config[i].list;
310			break;
311		default:
312			c[i].value = temp_config[i].value;
313			break;
314		}
315	}
316
317cleanup:
318	free(temp_config);
319	sbuf_delete(buf);
320}
321
322/*-
323 * Parse new repo style configs in style:
324 * Name:
325 *   URL:
326 *   MIRROR_TYPE:
327 * etc...
328 */
329static void
330parse_repo_file(ucl_object_t *obj)
331{
332	ucl_object_iter_t it = NULL;
333	const ucl_object_t *cur;
334	const char *key;
335
336	while ((cur = ucl_iterate_object(obj, &it, true))) {
337		key = ucl_object_key(cur);
338
339		if (key == NULL)
340			continue;
341
342		if (cur->type != UCL_OBJECT)
343			continue;
344
345		config_parse(cur, CONFFILE_REPO);
346	}
347}
348
349
350static int
351read_conf_file(const char *confpath, pkg_conf_file_t conftype)
352{
353	struct ucl_parser *p;
354	ucl_object_t *obj = NULL;
355
356	p = ucl_parser_new(0);
357
358	if (!ucl_parser_add_file(p, confpath)) {
359		if (errno != ENOENT)
360			errx(EXIT_FAILURE, "Unable to parse configuration "
361			    "file %s: %s", confpath, ucl_parser_get_error(p));
362		ucl_parser_free(p);
363		/* no configuration present */
364		return (1);
365	}
366
367	obj = ucl_parser_get_object(p);
368	if (obj->type != UCL_OBJECT)
369		warnx("Invalid configuration format, ignoring the "
370		    "configuration file %s", confpath);
371	else {
372		if (conftype == CONFFILE_PKG)
373			config_parse(obj, conftype);
374		else if (conftype == CONFFILE_REPO)
375			parse_repo_file(obj);
376	}
377
378	ucl_object_unref(obj);
379	ucl_parser_free(p);
380
381	return (0);
382}
383
384static int
385load_repositories(const char *repodir)
386{
387	struct dirent *ent;
388	DIR *d;
389	char *p;
390	size_t n;
391	char path[MAXPATHLEN];
392	int ret;
393
394	ret = 0;
395
396	if ((d = opendir(repodir)) == NULL)
397		return (1);
398
399	while ((ent = readdir(d))) {
400		/* Trim out 'repos'. */
401		if ((n = strlen(ent->d_name)) <= 5)
402			continue;
403		p = &ent->d_name[n - 5];
404		if (strcmp(p, ".conf") == 0) {
405			snprintf(path, sizeof(path), "%s%s%s",
406			    repodir,
407			    repodir[strlen(repodir) - 1] == '/' ? "" : "/",
408			    ent->d_name);
409			if (access(path, F_OK) == 0 &&
410			    read_conf_file(path, CONFFILE_REPO)) {
411				ret = 1;
412				goto cleanup;
413			}
414		}
415	}
416
417cleanup:
418	closedir(d);
419
420	return (ret);
421}
422
423int
424config_init(void)
425{
426	char *val;
427	int i;
428	const char *localbase;
429	char *env_list_item;
430	char confpath[MAXPATHLEN];
431	struct config_value *cv;
432	char abi[BUFSIZ];
433
434	for (i = 0; i < CONFIG_SIZE; i++) {
435		val = getenv(c[i].key);
436		if (val != NULL) {
437			c[i].envset = true;
438			switch (c[i].type) {
439			case PKG_CONFIG_LIST:
440				/* Split up comma-separated items from env. */
441				c[i].list = malloc(sizeof(*c[i].list));
442				STAILQ_INIT(c[i].list);
443				for (env_list_item = strtok(val, ",");
444				    env_list_item != NULL;
445				    env_list_item = strtok(NULL, ",")) {
446					cv =
447					    malloc(sizeof(struct config_value));
448					cv->value =
449					    strdup(env_list_item);
450					STAILQ_INSERT_TAIL(c[i].list, cv,
451					    next);
452				}
453				break;
454			default:
455				c[i].val = val;
456				break;
457			}
458		}
459	}
460
461	/* Read LOCALBASE/etc/pkg.conf first. */
462	localbase = getenv("LOCALBASE") ? getenv("LOCALBASE") : _LOCALBASE;
463	snprintf(confpath, sizeof(confpath), "%s/etc/pkg.conf",
464	    localbase);
465
466	if (access(confpath, F_OK) == 0 && read_conf_file(confpath,
467	    CONFFILE_PKG))
468		goto finalize;
469
470	/* Then read in all repos from REPOS_DIR list of directories. */
471	if (c[REPOS_DIR].list == NULL) {
472		c[REPOS_DIR].list = malloc(sizeof(*c[REPOS_DIR].list));
473		STAILQ_INIT(c[REPOS_DIR].list);
474		cv = malloc(sizeof(struct config_value));
475		cv->value = strdup("/etc/pkg");
476		STAILQ_INSERT_TAIL(c[REPOS_DIR].list, cv, next);
477		cv = malloc(sizeof(struct config_value));
478		if (asprintf(&cv->value, "%s/etc/pkg/repos", localbase) < 0)
479			goto finalize;
480		STAILQ_INSERT_TAIL(c[REPOS_DIR].list, cv, next);
481	}
482
483	STAILQ_FOREACH(cv, c[REPOS_DIR].list, next)
484		if (load_repositories(cv->value))
485			goto finalize;
486
487finalize:
488	if (c[ABI].val == NULL && c[ABI].value == NULL) {
489		if (pkg_get_myabi(abi, BUFSIZ) != 0)
490			errx(EXIT_FAILURE, "Failed to determine the system "
491			    "ABI");
492		c[ABI].val = abi;
493	}
494
495	subst_packagesite(c[ABI].value != NULL ? c[ABI].value : c[ABI].val);
496
497	return (0);
498}
499
500int
501config_string(pkg_config_key k, const char **val)
502{
503	if (c[k].type != PKG_CONFIG_STRING)
504		return (-1);
505
506	if (c[k].value != NULL)
507		*val = c[k].value;
508	else
509		*val = c[k].val;
510
511	return (0);
512}
513
514int
515config_bool(pkg_config_key k, bool *val)
516{
517	const char *value;
518
519	if (c[k].type != PKG_CONFIG_BOOL)
520		return (-1);
521
522	*val = false;
523
524	if (c[k].value != NULL)
525		value = c[k].value;
526	else
527		value = c[k].val;
528
529	if (boolstr_to_bool(value))
530		*val = true;
531
532	return (0);
533}
534
535void
536config_finish(void) {
537	int i;
538
539	for (i = 0; i < CONFIG_SIZE; i++)
540		free(c[i].value);
541}
542