1 /* $OpenBSD: conf.c,v 1.107 2017/10/27 08:29:32 mpi Exp $	 */
2 /* $EOM: conf.c,v 1.48 2000/12/04 02:04:29 angelos Exp $	 */
3 
4 /*
5  * Copyright (c) 1998, 1999, 2000, 2001 Niklas Hallqvist.  All rights reserved.
6  * Copyright (c) 2000, 2001, 2002 Håkan Olsson.  All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28 
29 #include <sys/types.h>
30 #include <sys/queue.h>
31 #include <sys/stat.h>
32 
33 #include <ctype.h>
34 #include <fcntl.h>
35 #include <stdarg.h>
36 #include <stdio.h>
37 #include <stdlib.h>
38 #include <string.h>
39 #include <unistd.h>
40 #include <errno.h>
41 
42 #include "got_error.h"
43 
44 #include "got_lib_gitconfig.h"
45 
46 #ifndef nitems
47 #define nitems(_a) (sizeof(_a) / sizeof((_a)[0]))
48 #endif
49 
50 #define LOG_MISC	0
51 #define LOG_REPORT	1
52 #ifdef GITCONFIG_DEBUG
53 #define LOG_DBG(x) log_debug x
54 #else
55 #define LOG_DBG(x)
56 #endif
57 
58 #define log_print printf
59 #define log_error printf
60 
61 #ifdef GITCONFIG_DEBUG
62 static void
63 log_debug(int cls, int level, const char *fmt, ...)
64 {
65 	va_list         ap;
66 
67 	va_start(ap, fmt);
68 	vfprintf(stderr, fmt, ap);
69 	va_end(ap);
70 }
71 #endif
72 
73 struct got_gitconfig_trans {
74 	TAILQ_ENTRY(got_gitconfig_trans) link;
75 	int	 trans;
76 	enum got_gitconfig_op {
77 		CONF_SET, CONF_REMOVE, CONF_REMOVE_SECTION
78 	}	 op;
79 	char	*section;
80 	char	*tag;
81 	char	*value;
82 	int	 override;
83 	int	 is_default;
84 };
85 
86 TAILQ_HEAD(got_gitconfig_trans_head, got_gitconfig_trans);
87 
88 struct got_gitconfig_binding {
89 	LIST_ENTRY(got_gitconfig_binding) link;
90 	char	*section;
91 	char	*tag;
92 	char	*value;
93 	int	 is_default;
94 };
95 
96 LIST_HEAD(got_gitconfig_bindings, got_gitconfig_binding);
97 
98 struct got_gitconfig {
99 	struct got_gitconfig_bindings bindings[256];
100 	struct got_gitconfig_trans_head trans_queue;
101 	char	*addr;
102 	int	seq;
103 };
104 
105 static __inline__ u_int8_t
106 conf_hash(const char *s)
107 {
108 	u_int8_t hash = 0;
109 
110 	while (*s) {
111 		hash = ((hash << 1) | (hash >> 7)) ^ tolower((unsigned char)*s);
112 		s++;
113 	}
114 	return hash;
115 }
116 
117 /*
118  * Insert a tag-value combination from LINE (the equal sign is at POS)
119  */
120 static int
121 conf_remove_now(struct got_gitconfig *conf, char *section, char *tag)
122 {
123 	struct got_gitconfig_binding *cb, *next;
124 
125 	for (cb = LIST_FIRST(&conf->bindings[conf_hash(section)]); cb;
126 	    cb = next) {
127 		next = LIST_NEXT(cb, link);
128 		if (strcasecmp(cb->section, section) == 0 &&
129 		    strcasecmp(cb->tag, tag) == 0) {
130 			LIST_REMOVE(cb, link);
131 			LOG_DBG((LOG_MISC, 95, "[%s]:%s->%s removed", section,
132 			    tag, cb->value));
133 			free(cb->section);
134 			free(cb->tag);
135 			free(cb->value);
136 			free(cb);
137 			return 0;
138 		}
139 	}
140 	return 1;
141 }
142 
143 static int
144 conf_remove_section_now(struct got_gitconfig *conf, char *section)
145 {
146 	struct got_gitconfig_binding *cb, *next;
147 	int	unseen = 1;
148 
149 	for (cb = LIST_FIRST(&conf->bindings[conf_hash(section)]); cb;
150 	    cb = next) {
151 		next = LIST_NEXT(cb, link);
152 		if (strcasecmp(cb->section, section) == 0) {
153 			unseen = 0;
154 			LIST_REMOVE(cb, link);
155 			LOG_DBG((LOG_MISC, 95, "[%s]:%s->%s removed", section,
156 			    cb->tag, cb->value));
157 			free(cb->section);
158 			free(cb->tag);
159 			free(cb->value);
160 			free(cb);
161 		}
162 	}
163 	return unseen;
164 }
165 
166 /*
167  * Insert a tag-value combination from LINE (the equal sign is at POS)
168  * into SECTION of our configuration database.
169  */
170 static int
171 conf_set_now(struct got_gitconfig *conf, char *section, char *tag,
172     char *value, int override, int is_default)
173 {
174 	struct got_gitconfig_binding *node = 0;
175 
176 	if (override)
177 		conf_remove_now(conf, section, tag);
178 	else if (got_gitconfig_get_str(conf, section, tag)) {
179 		if (!is_default)
180 			LOG_DBG((LOG_MISC,
181 			    "conf_set_now: duplicate tag [%s]:%s, "
182 			    "ignoring...\n", section, tag));
183 		return 1;
184 	}
185 	node = calloc(1, sizeof *node);
186 	if (!node) {
187 		log_error("conf_set_now: calloc (1, %lu) failed",
188 		    (unsigned long)sizeof *node);
189 		return 1;
190 	}
191 	node->section = node->tag = node->value = NULL;
192 	if ((node->section = strdup(section)) == NULL)
193 		goto fail;
194 	if ((node->tag = strdup(tag)) == NULL)
195 		goto fail;
196 	if ((node->value = strdup(value)) == NULL)
197 		goto fail;
198 	node->is_default = is_default;
199 
200 	LIST_INSERT_HEAD(&conf->bindings[conf_hash(section)], node, link);
201 	LOG_DBG((LOG_MISC, 95, "conf_set_now: [%s]:%s->%s", node->section,
202 	    node->tag, node->value));
203 	return 0;
204 fail:
205 	free(node->value);
206 	free(node->tag);
207 	free(node->section);
208 	free(node);
209 	return 1;
210 }
211 
212 /*
213  * Parse the line LINE of SZ bytes.  Skip Comments, recognize section
214  * headers and feed tag-value pairs into our configuration database.
215  */
216 static const struct got_error *
217 conf_parse_line(char **section, struct got_gitconfig *conf, int trans,
218     char *line, int ln, size_t sz)
219 {
220 	char	*val;
221 	size_t	 i;
222 	int	 j;
223 
224 	/* Lines starting with '#' or ';' are comments.  */
225 	if (*line == '#' || *line == ';')
226 		return NULL;
227 
228 	/* '[section]' parsing...  */
229 	if (*line == '[') {
230 		for (i = 1; i < sz; i++)
231 			if (line[i] == ']')
232 				break;
233 		free(*section);
234 		if (i == sz) {
235 			log_print("conf_parse_line: %d:"
236 			    "unmatched ']', ignoring until next section", ln);
237 			*section = NULL;
238 			return NULL;
239 		}
240 		*section = strndup(line + 1, i - 1);
241 		if (*section == NULL)
242 			return got_error_from_errno("strndup");
243 		return NULL;
244 	}
245 	while (isspace((unsigned char)*line))
246 		line++;
247 
248 	/* Deal with assignments.  */
249 	for (i = 0; i < sz; i++)
250 		if (line[i] == '=') {
251 			/* If no section, we are ignoring the lines.  */
252 			if (!*section) {
253 				log_print("conf_parse_line: %d: ignoring line "
254 				    "due to no section", ln);
255 				return NULL;
256 			}
257 			line[strcspn(line, " \t=")] = '\0';
258 			val = line + i + 1 + strspn(line + i + 1, " \t");
259 			/* Skip trailing whitespace, if any */
260 			for (j = sz - (val - line) - 1; j > 0 &&
261 			    isspace((unsigned char)val[j]); j--)
262 				val[j] = '\0';
263 			/* XXX Perhaps should we not ignore errors?  */
264 			got_gitconfig_set(conf, trans, *section, line, val,
265 			    0, 0);
266 			return NULL;
267 		}
268 	/* Other non-empty lines are weird.  */
269 	i = strspn(line, " \t");
270 	if (line[i])
271 		log_print("conf_parse_line: %d: syntax error", ln);
272 
273 	return NULL;
274 }
275 
276 /* Parse the mapped configuration file.  */
277 static const struct got_error *
278 conf_parse(struct got_gitconfig *conf, int trans, char *buf, size_t sz)
279 {
280 	const struct got_error *err = NULL;
281 	char	*cp = buf;
282 	char	*bufend = buf + sz;
283 	char	*line, *section = NULL;
284 	int	ln = 1;
285 
286 	line = cp;
287 	while (cp < bufend) {
288 		if (*cp == '\n') {
289 			/* Check for escaped newlines.  */
290 			if (cp > buf && *(cp - 1) == '\\')
291 				*(cp - 1) = *cp = ' ';
292 			else {
293 				*cp = '\0';
294 				err = conf_parse_line(&section, conf, trans,
295 				    line, ln, cp - line);
296 				if (err)
297 					return err;
298 				line = cp + 1;
299 			}
300 			ln++;
301 		}
302 		cp++;
303 	}
304 	if (cp != line)
305 		log_print("conf_parse: last line unterminated, ignored.");
306 	return NULL;
307 }
308 
309 const struct got_error *
310 got_gitconfig_open(struct got_gitconfig **conf, int fd)
311 {
312 	size_t i;
313 
314 	*conf = calloc(1, sizeof(**conf));
315 	if (*conf == NULL)
316 		return got_error_from_errno("malloc");
317 
318 	for (i = 0; i < nitems((*conf)->bindings); i++)
319 		LIST_INIT(&(*conf)->bindings[i]);
320 	TAILQ_INIT(&(*conf)->trans_queue);
321 	return got_gitconfig_reinit(*conf, fd);
322 }
323 
324 static void
325 conf_clear(struct got_gitconfig *conf)
326 {
327 	struct got_gitconfig_binding *cb;
328 	size_t i;
329 
330 	if (conf->addr) {
331 		for (i = 0; i < nitems(conf->bindings); i++)
332 			for (cb = LIST_FIRST(&conf->bindings[i]); cb;
333 			    cb = LIST_FIRST(&conf->bindings[i]))
334 				conf_remove_now(conf, cb->section, cb->tag);
335 		free(conf->addr);
336 		conf->addr = NULL;
337 	}
338 }
339 
340 /* Execute all queued operations for this transaction.  Cleanup.  */
341 static int
342 conf_end(struct got_gitconfig *conf, int transaction, int commit)
343 {
344 	struct got_gitconfig_trans *node, *next;
345 
346 	for (node = TAILQ_FIRST(&conf->trans_queue); node; node = next) {
347 		next = TAILQ_NEXT(node, link);
348 		if (node->trans == transaction) {
349 			if (commit)
350 				switch (node->op) {
351 				case CONF_SET:
352 					conf_set_now(conf, node->section,
353 					    node->tag, node->value,
354 					    node->override, node->is_default);
355 					break;
356 				case CONF_REMOVE:
357 					conf_remove_now(conf, node->section,
358 					    node->tag);
359 					break;
360 				case CONF_REMOVE_SECTION:
361 					conf_remove_section_now(conf, node->section);
362 					break;
363 				default:
364 					log_print("got_gitconfig_end: unknown "
365 					    "operation: %d", node->op);
366 				}
367 			TAILQ_REMOVE(&conf->trans_queue, node, link);
368 			free(node->section);
369 			free(node->tag);
370 			free(node->value);
371 			free(node);
372 		}
373 	}
374 	return 0;
375 }
376 
377 
378 void
379 got_gitconfig_close(struct got_gitconfig *conf)
380 {
381 	conf_clear(conf);
382 	free(conf);
383 }
384 
385 static int
386 conf_begin(struct got_gitconfig *conf)
387 {
388 	return ++conf->seq;
389 }
390 
391 /* Open the config file and map it into our address space, then parse it.  */
392 const struct got_error *
393 got_gitconfig_reinit(struct got_gitconfig *conf, int fd)
394 {
395 	const struct got_error *err = NULL;
396 	int	 trans;
397 	size_t	 sz;
398 	char	*new_conf_addr = 0;
399 	struct stat st;
400 
401 	if (fstat(fd, &st)) {
402 		err = got_error_from_errno("fstat");
403 		goto fail;
404 	}
405 
406 	sz = st.st_size;
407 	new_conf_addr = malloc(sz);
408 	if (new_conf_addr == NULL) {
409 		err = got_error_from_errno("malloc");
410 		goto fail;
411 	}
412 	/* XXX I assume short reads won't happen here.  */
413 	if (read(fd, new_conf_addr, sz) != (int)sz) {
414 		err = got_error_from_errno("read");
415 		goto fail;
416 	}
417 
418 	trans = conf_begin(conf);
419 
420 	err = conf_parse(conf, trans, new_conf_addr, sz);
421 	if (err)
422 		goto fail;
423 
424 	/* Free potential existing configuration.  */
425 	conf_clear(conf);
426 	conf_end(conf, trans, 1);
427 	conf->addr = new_conf_addr;
428 	return NULL;
429 
430 fail:
431 	free(new_conf_addr);
432 	return err;
433 }
434 
435 /*
436  * Return the numeric value denoted by TAG in section SECTION or DEF
437  * if that tag does not exist.
438  */
439 int
440 got_gitconfig_get_num(struct got_gitconfig *conf, const char *section,
441     const char *tag, int def)
442 {
443 	char	*value = got_gitconfig_get_str(conf, section, tag);
444 
445 	if (value)
446 		return atoi(value);
447 	return def;
448 }
449 
450 /* Validate X according to the range denoted by TAG in section SECTION.  */
451 int
452 got_gitconfig_match_num(struct got_gitconfig *conf, char *section, char *tag,
453     int x)
454 {
455 	char	*value = got_gitconfig_get_str(conf, section, tag);
456 	int	 val, min, max, n;
457 
458 	if (!value)
459 		return 0;
460 	n = sscanf(value, "%d,%d:%d", &val, &min, &max);
461 	switch (n) {
462 	case 1:
463 		LOG_DBG((LOG_MISC, 95, "got_gitconfig_match_num: %s:%s %d==%d?",
464 		    section, tag, val, x));
465 		return x == val;
466 	case 3:
467 		LOG_DBG((LOG_MISC, 95, "got_gitconfig_match_num: %s:%s %d<=%d<=%d?",
468 		    section, tag, min, x, max));
469 		return min <= x && max >= x;
470 	default:
471 		log_error("got_gitconfig_match_num: section %s tag %s: invalid number "
472 		    "spec %s", section, tag, value);
473 	}
474 	return 0;
475 }
476 
477 /* Return the string value denoted by TAG in section SECTION.  */
478 char *
479 got_gitconfig_get_str(struct got_gitconfig *conf, const char *section,
480     const char *tag)
481 {
482 	struct got_gitconfig_binding *cb;
483 
484 	for (cb = LIST_FIRST(&conf->bindings[conf_hash(section)]); cb;
485 	    cb = LIST_NEXT(cb, link))
486 		if (strcasecmp(section, cb->section) == 0 &&
487 		    strcasecmp(tag, cb->tag) == 0) {
488 			LOG_DBG((LOG_MISC, 95, "got_gitconfig_get_str: [%s]:%s->%s",
489 			    section, tag, cb->value));
490 			return cb->value;
491 		}
492 	LOG_DBG((LOG_MISC, 95,
493 	    "got_gitconfig_get_str: configuration value not found [%s]:%s", section,
494 	    tag));
495 	return 0;
496 }
497 
498 const struct got_error *
499 got_gitconfig_get_section_list(struct got_gitconfig_list **sections,
500     struct got_gitconfig *conf)
501 {
502 	const struct got_error *err = NULL;
503 	struct got_gitconfig_list *list = NULL;
504 	struct got_gitconfig_list_node *node = 0;
505 	struct got_gitconfig_binding *cb;
506 	size_t i;
507 
508 	*sections = NULL;
509 
510 	list = malloc(sizeof *list);
511 	if (!list)
512 		return got_error_from_errno("malloc");
513 	TAILQ_INIT(&list->fields);
514 	list->cnt = 0;
515 	for (i = 0; i < nitems(conf->bindings); i++) {
516 		for (cb = LIST_FIRST(&conf->bindings[i]); cb;
517 		    cb = LIST_NEXT(cb, link)) {
518 			int section_present = 0;
519 			TAILQ_FOREACH(node, &list->fields, link) {
520 				if (strcmp(node->field, cb->section) == 0) {
521 					section_present = 1;
522 					break;
523 				}
524 			}
525 			if (section_present)
526 				continue;
527 			list->cnt++;
528 			node = calloc(1, sizeof *node);
529 			if (!node) {
530 				err = got_error_from_errno("calloc");
531 				goto cleanup;
532 			}
533 			node->field = strdup(cb->section);
534 			if (!node->field) {
535 				err = got_error_from_errno("strdup");
536 				goto cleanup;
537 			}
538 			TAILQ_INSERT_TAIL(&list->fields, node, link);
539 		}
540 	}
541 
542 	*sections = list;
543 	return NULL;
544 
545 cleanup:
546 	free(node);
547 	if (list)
548 		got_gitconfig_free_list(list);
549 	return err;
550 }
551 
552 /*
553  * Build a list of string values out of the comma separated value denoted by
554  * TAG in SECTION.
555  */
556 struct got_gitconfig_list *
557 got_gitconfig_get_list(struct got_gitconfig *conf, char *section, char *tag)
558 {
559 	char	*liststr = 0, *p, *field, *t;
560 	struct got_gitconfig_list *list = 0;
561 	struct got_gitconfig_list_node *node = 0;
562 
563 	list = malloc(sizeof *list);
564 	if (!list)
565 		goto cleanup;
566 	TAILQ_INIT(&list->fields);
567 	list->cnt = 0;
568 	liststr = got_gitconfig_get_str(conf, section, tag);
569 	if (!liststr)
570 		goto cleanup;
571 	liststr = strdup(liststr);
572 	if (!liststr)
573 		goto cleanup;
574 	p = liststr;
575 	while ((field = strsep(&p, ",")) != NULL) {
576 		/* Skip leading whitespace */
577 		while (isspace((unsigned char)*field))
578 			field++;
579 		/* Skip trailing whitespace */
580 		if (p)
581 			for (t = p - 1; t > field && isspace((unsigned char)*t); t--)
582 				*t = '\0';
583 		if (*field == '\0') {
584 			log_print("got_gitconfig_get_list: empty field, ignoring...");
585 			continue;
586 		}
587 		list->cnt++;
588 		node = calloc(1, sizeof *node);
589 		if (!node)
590 			goto cleanup;
591 		node->field = strdup(field);
592 		if (!node->field)
593 			goto cleanup;
594 		TAILQ_INSERT_TAIL(&list->fields, node, link);
595 	}
596 	free(liststr);
597 	return list;
598 
599 cleanup:
600 	free(node);
601 	if (list)
602 		got_gitconfig_free_list(list);
603 	free(liststr);
604 	return 0;
605 }
606 
607 struct got_gitconfig_list *
608 got_gitconfig_get_tag_list(struct got_gitconfig *conf, const char *section)
609 {
610 	struct got_gitconfig_list *list = 0;
611 	struct got_gitconfig_list_node *node = 0;
612 	struct got_gitconfig_binding *cb;
613 
614 	list = malloc(sizeof *list);
615 	if (!list)
616 		goto cleanup;
617 	TAILQ_INIT(&list->fields);
618 	list->cnt = 0;
619 	for (cb = LIST_FIRST(&conf->bindings[conf_hash(section)]); cb;
620 	    cb = LIST_NEXT(cb, link))
621 		if (strcasecmp(section, cb->section) == 0) {
622 			list->cnt++;
623 			node = calloc(1, sizeof *node);
624 			if (!node)
625 				goto cleanup;
626 			node->field = strdup(cb->tag);
627 			if (!node->field)
628 				goto cleanup;
629 			TAILQ_INSERT_TAIL(&list->fields, node, link);
630 		}
631 	return list;
632 
633 cleanup:
634 	free(node);
635 	if (list)
636 		got_gitconfig_free_list(list);
637 	return 0;
638 }
639 
640 void
641 got_gitconfig_free_list(struct got_gitconfig_list *list)
642 {
643 	struct got_gitconfig_list_node *node = TAILQ_FIRST(&list->fields);
644 
645 	while (node) {
646 		TAILQ_REMOVE(&list->fields, node, link);
647 		free(node->field);
648 		free(node);
649 		node = TAILQ_FIRST(&list->fields);
650 	}
651 	free(list);
652 }
653 
654 static int
655 got_gitconfig_trans_node(struct got_gitconfig *conf, int transaction,
656     enum got_gitconfig_op op, char *section, char *tag, char *value,
657     int override, int is_default)
658 {
659 	struct got_gitconfig_trans *node;
660 
661 	node = calloc(1, sizeof *node);
662 	if (!node) {
663 		log_error("got_gitconfig_trans_node: calloc (1, %lu) failed",
664 		    (unsigned long)sizeof *node);
665 		return 1;
666 	}
667 	node->trans = transaction;
668 	node->op = op;
669 	node->override = override;
670 	node->is_default = is_default;
671 	if (section && (node->section = strdup(section)) == NULL)
672 		goto fail;
673 	if (tag && (node->tag = strdup(tag)) == NULL)
674 		goto fail;
675 	if (value && (node->value = strdup(value)) == NULL)
676 		goto fail;
677 	TAILQ_INSERT_TAIL(&conf->trans_queue, node, link);
678 	return 0;
679 
680 fail:
681 	free(node->section);
682 	free(node->tag);
683 	free(node->value);
684 	free(node);
685 	return 1;
686 }
687 
688 /* Queue a set operation.  */
689 int
690 got_gitconfig_set(struct got_gitconfig *conf, int transaction, char *section,
691     char *tag, char *value, int override, int is_default)
692 {
693 	return got_gitconfig_trans_node(conf, transaction, CONF_SET, section,
694 	    tag, value, override, is_default);
695 }
696 
697 /* Queue a remove operation.  */
698 int
699 got_gitconfig_remove(struct got_gitconfig *conf, int transaction,
700     char *section, char *tag)
701 {
702 	return got_gitconfig_trans_node(conf, transaction, CONF_REMOVE,
703 	    section, tag, NULL, 0, 0);
704 }
705 
706 /* Queue a remove section operation.  */
707 int
708 got_gitconfig_remove_section(struct got_gitconfig *conf, int transaction,
709     char *section)
710 {
711 	return got_gitconfig_trans_node(conf, transaction, CONF_REMOVE_SECTION,
712 	    section, NULL, NULL, 0, 0);
713 }