config.c 56.5 KB
Newer Older
1 2 3 4 5 6 7
/*
 * GIT - The information manager from hell
 *
 * Copyright (C) Linus Torvalds, 2005
 * Copyright (C) Johannes Schindelin, 2005
 *
 */
8
#include "cache.h"
9
#include "lockfile.h"
10
#include "exec_cmd.h"
11
#include "strbuf.h"
12
#include "quote.h"
13 14
#include "hashmap.h"
#include "string-list.h"
15
#include "utf8.h"
16

17 18 19 20
struct config_source {
	struct config_source *prev;
	union {
		FILE *file;
21 22 23 24 25
		struct config_buf {
			const char *buf;
			size_t len;
			size_t pos;
		} buf;
26
	} u;
27
	const char *name;
28
	const char *path;
29
	int die_on_error;
30 31 32
	int linenr;
	int eof;
	struct strbuf value;
33
	struct strbuf var;
34

35 36 37
	int (*do_fgetc)(struct config_source *c);
	int (*do_ungetc)(int c, struct config_source *conf);
	long (*do_ftell)(struct config_source *c);
38 39 40
};

static struct config_source *cf;
41

42 43
static int zlib_compression_seen;

44 45 46 47 48 49 50
/*
 * Default config_set that contains key-value pairs from the usual set of config
 * config files (i.e repo specific .git/config, user wide ~/.gitconfig, XDG
 * config file and the global /etc/gitconfig)
 */
static struct config_set the_config_set;

51 52
static int config_file_fgetc(struct config_source *conf)
{
53
	return getc_unlocked(conf->u.file);
54 55 56 57 58 59 60 61 62 63 64 65
}

static int config_file_ungetc(int c, struct config_source *conf)
{
	return ungetc(c, conf->u.file);
}

static long config_file_ftell(struct config_source *conf)
{
	return ftell(conf->u.file);
}

66 67 68 69 70 71 72 73 74 75 76

static int config_buf_fgetc(struct config_source *conf)
{
	if (conf->u.buf.pos < conf->u.buf.len)
		return conf->u.buf.buf[conf->u.buf.pos++];

	return EOF;
}

static int config_buf_ungetc(int c, struct config_source *conf)
{
77 78 79 80 81 82
	if (conf->u.buf.pos > 0) {
		conf->u.buf.pos--;
		if (conf->u.buf.buf[conf->u.buf.pos] != c)
			die("BUG: config_buf can only ungetc the same character");
		return c;
	}
83 84 85 86 87 88 89 90 91

	return EOF;
}

static long config_buf_ftell(struct config_source *conf)
{
	return conf->u.buf.pos;
}

92 93 94 95 96 97 98 99 100 101 102
#define MAX_INCLUDE_DEPTH 10
static const char include_depth_advice[] =
"exceeded maximum include depth (%d) while including\n"
"	%s\n"
"from\n"
"	%s\n"
"Do you have circular includes?";
static int handle_path_include(const char *path, struct config_include_data *inc)
{
	int ret = 0;
	struct strbuf buf = STRBUF_INIT;
103
	char *expanded;
104

105 106 107 108
	if (!path)
		return config_error_nonbool("include.path");

	expanded = expand_user_path(path);
109 110 111
	if (!expanded)
		return error("Could not expand include path '%s'", path);
	path = expanded;
112 113 114 115 116 117 118 119

	/*
	 * Use an absolute path as-is, but interpret relative paths
	 * based on the including config file.
	 */
	if (!is_absolute_path(path)) {
		char *slash;

120
		if (!cf || !cf->path)
121 122
			return error("relative config includes must come from files");

123
		slash = find_last_dir_sep(cf->path);
124
		if (slash)
125
			strbuf_add(&buf, cf->path, slash - cf->path + 1);
126 127 128 129
		strbuf_addstr(&buf, path);
		path = buf.buf;
	}

130
	if (!access_or_die(path, R_OK, 0)) {
131 132 133 134 135 136 137
		if (++inc->depth > MAX_INCLUDE_DEPTH)
			die(include_depth_advice, MAX_INCLUDE_DEPTH, path,
			    cf && cf->name ? cf->name : "the command line");
		ret = git_config_from_file(git_config_include, path, inc);
		inc->depth--;
	}
	strbuf_release(&buf);
138
	free(expanded);
139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154
	return ret;
}

int git_config_include(const char *var, const char *value, void *data)
{
	struct config_include_data *inc = data;
	int ret;

	/*
	 * Pass along all values, including "include" directives; this makes it
	 * possible to query information on the includes themselves.
	 */
	ret = inc->fn(var, value, inc->data);
	if (ret < 0)
		return ret;

155
	if (!strcmp(var, "include.path"))
156 157 158 159
		ret = handle_path_include(value, inc);
	return ret;
}

160 161 162 163 164 165 166 167 168 169 170 171 172
void git_config_push_parameter(const char *text)
{
	struct strbuf env = STRBUF_INIT;
	const char *old = getenv(CONFIG_DATA_ENVIRONMENT);
	if (old) {
		strbuf_addstr(&env, old);
		strbuf_addch(&env, ' ');
	}
	sq_quote_buf(&env, text);
	setenv(CONFIG_DATA_ENVIRONMENT, env.buf, 1);
	strbuf_release(&env);
}

173 174
int git_config_parse_parameter(const char *text,
			       config_fn_t fn, void *data)
175
{
176
	const char *value;
177
	struct strbuf **pair;
178

179
	pair = strbuf_split_str(text, '=', 2);
180 181
	if (!pair[0])
		return error("bogus config parameter: %s", text);
182 183

	if (pair[0]->len && pair[0]->buf[pair[0]->len - 1] == '=') {
184
		strbuf_setlen(pair[0], pair[0]->len - 1);
185 186 187 188 189
		value = pair[1] ? pair[1]->buf : "";
	} else {
		value = NULL;
	}

190 191 192
	strbuf_trim(pair[0]);
	if (!pair[0]->len) {
		strbuf_list_free(pair);
193
		return error("bogus config parameter: %s", text);
194
	}
195
	strbuf_tolower(pair[0]);
196
	if (fn(pair[0]->buf, value, data) < 0) {
197 198
		strbuf_list_free(pair);
		return -1;
199 200
	}
	strbuf_list_free(pair);
201 202 203
	return 0;
}

204 205
int git_config_from_parameters(config_fn_t fn, void *data)
{
206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222
	const char *env = getenv(CONFIG_DATA_ENVIRONMENT);
	char *envw;
	const char **argv = NULL;
	int nr = 0, alloc = 0;
	int i;

	if (!env)
		return 0;
	/* sq_dequote will write over it */
	envw = xstrdup(env);

	if (sq_dequote_to_argv(envw, &argv, &nr, &alloc) < 0) {
		free(envw);
		return error("bogus format in " CONFIG_DATA_ENVIRONMENT);
	}

	for (i = 0; i < nr; i++) {
223
		if (git_config_parse_parameter(argv[i], fn, data) < 0) {
224 225 226 227 228 229 230 231
			free(argv);
			free(envw);
			return -1;
		}
	}

	free(argv);
	free(envw);
232
	return nr > 0;
233 234
}

235 236
static int get_next_char(void)
{
237
	int c = cf->do_fgetc(cf);
238

239 240
	if (c == '\r') {
		/* DOS like systems */
241
		c = cf->do_fgetc(cf);
242
		if (c != '\n') {
Jeff King's avatar
Jeff King committed
243 244
			if (c != EOF)
				cf->do_ungetc(c, cf);
245
			c = '\r';
246 247
		}
	}
248 249 250 251
	if (c == '\n')
		cf->linenr++;
	if (c == EOF) {
		cf->eof = 1;
252
		cf->linenr++;
253 254
		c = '\n';
	}
255 256 257 258 259
	return c;
}

static char *parse_value(void)
{
260
	int quote = 0, comment = 0, space = 0;
261

262
	strbuf_reset(&cf->value);
263 264 265
	for (;;) {
		int c = get_next_char();
		if (c == '\n') {
266 267
			if (quote) {
				cf->linenr--;
268
				return NULL;
269
			}
270
			return cf->value.buf;
271 272 273 274
		}
		if (comment)
			continue;
		if (isspace(c) && !quote) {
275
			if (cf->value.len)
276
				space++;
277 278
			continue;
		}
279 280 281 282 283 284
		if (!quote) {
			if (c == ';' || c == '#') {
				comment = 1;
				continue;
			}
		}
285
		for (; space; space--)
286
			strbuf_addch(&cf->value, ' ');
287 288 289 290 291 292 293 294 295 296 297 298 299 300
		if (c == '\\') {
			c = get_next_char();
			switch (c) {
			case '\n':
				continue;
			case 't':
				c = '\t';
				break;
			case 'b':
				c = '\b';
				break;
			case 'n':
				c = '\n';
				break;
301 302 303 304 305 306
			/* Some characters escape as themselves */
			case '\\': case '"':
				break;
			/* Reject unknown escape sequences */
			default:
				return NULL;
307
			}
308
			strbuf_addch(&cf->value, c);
309 310 311 312 313 314
			continue;
		}
		if (c == '"') {
			quote = 1-quote;
			continue;
		}
315
		strbuf_addch(&cf->value, c);
316 317 318
	}
}

319 320 321 322 323
static inline int iskeychar(int c)
{
	return isalnum(c) || c == '-';
}

324
static int get_value(config_fn_t fn, void *data, struct strbuf *name)
325 326 327
{
	int c;
	char *value;
328
	int ret;
329 330 331 332

	/* Get the full name */
	for (;;) {
		c = get_next_char();
333
		if (cf->eof)
334
			break;
335
		if (!iskeychar(c))
336
			break;
337
		strbuf_addch(name, tolower(c));
338
	}
339

340 341 342 343 344 345 346 347 348 349 350
	while (c == ' ' || c == '\t')
		c = get_next_char();

	value = NULL;
	if (c != '\n') {
		if (c != '=')
			return -1;
		value = parse_value();
		if (!value)
			return -1;
	}
351 352 353 354 355 356 357 358 359
	/*
	 * We already consumed the \n, but we need linenr to point to
	 * the line we just parsed during the call to fn to get
	 * accurate line number in error messages.
	 */
	cf->linenr--;
	ret = fn(name->buf, value, data);
	cf->linenr++;
	return ret;
360 361
}

362
static int get_extended_base_var(struct strbuf *name, int c)
363 364 365
{
	do {
		if (c == '\n')
366
			goto error_incomplete_line;
367 368 369 370 371 372
		c = get_next_char();
	} while (isspace(c));

	/* We require the format to be '[base "extension"]' */
	if (c != '"')
		return -1;
373
	strbuf_addch(name, '.');
374 375 376 377

	for (;;) {
		int c = get_next_char();
		if (c == '\n')
378
			goto error_incomplete_line;
379 380 381 382 383
		if (c == '"')
			break;
		if (c == '\\') {
			c = get_next_char();
			if (c == '\n')
384
				goto error_incomplete_line;
385
		}
386
		strbuf_addch(name, c);
387 388 389 390 391
	}

	/* Final ']' */
	if (get_next_char() != ']')
		return -1;
392
	return 0;
393 394 395
error_incomplete_line:
	cf->linenr--;
	return -1;
396 397
}

398
static int get_base_var(struct strbuf *name)
399 400 401
{
	for (;;) {
		int c = get_next_char();
402
		if (cf->eof)
403 404
			return -1;
		if (c == ']')
405
			return 0;
406
		if (isspace(c))
407
			return get_extended_base_var(name, c);
408
		if (!iskeychar(c) && c != '.')
409
			return -1;
410
		strbuf_addch(name, tolower(c));
411 412 413
	}
}

414
static int git_parse_source(config_fn_t fn, void *data)
415 416 417
{
	int comment = 0;
	int baselen = 0;
418
	struct strbuf *var = &cf->var;
419

420
	/* U+FEFF Byte Order Mark in UTF8 */
421
	const char *bomptr = utf8_bom;
422

423 424
	for (;;) {
		int c = get_next_char();
425 426 427 428
		if (bomptr && *bomptr) {
			/* We are at the file beginning; skip UTF8-encoded BOM
			 * if present. Sane editors won't put this in on their
			 * own, but e.g. Windows Notepad will do it happily. */
429
			if (c == (*bomptr & 0377)) {
430 431 432 433 434 435 436 437 438 439
				bomptr++;
				continue;
			} else {
				/* Do not tolerate partial BOM. */
				if (bomptr != utf8_bom)
					break;
				/* No BOM at file beginning. Cool. */
				bomptr = NULL;
			}
		}
440
		if (c == '\n') {
441
			if (cf->eof)
442 443 444 445 446 447 448 449 450 451 452
				return 0;
			comment = 0;
			continue;
		}
		if (comment || isspace(c))
			continue;
		if (c == '#' || c == ';') {
			comment = 1;
			continue;
		}
		if (c == '[') {
453 454 455
			/* Reset prior to determining a new stem */
			strbuf_reset(var);
			if (get_base_var(var) < 0 || var->len < 1)
456
				break;
457 458
			strbuf_addch(var, '.');
			baselen = var->len;
459 460 461 462
			continue;
		}
		if (!isalpha(c))
			break;
463 464 465 466 467 468 469 470
		/*
		 * Truncate the var name back to the section header
		 * stem prior to grabbing the suffix part of the name
		 * and the value.
		 */
		strbuf_setlen(var, baselen);
		strbuf_addch(var, tolower(c));
		if (get_value(fn, data, var) < 0)
471 472
			break;
	}
473
	if (cf->die_on_error)
474
		die(_("bad config file line %d in %s"), cf->linenr, cf->name);
475
	else
476
		return error(_("bad config file line %d in %s"), cf->linenr, cf->name);
477 478
}

479
static int parse_unit_factor(const char *end, uintmax_t *val)
480 481 482
{
	if (!*end)
		return 1;
483 484 485 486 487 488 489 490 491 492 493 494 495
	else if (!strcasecmp(end, "k")) {
		*val *= 1024;
		return 1;
	}
	else if (!strcasecmp(end, "m")) {
		*val *= 1024 * 1024;
		return 1;
	}
	else if (!strcasecmp(end, "g")) {
		*val *= 1024 * 1024 * 1024;
		return 1;
	}
	return 0;
496 497
}

498
static int git_parse_signed(const char *value, intmax_t *ret, intmax_t max)
499 500 501
{
	if (value && *value) {
		char *end;
502 503 504 505 506 507 508 509
		intmax_t val;
		uintmax_t uval;
		uintmax_t factor = 1;

		errno = 0;
		val = strtoimax(value, &end, 0);
		if (errno == ERANGE)
			return 0;
510 511
		if (!parse_unit_factor(end, &factor)) {
			errno = EINVAL;
512
			return 0;
513
		}
514
		uval = labs(val);
515
		uval *= factor;
516
		if (uval > max || labs(val) > uval) {
517
			errno = ERANGE;
518
			return 0;
519
		}
520 521
		val *= factor;
		*ret = val;
522 523
		return 1;
	}
524
	errno = EINVAL;
525 526 527
	return 0;
}

528
static int git_parse_unsigned(const char *value, uintmax_t *ret, uintmax_t max)
529 530 531
{
	if (value && *value) {
		char *end;
532 533 534 535 536 537 538 539
		uintmax_t val;
		uintmax_t oldval;

		errno = 0;
		val = strtoumax(value, &end, 0);
		if (errno == ERANGE)
			return 0;
		oldval = val;
540 541
		if (!parse_unit_factor(end, &val)) {
			errno = EINVAL;
542
			return 0;
543 544 545
		}
		if (val > max || oldval > val) {
			errno = ERANGE;
546
			return 0;
547
		}
548
		*ret = val;
549
		return 1;
550
	}
551
	errno = EINVAL;
552 553 554
	return 0;
}

555
static int git_parse_int(const char *value, int *ret)
556
{
557
	intmax_t tmp;
558
	if (!git_parse_signed(value, &tmp, maximum_signed_value_of_type(int)))
559 560 561 562 563
		return 0;
	*ret = tmp;
	return 1;
}

564 565 566 567 568 569 570 571 572
static int git_parse_int64(const char *value, int64_t *ret)
{
	intmax_t tmp;
	if (!git_parse_signed(value, &tmp, maximum_signed_value_of_type(int64_t)))
		return 0;
	*ret = tmp;
	return 1;
}

573 574 575 576 577 578 579 580 581
int git_parse_ulong(const char *value, unsigned long *ret)
{
	uintmax_t tmp;
	if (!git_parse_unsigned(value, &tmp, maximum_unsigned_value_of_type(long)))
		return 0;
	*ret = tmp;
	return 1;
}

582
NORETURN
583
static void die_bad_number(const char *name, const char *value)
584
{
585 586 587 588 589 590
	const char *reason = errno == ERANGE ?
			     "out of range" :
			     "invalid unit";
	if (!value)
		value = "";

591
	if (cf && cf->name)
592
		die(_("bad numeric config value '%s' for '%s' in %s: %s"),
593
		    value, name, cf->name, reason);
594
	die(_("bad numeric config value '%s' for '%s': %s"), value, name, reason);
595 596
}

597 598
int git_config_int(const char *name, const char *value)
{
599 600
	int ret;
	if (!git_parse_int(value, &ret))
601
		die_bad_number(name, value);
602 603 604
	return ret;
}

605 606 607 608 609
int64_t git_config_int64(const char *name, const char *value)
{
	int64_t ret;
	if (!git_parse_int64(value, &ret))
		die_bad_number(name, value);
610 611 612 613 614 615 616
	return ret;
}

unsigned long git_config_ulong(const char *name, const char *value)
{
	unsigned long ret;
	if (!git_parse_ulong(value, &ret))
617
		die_bad_number(name, value);
618
	return ret;
619 620
}

621
int git_parse_maybe_bool(const char *value)
622 623 624 625 626
{
	if (!value)
		return 1;
	if (!*value)
		return 0;
Junio C Hamano's avatar
Junio C Hamano committed
627 628 629
	if (!strcasecmp(value, "true")
	    || !strcasecmp(value, "yes")
	    || !strcasecmp(value, "on"))
630
		return 1;
Junio C Hamano's avatar
Junio C Hamano committed
631 632 633
	if (!strcasecmp(value, "false")
	    || !strcasecmp(value, "no")
	    || !strcasecmp(value, "off"))
634
		return 0;
Junio C Hamano's avatar
Junio C Hamano committed
635 636 637
	return -1;
}

638 639
int git_config_maybe_bool(const char *name, const char *value)
{
640
	int v = git_parse_maybe_bool(value);
641 642
	if (0 <= v)
		return v;
643
	if (git_parse_int(value, &v))
644
		return !!v;
645 646 647
	return -1;
}

Junio C Hamano's avatar
Junio C Hamano committed
648 649
int git_config_bool_or_int(const char *name, const char *value, int *is_bool)
{
650
	int v = git_parse_maybe_bool(value);
Junio C Hamano's avatar
Junio C Hamano committed
651 652 653 654
	if (0 <= v) {
		*is_bool = 1;
		return v;
	}
655
	*is_bool = 0;
656
	return git_config_int(name, value);
657 658
}

659 660 661
int git_config_bool(const char *name, const char *value)
{
	int discard;
662
	return !!git_config_bool_or_int(name, value, &discard);
663 664
}

665 666 667 668 669 670 671 672
int git_config_string(const char **dest, const char *var, const char *value)
{
	if (!value)
		return config_error_nonbool(var);
	*dest = xstrdup(value);
	return 0;
}

673 674 675 676 677 678
int git_config_pathname(const char **dest, const char *var, const char *value)
{
	if (!value)
		return config_error_nonbool(var);
	*dest = expand_user_path(value);
	if (!*dest)
679
		die(_("failed to expand user dir in: '%s'"), value);
680 681 682
	return 0;
}

683
static int git_default_core_config(const char *var, const char *value)
684 685 686 687 688 689
{
	/* This needs a better name */
	if (!strcmp(var, "core.filemode")) {
		trust_executable_bit = git_config_bool(var, value);
		return 0;
	}
690 691 692 693
	if (!strcmp(var, "core.trustctime")) {
		trust_ctime = git_config_bool(var, value);
		return 0;
	}
694
	if (!strcmp(var, "core.checkstat")) {
695 696 697 698 699
		if (!strcasecmp(value, "default"))
			check_stat = 1;
		else if (!strcasecmp(value, "minimal"))
			check_stat = 0;
	}
700

701 702 703 704 705
	if (!strcmp(var, "core.quotepath")) {
		quote_path_fully = git_config_bool(var, value);
		return 0;
	}

706 707 708 709 710
	if (!strcmp(var, "core.symlinks")) {
		has_symlinks = git_config_bool(var, value);
		return 0;
	}

711 712 713 714 715
	if (!strcmp(var, "core.ignorecase")) {
		ignore_case = git_config_bool(var, value);
		return 0;
	}

716 717 718
	if (!strcmp(var, "core.attributesfile"))
		return git_config_pathname(&git_attributes_file, var, value);

719 720 721 722 723
	if (!strcmp(var, "core.bare")) {
		is_bare_repository_cfg = git_config_bool(var, value);
		return 0;
	}

Junio C Hamano's avatar
Junio C Hamano committed
724 725 726 727 728
	if (!strcmp(var, "core.ignorestat")) {
		assume_unchanged = git_config_bool(var, value);
		return 0;
	}

729 730
	if (!strcmp(var, "core.prefersymlinkrefs")) {
		prefer_symlink_refs = git_config_bool(var, value);
731 732 733
		return 0;
	}

734 735 736 737 738
	if (!strcmp(var, "core.logallrefupdates")) {
		log_all_ref_updates = git_config_bool(var, value);
		return 0;
	}

739 740 741 742 743
	if (!strcmp(var, "core.warnambiguousrefs")) {
		warn_ambiguous_refs = git_config_bool(var, value);
		return 0;
	}

744
	if (!strcmp(var, "core.abbrev")) {
745 746 747 748 749 750 751
		int abbrev = git_config_int(var, value);
		if (abbrev < minimum_abbrev || abbrev > 40)
			return -1;
		default_abbrev = abbrev;
		return 0;
	}

752
	if (!strcmp(var, "core.loosecompression")) {
753 754 755 756
		int level = git_config_int(var, value);
		if (level == -1)
			level = Z_DEFAULT_COMPRESSION;
		else if (level < 0 || level > Z_BEST_COMPRESSION)
757
			die(_("bad zlib compression level %d"), level);
758
		zlib_compression_level = level;
759 760 761 762 763 764 765 766 767
		zlib_compression_seen = 1;
		return 0;
	}

	if (!strcmp(var, "core.compression")) {
		int level = git_config_int(var, value);
		if (level == -1)
			level = Z_DEFAULT_COMPRESSION;
		else if (level < 0 || level > Z_BEST_COMPRESSION)
768
			die(_("bad zlib compression level %d"), level);
769 770 771 772
		core_compression_level = level;
		core_compression_seen = 1;
		if (!zlib_compression_seen)
			zlib_compression_level = level;
773 774 775
		return 0;
	}

776
	if (!strcmp(var, "core.packedgitwindowsize")) {
777
		int pgsz_x2 = getpagesize() * 2;
778
		packed_git_window_size = git_config_ulong(var, value);
779 780 781 782 783 784

		/* This value must be multiple of (pagesize * 2) */
		packed_git_window_size /= pgsz_x2;
		if (packed_git_window_size < 1)
			packed_git_window_size = 1;
		packed_git_window_size *= pgsz_x2;
785 786 787
		return 0;
	}

788
	if (!strcmp(var, "core.bigfilethreshold")) {
789
		big_file_threshold = git_config_ulong(var, value);
790 791 792
		return 0;
	}

793
	if (!strcmp(var, "core.packedgitlimit")) {
794
		packed_git_limit = git_config_ulong(var, value);
795 796 797
		return 0;
	}

798
	if (!strcmp(var, "core.deltabasecachelimit")) {
799
		delta_base_cache_limit = git_config_ulong(var, value);
800 801 802
		return 0;
	}

Linus Torvalds's avatar
Linus Torvalds committed
803
	if (!strcmp(var, "core.autocrlf")) {
804
		if (value && !strcasecmp(value, "input")) {
805
			if (core_eol == EOL_CRLF)
806
				return error("core.autocrlf=input conflicts with core.eol=crlf");
807
			auto_crlf = AUTO_CRLF_INPUT;
808 809
			return 0;
		}
Linus Torvalds's avatar
Linus Torvalds committed
810 811 812 813
		auto_crlf = git_config_bool(var, value);
		return 0;
	}

814 815 816 817 818 819 820 821 822
	if (!strcmp(var, "core.safecrlf")) {
		if (value && !strcasecmp(value, "warn")) {
			safe_crlf = SAFE_CRLF_WARN;
			return 0;
		}
		safe_crlf = git_config_bool(var, value);
		return 0;
	}

823 824
	if (!strcmp(var, "core.eol")) {
		if (value && !strcasecmp(value, "lf"))
825
			core_eol = EOL_LF;
826
		else if (value && !strcasecmp(value, "crlf"))
827
			core_eol = EOL_CRLF;
828
		else if (value && !strcasecmp(value, "native"))
829
			core_eol = EOL_NATIVE;
830
		else
831 832
			core_eol = EOL_UNSET;
		if (core_eol == EOL_CRLF && auto_crlf == AUTO_CRLF_INPUT)
833 834 835 836
			return error("core.autocrlf=input conflicts with core.eol=crlf");
		return 0;
	}

837 838 839 840 841
	if (!strcmp(var, "core.notesref")) {
		notes_ref_name = xstrdup(value);
		return 0;
	}

842 843 844 845 846 847
	if (!strcmp(var, "core.pager"))
		return git_config_string(&pager_program, var, value);

	if (!strcmp(var, "core.editor"))
		return git_config_string(&editor_program, var, value);

848
	if (!strcmp(var, "core.commentchar")) {
849 850
		if (!value)
			return config_error_nonbool(var);
851
		else if (!strcasecmp(value, "auto"))
852
			auto_comment_line_char = 1;
853
		else if (value[0] && !value[1]) {
854
			comment_line_char = value[0];
855
			auto_comment_line_char = 0;
856 857 858
		} else
			return error("core.commentChar should only be one character");
		return 0;
859 860
	}

861 862 863
	if (!strcmp(var, "core.askpass"))
		return git_config_string(&askpass_program, var, value);

864
	if (!strcmp(var, "core.excludesfile"))
865
		return git_config_pathname(&excludes_file, var, value);
866 867 868 869 870 871 872 873

	if (!strcmp(var, "core.whitespace")) {
		if (!value)
			return config_error_nonbool(var);
		whitespace_rule_cfg = parse_whitespace_rule(value);
		return 0;
	}

874 875 876 877 878
	if (!strcmp(var, "core.fsyncobjectfiles")) {
		fsync_object_files = git_config_bool(var, value);
		return 0;
	}

879 880 881 882 883
	if (!strcmp(var, "core.preloadindex")) {
		core_preload_index = git_config_bool(var, value);
		return 0;
	}

884 885 886 887 888 889
	if (!strcmp(var, "core.createobject")) {
		if (!strcmp(value, "rename"))
			object_creation_mode = OBJECT_CREATION_USES_RENAMES;
		else if (!strcmp(value, "link"))
			object_creation_mode = OBJECT_CREATION_USES_HARDLINKS;
		else
890
			die(_("invalid mode for object creation: %s"), value);
891 892 893
		return 0;
	}

894 895 896 897 898
	if (!strcmp(var, "core.sparsecheckout")) {
		core_apply_sparse_checkout = git_config_bool(var, value);
		return 0;
	}

899 900 901 902 903
	if (!strcmp(var, "core.precomposeunicode")) {
		precomposed_unicode = git_config_bool(var, value);
		return 0;
	}

904 905 906 907 908
	if (!strcmp(var, "core.protecthfs")) {
		protect_hfs = git_config_bool(var, value);
		return 0;
	}

909 910 911
	if (!strcmp(var, "core.protectntfs")) {
		protect_ntfs = git_config_bool(var, value);
		return 0;
912 913
	}

914 915 916 917
	/* Add other config variables here and to Documentation/config.txt. */
	return 0;
}

918
static int git_default_i18n_config(const char *var, const char *value)
919
{
920 921
	if (!strcmp(var, "i18n.commitencoding"))
		return git_config_string(&git_commit_encoding, var, value);
922

923 924
	if (!strcmp(var, "i18n.logoutputencoding"))
		return git_config_string(&git_log_output_encoding, var, value);
925

926 927 928
	/* Add other config variables here and to Documentation/config.txt. */
	return 0;
}
929

930 931
static int git_default_branch_config(const char *var, const char *value)
{
932 933 934 935 936 937 938 939
	if (!strcmp(var, "branch.autosetupmerge")) {
		if (value && !strcasecmp(value, "always")) {
			git_branch_track = BRANCH_TRACK_ALWAYS;
			return 0;
		}
		git_branch_track = git_config_bool(var, value);
		return 0;
	}
940 941 942 943 944 945 946 947 948 949 950 951 952 953 954
	if (!strcmp(var, "branch.autosetuprebase")) {
		if (!value)
			return config_error_nonbool(var);
		else if (!strcmp(value, "never"))
			autorebase = AUTOREBASE_NEVER;
		else if (!strcmp(value, "local"))
			autorebase = AUTOREBASE_LOCAL;
		else if (!strcmp(value, "remote"))
			autorebase = AUTOREBASE_REMOTE;
		else if (!strcmp(value, "always"))
			autorebase = AUTOREBASE_ALWAYS;
		else
			return error("Malformed value for %s", var);
		return 0;
	}
955

956
	/* Add other config variables here and to Documentation/config.txt. */
957 958 959
	return 0;
}

960 961 962 963 964 965 966 967 968
static int git_default_push_config(const char *var, const char *value)
{
	if (!strcmp(var, "push.default")) {
		if (!value)
			return config_error_nonbool(var);
		else if (!strcmp(value, "nothing"))
			push_default = PUSH_DEFAULT_NOTHING;
		else if (!strcmp(value, "matching"))
			push_default = PUSH_DEFAULT_MATCHING;
969 970
		else if (!strcmp(value, "simple"))
			push_default = PUSH_DEFAULT_SIMPLE;
971 972 973 974
		else if (!strcmp(value, "upstream"))
			push_default = PUSH_DEFAULT_UPSTREAM;
		else if (!strcmp(value, "tracking")) /* deprecated */
			push_default = PUSH_DEFAULT_UPSTREAM;
975 976 977 978
		else if (!strcmp(value, "current"))
			push_default = PUSH_DEFAULT_CURRENT;
		else {
			error("Malformed value for %s: %s", var, value);
979 980
			return error("Must be one of nothing, matching, simple, "
				     "upstream or current.");
981 982 983 984 985 986 987 988
		}
		return 0;
	}

	/* Add other config variables here and to Documentation/config.txt. */
	return 0;
}

989 990 991
static int git_default_mailmap_config(const char *var, const char *value)
{
	if (!strcmp(var, "mailmap.file"))
992
		return git_config_pathname(&git_mailmap_file, var, value);
993 994
	if (!strcmp(var, "mailmap.blob"))
		return git_config_string(&git_mailmap_blob, var, value);
995 996 997 998 999

	/* Add other config variables here and to Documentation/config.txt. */
	return 0;
}

1000 1001
int git_default_config(const char *var, const char *value, void *dummy)
{
1002
	if (starts_with(var, "core."))
1003 1004
		return git_default_core_config(var, value);

1005
	if (starts_with(var, "user."))
1006
		return git_ident_config(var, value, dummy);
1007

1008
	if (starts_with(var, "i18n."))
1009 1010
		return git_default_i18n_config(var, value);

1011
	if (starts_with(var, "branch."))
1012 1013
		return git_default_branch_config(var, value);

1014
	if (starts_with(var, "push."))
1015 1016
		return git_default_push_config(var, value);

1017
	if (starts_with(var, "mailmap."))
1018 1019
		return git_default_mailmap_config(var, value);

1020
	if (starts_with(var, "advice."))
1021 1022
		return git_default_advice_config(var, value);

1023 1024 1025 1026 1027
	if (!strcmp(var, "pager.color") || !strcmp(var, "color.pager")) {
		pager_use_color = git_config_bool(var,value);
		return 0;
	}

1028 1029 1030 1031
	if (!strcmp(var, "pack.packsizelimit")) {
		pack_size_limit_cfg = git_config_ulong(var, value);
		return 0;
	}
1032 1033 1034 1035
	/* Add other config variables here and to Documentation/config.txt. */
	return 0;
}

1036
/*
1037
 * All source specific fields in the union, die_on_error, name and the callbacks
1038
 * fgetc, ungetc, ftell of top need to be initialized before calling
1039 1040
 * this function.
 */
1041
static int do_config_from(struct config_source *top, config_fn_t fn, void *data)
1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052
{
	int ret;

	/* push config-file parsing state stack */
	top->prev = cf;
	top->linenr = 1;
	top->eof = 0;
	strbuf_init(&top->value, 1024);
	strbuf_init(&top->var, 1024);
	cf = top;

1053
	ret = git_parse_source(fn, data);
1054 1055 1056 1057 1058 1059 1060 1061 1062

	/* pop config-file parsing state stack */
	strbuf_release(&top->value);
	strbuf_release(&top->var);
	cf = top->prev;

	return ret;
}

1063 1064
static int do_config_from_file(config_fn_t fn,
		const char *name, const char *path, FILE *f, void *data)
1065
{
1066
	struct config_source top;
1067

1068 1069 1070 1071 1072 1073 1074
	top.u.file = f;
	top.name = name;
	top.path = path;
	top.die_on_error = 1;
	top.do_fgetc = config_file_fgetc;
	top.do_ungetc = config_file_ungetc;
	top.do_ftell = config_file_ftell;
1075

1076 1077
	return do_config_from(&top, fn, data);
}
1078

1079 1080 1081 1082 1083 1084 1085 1086 1087
static int git_config_from_stdin(config_fn_t fn, void *data)
{
	return do_config_from_file(fn, "<stdin>", NULL, stdin, data);
}

int git_config_from_file(config_fn_t fn, const char *filename, void *data)
{
	int ret = -1;
	FILE *f;
1088

1089 1090
	f = fopen(filename, "r");
	if (f) {
1091
		flockfile(f);
1092
		ret = do_config_from_file(fn, filename, filename, f, data);
1093
		funlockfile(f);
1094 1095 1096 1097
		fclose(f);
	}
	return ret;
}
1098

1099 1100 1101 1102 1103 1104 1105 1106 1107
int git_config_from_buf(config_fn_t fn, const char *name, const char *buf,
			size_t len, void *data)
{
	struct config_source top;

	top.u.buf.buf = buf;
	top.u.buf.len = len;
	top.u.buf.pos = 0;
	top.name = name;
1108
	top.path = NULL;
1109
	top.die_on_error = 0;
1110 1111 1112
	top.do_fgetc = config_buf_fgetc;
	top.do_ungetc = config_buf_ungetc;
	top.do_ftell = config_buf_ftell;
1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151

	return do_config_from(&top, fn, data);
}

static int git_config_from_blob_sha1(config_fn_t fn,
				     const char *name,
				     const unsigned char *sha1,
				     void *data)
{
	enum object_type type;
	char *buf;
	unsigned long size;
	int ret;

	buf = read_sha1_file(sha1, &type, &size);
	if (!buf)
		return error("unable to load config blob object '%s'", name);
	if (type != OBJ_BLOB) {
		free(buf);
		return error("reference '%s' does not point to a blob", name);
	}

	ret = git_config_from_buf(fn, name, buf, size, data);
	free(buf);

	return ret;
}

static int git_config_from_blob_ref(config_fn_t fn,
				    const char *name,
				    void *data)
{
	unsigned char sha1[20];

	if (get_sha1(name, sha1) < 0)
		return error("unable to resolve config blob '%s'", name);
	return git_config_from_blob_sha1(fn, name, sha1, data);
}

1152 1153
const char *git_etc_gitconfig(void)
{
1154
	static const char *system_wide;
1155 1156
	if (!system_wide)
		system_wide = system_path(ETC_GITCONFIG);
1157
	return system_wide;
1158 1159
}

1160 1161 1162 1163
/*
 * Parse environment variable 'k' as a boolean (in various
 * possible spellings); if missing, use the default value 'def'.
 */
1164
int git_env_bool(const char *k, int def)
1165 1166 1167 1168 1169
{
	const char *v = getenv(k);
	return v ? git_config_bool(k, v) : def;
}

1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181
/*
 * Parse environment variable 'k' as ulong with possibly a unit
 * suffix; if missing, use the default value 'val'.
 */
unsigned long git_env_ulong(const char *k, unsigned long val)
{
	const char *v = getenv(k);
	if (v && !git_parse_ulong(v, &val))
		die("failed to parse %s", k);
	return val;
}

1182 1183 1184 1185 1186
int git_config_system(void)
{
	return !git_env_bool("GIT_CONFIG_NOSYSTEM", 0);
}

Duy Nguyen's avatar
Duy Nguyen committed
1187
int git_config_early(config_fn_t fn, void *data, const char *repo_config)
1188
{
1189
	int ret = 0, found = 0;
1190 1191
	char *xdg_config = xdg_config_home("config");
	char *user_config = expand_user_path("~/.gitconfig");
1192

1193
	if (git_config_system() && !access_or_die(git_etc_gitconfig(), R_OK, 0)) {
1194 1195
		ret += git_config_from_file(fn, git_etc_gitconfig(),
					    data);
1196 1197
		found += 1;
	}
1198

1199
	if (xdg_config && !access_or_die(xdg_config, R_OK, ACCESS_EACCES_OK)) {
1200 1201 1202 1203
		ret += git_config_from_file(fn, xdg_config, data);
		found += 1;
	}

1204
	if (user_config && !access_or_die(user_config, R_OK, ACCESS_EACCES_OK)) {
1205 1206
		ret += git_config_from_file(fn, user_config, data);
		found += 1;
1207 1208
	}

1209
	if (repo_config && !access_or_die(repo_config, R_OK, 0)) {
1210 1211 1212
		ret += git_config_from_file(fn, repo_config, data);
		found += 1;
	}
1213

1214 1215
	switch (git_config_from_parameters(fn, data)) {
	case -1: /* error */
1216
		die(_("unable to parse command-line config"));
1217 1218 1219 1220 1221 1222 1223
		break;
	case 0: /* found nothing */
		break;
	default: /* found at least one item */
		found++;
		break;
	}
1224

1225 1226
	free(xdg_config);
	free(user_config);
1227
	return ret == 0 ? found : ret;
1228 1229
}

1230
int git_config_with_options(config_fn_t fn, void *data,
1231
			    struct git_config_source *config_source,
1232
			    int respect_includes)
Duy Nguyen's avatar
Duy Nguyen committed
1233 1234 1235
{
	char *repo_config = NULL;
	int ret;
1236 1237 1238 1239 1240 1241 1242 1243
	struct config_include_data inc = CONFIG_INCLUDE_INIT;

	if (respect_includes) {
		inc.fn = fn;
		inc.data = data;
		fn = git_config_include;
		data = &inc;
	}
Duy Nguyen's avatar
Duy Nguyen committed
1244

1245 1246 1247 1248
	/*
	 * If we have a specific filename, use it. Otherwise, follow the
	 * regular lookup sequence.
	 */
1249 1250 1251
	if (config_source && config_source->use_stdin)
		return git_config_from_stdin(fn, data);
	else if (config_source && config_source->file)
1252 1253 1254
		return git_config_from_file(fn, config_source->file, data);
	else if (config_source && config_source->blob)
		return git_config_from_blob_ref(fn, config_source->blob, data);
1255

Duy Nguyen's avatar
Duy Nguyen committed
1256 1257 1258 1259 1260 1261 1262
	repo_config = git_pathdup("config");
	ret = git_config_early(fn, data, repo_config);
	if (repo_config)
		free(repo_config);
	return ret;
}

1263
static void git_config_raw(config_fn_t fn, void *data)
1264
{
1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277
	if (git_config_with_options(fn, data, NULL, 1) < 0)
		/*
		 * git_config_with_options() normally returns only
		 * positive values, as most errors are fatal, and
		 * non-fatal potential errors are guarded by "if"
		 * statements that are entered only when no error is
		 * possible.
		 *
		 * If we ever encounter a non-fatal error, it means
		 * something went really wrong and we should stop
		 * immediately.
		 */
		die(_("unknown error occured while reading the configuration files"));
1278 1279
}

1280
static void configset_iter(struct config_set *cs, config_fn_t fn, void *data)
1281
{
1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304
	int i, value_index;
	struct string_list *values;
	struct config_set_element *entry;
	struct configset_list *list = &cs->list;
	struct key_value_info *kv_info;

	for (i = 0; i < list->nr; i++) {
		entry = list->items[i].e;
		value_index = list->items[i].value_index;
		values = &entry->value_list;
		if (fn(entry->key, values->items[value_index].string, data) < 0) {
			kv_info = values->items[value_index].util;
			git_die_config_linenr(entry->key, kv_info->filename, kv_info->linenr);
		}
	}
}

static void git_config_check_init(void);

void git_config(config_fn_t fn, void *data)
{
	git_config_check_init();
	configset_iter(&the_config_set, fn, data);
1305 1306
}

1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331
static struct config_set_element *configset_find_element(struct config_set *cs, const char *key)
{
	struct config_set_element k;
	struct config_set_element *found_entry;
	char *normalized_key;
	int ret;
	/*
	 * `key` may come from the user, so normalize it before using it
	 * for querying entries from the hashmap.
	 */
	ret = git_config_parse_key(key, &normalized_key, NULL);

	if (ret)
		return NULL;

	hashmap_entry_init(&k, strhash(normalized_key));
	k.key = normalized_key;
	found_entry = hashmap_get(&cs->config_hash, &k, NULL);
	free(normalized_key);
	return found_entry;
}

static int configset_add_value(struct config_set *cs, const char *key, const char *value)
{
	struct config_set_element *e;
1332
	struct string_list_item *si;
1333
	struct configset_list_item *l_item;
1334 1335
	struct key_value_info *kv_info = xmalloc(sizeof(*kv_info));

1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347
	e = configset_find_element(cs, key);
	/*
	 * Since the keys are being fed by git_config*() callback mechanism, they
	 * are already normalized. So simply add them without any further munging.
	 */
	if (!e) {
		e = xmalloc(sizeof(*e));
		hashmap_entry_init(e, strhash(key));
		e->key = xstrdup(key);
		string_list_init(&e->value_list, 1);
		hashmap_add(&cs->config_hash, e);
	}
1348
	si = string_list_append_nodup(&e->value_list, xstrdup_or_null(value));
1349 1350 1351 1352 1353 1354

	ALLOC_GROW(cs->list.items, cs->list.nr + 1, cs->list.alloc);
	l_item = &cs->list.items[cs->list.nr++];
	l_item->e = e;
	l_item->value_index = e->value_list.nr - 1;

1355 1356 1357 1358 1359 1360 1361 1362 1363
	if (cf) {
		kv_info->filename = strintern(cf->name);
		kv_info->linenr = cf->linenr;
	} else {
		/* for values read from `git_config_from_parameters()` */
		kv_info->filename = NULL;
		kv_info->linenr = -1;
	}
	si->util = kv_info;
1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377

	return 0;
}

static int config_set_element_cmp(const struct config_set_element *e1,
				 const struct config_set_element *e2, const void *unused)
{
	return strcmp(e1->key, e2->key);
}

void git_configset_init(struct config_set *cs)
{
	hashmap_init(&cs->config_hash, (hashmap_cmp_fn)config_set_element_cmp, 0);
	cs->hash_initialized = 1;
1378 1379 1380
	cs->list.nr = 0;
	cs->list.alloc = 0;
	cs->list.items = NULL;
1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392
}

void git_configset_clear(struct config_set *cs)
{
	struct config_set_element *entry;
	struct hashmap_iter iter;
	if (!cs->hash_initialized)
		return;

	hashmap_iter_init(&cs->config_hash, &iter);
	while ((entry = hashmap_iter_next(&iter))) {
		free(entry->key);
1393
		string_list_clear(&entry->value_list, 1);
1394 1395 1396
	}
	hashmap_free(&cs->config_hash, 1);
	cs->hash_initialized = 0;
1397 1398 1399 1400
	free(cs->list.items);
	cs->list.nr = 0;
	cs->list.alloc = 0;
	cs->list.items = NULL;
1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428