config.c 26.8 KB
Newer Older
1
/*
Edward Thomson committed
2
 * Copyright (C) the libgit2 contributors. All rights reserved.
3
 *
Vicent Marti committed
4 5
 * This file is part of libgit2, distributed under the GNU GPL v2 with
 * a Linking Exception. For full terms see the included COPYING file.
6 7 8
 */

#include "common.h"
9
#include "sysdir.h"
10
#include "config.h"
11
#include "git2/config.h"
12
#include "git2/sys/config.h"
13
#include "vector.h"
14
#include "buf_text.h"
15
#include "config_file.h"
16 17 18
#if GIT_WIN32
# include <windows.h>
#endif
19 20 21

#include <ctype.h>

22
typedef struct {
23 24
	git_refcount rc;

Ben Straub committed
25
	git_config_backend *file;
26
	git_config_level_t level;
27
} file_internal;
28

29 30
static void file_internal_free(file_internal *internal)
{
Ben Straub committed
31
	git_config_backend *file;
32 33 34 35 36 37

	file = internal->file;
	file->free(file);
	git__free(internal);
}

38
static void config_free(git_config *cfg)
39
{
40
	size_t i;
41
	file_internal *internal;
42

43
	for (i = 0; i < cfg->files.length; ++i) {
44
		internal = git_vector_get(&cfg->files, i);
45
		GIT_REFCOUNT_DEC(internal, file_internal_free);
46
	}
47

48
	git_vector_free(&cfg->files);
49

50
	git__memzero(cfg, sizeof(*cfg));
51
	git__free(cfg);
52 53
}

54 55 56 57 58 59 60 61
void git_config_free(git_config *cfg)
{
	if (cfg == NULL)
		return;

	GIT_REFCOUNT_DEC(cfg, config_free);
}

62
static int config_backend_cmp(const void *a, const void *b)
63
{
64 65
	const file_internal *bk_a = (const file_internal *)(a);
	const file_internal *bk_b = (const file_internal *)(b);
66

67
	return bk_b->level - bk_a->level;
68 69
}

70
int git_config_new(git_config **out)
71 72 73 74
{
	git_config *cfg;

	cfg = git__malloc(sizeof(git_config));
75
	GITERR_CHECK_ALLOC(cfg);
76 77 78

	memset(cfg, 0x0, sizeof(git_config));

79
	if (git_vector_init(&cfg->files, 3, config_backend_cmp) < 0) {
80
		git__free(cfg);
Vicent Martí committed
81
		return -1;
82
	}
83

84
	*out = cfg;
85
	GIT_REFCOUNT_INC(cfg);
Vicent Martí committed
86
	return 0;
87
}
88

89 90 91
int git_config_add_file_ondisk(
	git_config *cfg,
	const char *path,
92
	git_config_level_t level,
93
	int force)
94
{
Ben Straub committed
95
	git_config_backend *file = NULL;
96
	struct stat st;
97
	int res;
98

99 100
	assert(cfg && path);

101 102 103 104
	res = p_stat(path, &st);
	if (res < 0 && errno != ENOENT) {
		giterr_set(GITERR_CONFIG, "Error stat'ing config file '%s'", path);
		return -1;
105 106
	}

Vicent Martí committed
107 108
	if (git_config_file__ondisk(&file, path) < 0)
		return -1;
109

Ben Straub committed
110
	if ((res = git_config_add_backend(cfg, file, level, force)) < 0) {
Vicent Marti committed
111 112 113 114 115
		/*
		 * free manually; the file is not owned by the config
		 * instance yet and will not be freed on cleanup
		 */
		file->free(file);
116
		return res;
117 118
	}

Vicent Martí committed
119
	return 0;
120 121
}

122
int git_config_open_ondisk(git_config **out, const char *path)
123
{
124 125
	int error;
	git_config *config;
126

127 128 129
	*out = NULL;

	if (git_config_new(&config) < 0)
Vicent Martí committed
130
		return -1;
131

132 133 134 135 136 137
	if ((error = git_config_add_file_ondisk(config, path, GIT_CONFIG_LEVEL_LOCAL, 0)) < 0)
		git_config_free(config);
	else
		*out = config;

	return error;
138 139
}

140 141
int git_config_snapshot(git_config **out, git_config *in)
{
142
	int error = 0;
143 144 145 146 147 148 149 150 151 152 153 154 155
	size_t i;
	file_internal *internal;
	git_config *config;

	*out = NULL;

	if (git_config_new(&config) < 0)
		return -1;

	git_vector_foreach(&in->files, i, internal) {
		git_config_backend *b;

		if ((error = internal->file->snapshot(&b, internal->file)) < 0)
156
			break;
157 158 159

		if ((error = git_config_add_backend(config, b, internal->level, 0)) < 0) {
			b->free(b);
160
			break;
161 162 163
		}
	}

164 165 166 167
	if (error < 0)
		git_config_free(config);
	else
		*out = config;
168 169 170 171

	return error;
}

172 173
static int find_internal_file_by_level(
	file_internal **internal_out,
Ben Straub committed
174
	const git_config *cfg,
175
	git_config_level_t level)
176 177 178
{
	int pos = -1;
	file_internal *internal;
179
	size_t i;
180 181 182 183 184 185 186 187 188 189

	/* when passing GIT_CONFIG_HIGHEST_LEVEL, the idea is to get the config file
	 * which has the highest level. As config files are stored in a vector
	 * sorted by decreasing order of level, getting the file at position 0
	 * will do the job.
	 */
	if (level == GIT_CONFIG_HIGHEST_LEVEL) {
		pos = 0;
	} else {
		git_vector_foreach(&cfg->files, i, internal) {
190
			if (internal->level == level)
Russell Belfer committed
191
				pos = (int)i;
192 193 194 195 196
		}
	}

	if (pos == -1) {
		giterr_set(GITERR_CONFIG,
197
			"No config file exists for the given level '%i'", (int)level);
198 199 200 201 202 203 204 205 206 207 208 209 210 211
		return GIT_ENOTFOUND;
	}

	*internal_out = git_vector_get(&cfg->files, pos);

	return 0;
}

static int duplicate_level(void **old_raw, void *new_raw)
{
	file_internal **old = (file_internal **)old_raw;

	GIT_UNUSED(new_raw);

212
	giterr_set(GITERR_CONFIG, "A file with the same level (%i) has already been added to the config", (int)(*old)->level);
213 214 215 216 217
	return GIT_EEXISTS;
}

static void try_remove_existing_file_internal(
	git_config *cfg,
218
	git_config_level_t level)
219 220 221
{
	int pos = -1;
	file_internal *internal;
222
	size_t i;
223 224 225

	git_vector_foreach(&cfg->files, i, internal) {
		if (internal->level == level)
Russell Belfer committed
226
			pos = (int)i;
227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242
	}

	if (pos == -1)
		return;

	internal = git_vector_get(&cfg->files, pos);

	if (git_vector_remove(&cfg->files, pos) < 0)
		return;

	GIT_REFCOUNT_DEC(internal, file_internal_free);
}

static int git_config__add_internal(
	git_config *cfg,
	file_internal *internal,
243
	git_config_level_t level,
244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263
	int force)
{
	int result;

	/* delete existing config file for level if it exists */
	if (force)
		try_remove_existing_file_internal(cfg, level);

	if ((result = git_vector_insert_sorted(&cfg->files,
			internal, &duplicate_level)) < 0)
		return result;

	git_vector_sort(&cfg->files);
	internal->file->cfg = cfg;

	GIT_REFCOUNT_INC(internal);

	return 0;
}

264 265 266 267 268 269 270 271
int git_config_open_global(git_config **cfg_out, git_config *cfg)
{
	if (!git_config_open_level(cfg_out, cfg, GIT_CONFIG_LEVEL_XDG))
		return 0;

	return git_config_open_level(cfg_out, cfg, GIT_CONFIG_LEVEL_GLOBAL);
}

272
int git_config_open_level(
Linquize committed
273 274
	git_config **cfg_out,
	const git_config *cfg_parent,
275
	git_config_level_t level)
276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296
{
	git_config *cfg;
	file_internal *internal;
	int res;

	if ((res = find_internal_file_by_level(&internal, cfg_parent, level)) < 0)
		return res;

	if ((res = git_config_new(&cfg)) < 0)
		return res;

	if ((res = git_config__add_internal(cfg, internal, level, true)) < 0) {
		git_config_free(cfg);
		return res;
	}

	*cfg_out = cfg;

	return 0;
}

Ben Straub committed
297
int git_config_add_backend(
298
	git_config *cfg,
Ben Straub committed
299
	git_config_backend *file,
300
	git_config_level_t level,
301
	int force)
302
{
303
	file_internal *internal;
Vicent Martí committed
304
	int result;
305

306
	assert(cfg && file);
307

Ben Straub committed
308
	GITERR_CHECK_VERSION(file, GIT_CONFIG_BACKEND_VERSION, "git_config_backend");
309

310
	if ((result = file->open(file, level)) < 0)
Vicent Martí committed
311
		return result;
312

313
	internal = git__malloc(sizeof(file_internal));
Vicent Martí committed
314
	GITERR_CHECK_ALLOC(internal);
315

316 317
	memset(internal, 0x0, sizeof(file_internal));

318
	internal->file = file;
319
	internal->level = level;
320

321
	if ((result = git_config__add_internal(cfg, internal, level, force)) < 0) {
322
		git__free(internal);
323
		return result;
324
	}
325

Vicent Martí committed
326
	return 0;
327 328
}

329 330 331
int git_config_refresh(git_config *cfg)
{
	int error = 0;
332
	size_t i;
333 334 335

	for (i = 0; i < cfg->files.length && !error; ++i) {
		file_internal *internal = git_vector_get(&cfg->files, i);
Ben Straub committed
336
		git_config_backend *file = internal->file;
337 338 339
		error = file->refresh(file);
	}

340 341 342
	if (!error && GIT_REFCOUNT_OWNER(cfg) != NULL)
		git_repository__cvar_cache_clear(GIT_REFCOUNT_OWNER(cfg));

343 344 345
	return error;
}

346 347 348 349
/*
 * Loop over all the variables
 */

350 351 352 353
typedef struct {
	git_config_iterator parent;
	git_config_iterator *current;
	const git_config *cfg;
354 355
	regex_t regex;
	int has_regex;
356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409
	size_t i;
} all_iter;

static int find_next_backend(size_t *out, const git_config *cfg, size_t i)
{
	file_internal *internal;

	for (; i > 0; --i) {
		internal = git_vector_get(&cfg->files, i - 1);
		if (!internal || !internal->file)
			continue;

		*out = i;
		return 0;
	}

	return -1;
}

static int all_iter_next(git_config_entry **entry, git_config_iterator *_iter)
{
	all_iter *iter = (all_iter *) _iter;
	file_internal *internal;
	git_config_backend *backend;
	size_t i;
	int error = 0;

	if (iter->current != NULL &&
	    (error = iter->current->next(entry, iter->current)) == 0) {
		return 0;
	}

	if (error < 0 && error != GIT_ITEROVER)
		return error;

	do {
		if (find_next_backend(&i, iter->cfg, iter->i) < 0)
			return GIT_ITEROVER;

		internal = git_vector_get(&iter->cfg->files, i - 1);
		backend = internal->file;
		iter->i = i - 1;

		if (iter->current)
			iter->current->free(iter->current);

		iter->current = NULL;
		error = backend->iterator(&iter->current, backend);
		if (error == GIT_ENOTFOUND)
			continue;

		if (error < 0)
			return error;

410 411 412 413 414 415
		error = iter->current->next(entry, iter->current);
		/* If this backend is empty, then keep going */
		if (error == GIT_ITEROVER)
			continue;

		return error;
416 417 418 419 420 421

	} while(1);

	return GIT_ITEROVER;
}

422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442
static int all_iter_glob_next(git_config_entry **entry, git_config_iterator *_iter)
{
	int error;
	all_iter *iter = (all_iter *) _iter;

	/*
	 * We use the "normal" function to grab the next one across
	 * backends and then apply the regex
	 */
	while ((error = all_iter_next(entry, _iter)) == 0) {
		/* skip non-matching keys if regexp was provided */
		if (regexec(&iter->regex, (*entry)->name, 0, NULL, 0) != 0)
			continue;

		/* and simply return if we like the entry's name */
		return 0;
	}

	return error;
}

443 444 445 446 447 448 449 450 451 452
static void all_iter_free(git_config_iterator *_iter)
{
	all_iter *iter = (all_iter *) _iter;

	if (iter->current)
		iter->current->free(iter->current);

	git__free(iter);
}

453 454 455 456 457 458 459 460
static void all_iter_glob_free(git_config_iterator *_iter)
{
	all_iter *iter = (all_iter *) _iter;

	regfree(&iter->regex);
	all_iter_free(_iter);
}

461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478
int git_config_iterator_new(git_config_iterator **out, const git_config *cfg)
{
	all_iter *iter;

	iter = git__calloc(1, sizeof(all_iter));
	GITERR_CHECK_ALLOC(iter);

	iter->parent.free = all_iter_free;
	iter->parent.next = all_iter_next;

	iter->i = cfg->files.length;
	iter->cfg = cfg;

	*out = (git_config_iterator *) iter;

	return 0;
}

479 480 481 482 483
int git_config_iterator_glob_new(git_config_iterator **out, const git_config *cfg, const char *regexp)
{
	all_iter *iter;
	int result;

484 485 486
	if (regexp == NULL)
		return git_config_iterator_new(out, cfg);

487 488 489
	iter = git__calloc(1, sizeof(all_iter));
	GITERR_CHECK_ALLOC(iter);

490 491 492
	if ((result = regcomp(&iter->regex, regexp, REG_EXTENDED)) < 0) {
		giterr_set_regex(&iter->regex, result);
		regfree(&iter->regex);
493
		git__free(iter);
494
		return -1;
495 496
	}

497 498
	iter->parent.next = all_iter_glob_next;
	iter->parent.free = all_iter_glob_free;
499 500 501 502 503 504 505 506
	iter->i = cfg->files.length;
	iter->cfg = cfg;

	*out = (git_config_iterator *) iter;

	return 0;
}

507
int git_config_foreach(
Ben Straub committed
508
	const git_config *cfg, git_config_foreach_cb cb, void *payload)
509
{
Ben Straub committed
510
	return git_config_foreach_match(cfg, NULL, cb, payload);
511 512
}

513 514 515
int git_config_backend_foreach_match(
	git_config_backend *backend,
	const char *regexp,
516 517
	git_config_foreach_cb cb,
	void *payload)
518
{
519
	git_config_entry *entry;
520
	git_config_iterator* iter;
521
	regex_t regex;
522
	int error = 0;
523 524

	if (regexp != NULL) {
525 526
		if ((error = regcomp(&regex, regexp, REG_EXTENDED)) < 0) {
			giterr_set_regex(&regex, error);
527 528 529 530 531
			regfree(&regex);
			return -1;
		}
	}

532
	if ((error = backend->iterator(&iter, backend)) < 0) {
533 534 535
		iter = NULL;
		return -1;
	}
536

537
	while (!(iter->next(&entry, iter) < 0)) {
538
		/* skip non-matching keys if regexp was provided */
539
		if (regexp && regexec(&regex, entry->name, 0, NULL, 0) != 0)
540 541 542
			continue;

		/* abort iterator on non-zero return value */
543
		if ((error = cb(entry, payload)) != 0) {
544
			giterr_set_after_callback(error);
545
			break;
546
		}
547 548 549 550 551
	}

	if (regexp != NULL)
		regfree(&regex);

552
	iter->free(iter);
553

554
	return error;
555 556
}

557
int git_config_foreach_match(
Ben Straub committed
558
	const git_config *cfg,
559
	const char *regexp,
Ben Straub committed
560 561
	git_config_foreach_cb cb,
	void *payload)
562
{
563 564 565
	int error;
	git_config_iterator *iter;
	git_config_entry *entry;
566

567 568 569
	if ((error = git_config_iterator_glob_new(&iter, cfg, regexp)) < 0)
		return error;

570 571
	while (!(error = git_config_next(&entry, iter))) {
		if ((error = cb(entry, payload)) != 0) {
572
			giterr_set_after_callback(error);
573 574 575
			break;
		}
	}
576

577 578 579 580 581 582
	git_config_iterator_free(iter);

	if (error == GIT_ITEROVER)
		error = 0;

	return error;
583 584
}

585
/**************
586
 * Setters
587
 **************/
588

589 590 591 592 593 594 595
static int config_error_nofiles(const char *name)
{
	giterr_set(GITERR_CONFIG,
		"Cannot set value for '%s' when no config files exist", name);
	return GIT_ENOTFOUND;
}

596 597 598 599 600 601 602 603 604 605 606 607 608
int git_config_delete_entry(git_config *cfg, const char *name)
{
	git_config_backend *file;
	file_internal *internal;

	internal = git_vector_get(&cfg->files, 0);
	if (!internal || !internal->file)
		return config_error_nofiles(name);
	file = internal->file;

	return file->del(file, name);
}

609
int git_config_set_int64(git_config *cfg, const char *name, int64_t value)
610
{
Vicent Marti committed
611
	char str_value[32]; /* All numbers should fit in here */
612
	p_snprintf(str_value, sizeof(str_value), "%" PRId64, value);
Vicent Marti committed
613
	return git_config_set_string(cfg, name, str_value);
614
}
615

616
int git_config_set_int32(git_config *cfg, const char *name, int32_t value)
617
{
618
	return git_config_set_int64(cfg, name, (int64_t)value);
619 620
}

621 622
int git_config_set_bool(git_config *cfg, const char *name, int value)
{
Vicent Marti committed
623
	return git_config_set_string(cfg, name, value ? "true" : "false");
624
}
625

626 627
int git_config_set_string(git_config *cfg, const char *name, const char *value)
{
628
	int error;
Ben Straub committed
629
	git_config_backend *file;
630
	file_internal *internal;
631

632 633 634 635 636
	if (!value) {
		giterr_set(GITERR_CONFIG, "The value to set cannot be NULL");
		return -1;
	}

637
	internal = git_vector_get(&cfg->files, 0);
638
	if (!internal || !internal->file)
639
		return config_error_nofiles(name);
640
	file = internal->file;
641

642 643 644 645 646 647
	error = file->set(file, name, value);

	if (!error && GIT_REFCOUNT_OWNER(cfg) != NULL)
		git_repository__cvar_cache_clear(GIT_REFCOUNT_OWNER(cfg));

	return error;
648 649
}

650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679
int git_config__update_entry(
	git_config *config,
	const char *key,
	const char *value,
	bool overwrite_existing,
	bool only_if_existing)
{
	int error = 0;
	const git_config_entry *ce = NULL;

	if ((error = git_config__lookup_entry(&ce, config, key, false)) < 0)
		return error;

	if (!ce && only_if_existing) /* entry doesn't exist */
		return 0;
	if (ce && !overwrite_existing) /* entry would be overwritten */
		return 0;
	if (value && ce && ce->value && !strcmp(ce->value, value)) /* no change */
		return 0;
	if (!value && (!ce || !ce->value)) /* asked to delete absent entry */
		return 0;

	if (!value)
		error = git_config_delete_entry(config, key);
	else
		error = git_config_set_string(config, key, value);

	return error;
}

680 681 682
/***********
 * Getters
 ***********/
683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716

static int config_error_notfound(const char *name)
{
	giterr_set(GITERR_CONFIG, "Config value '%s' was not found", name);
	return GIT_ENOTFOUND;
}

enum {
	GET_ALL_ERRORS = 0,
	GET_NO_MISSING = 1,
	GET_NO_ERRORS  = 2
};

static int get_entry(
	const git_config_entry **out,
	const git_config *cfg,
	const char *name,
	bool normalize_name,
	int want_errors)
{
	int res = GIT_ENOTFOUND;
	const char *key = name;
	char *normalized = NULL;
	size_t i;
	file_internal *internal;

	*out = NULL;

	if (normalize_name) {
		if ((res = git_config__normalize_name(name, &normalized)) < 0)
			goto cleanup;
		key = normalized;
	}

717
	res = GIT_ENOTFOUND;
718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755
	git_vector_foreach(&cfg->files, i, internal) {
		if (!internal || !internal->file)
			continue;

		res = internal->file->get(internal->file, key, out);
		if (res != GIT_ENOTFOUND)
			break;
	}

	git__free(normalized);

cleanup:
	if (res == GIT_ENOTFOUND)
		res = (want_errors > GET_ALL_ERRORS) ? 0 : config_error_notfound(name);
	else if (res && (want_errors == GET_NO_ERRORS)) {
		giterr_clear();
		res = 0;
	}

	return res;
}

int git_config_get_entry(
	const git_config_entry **out, const git_config *cfg, const char *name)
{
	return get_entry(out, cfg, name, true, GET_ALL_ERRORS);
}

int git_config__lookup_entry(
	const git_config_entry **out,
	const git_config *cfg,
	const char *key,
	bool no_errors)
{
	return get_entry(
		out, cfg, key, false, no_errors ? GET_NO_ERRORS : GET_NO_MISSING);
}

756 757
int git_config_get_mapped(
	int *out,
Ben Straub committed
758
	const git_config *cfg,
759
	const char *name,
Ben Straub committed
760
	const git_cvar_map *maps,
761
	size_t map_n)
762
{
763
	const git_config_entry *entry;
764
	int ret;
765

766
	if ((ret = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS)) < 0)
767
		return ret;
768

769
	return git_config_lookup_map_value(out, maps, map_n, entry->value);
770 771
}

Ben Straub committed
772
int git_config_get_int64(int64_t *out, const git_config *cfg, const char *name)
773
{
774
	const git_config_entry *entry;
775
	int ret;
776

777
	if ((ret = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS)) < 0)
Vicent Martí committed
778
		return ret;
779

780
	return git_config_parse_int64(out, entry->value);
781 782
}

Ben Straub committed
783
int git_config_get_int32(int32_t *out, const git_config *cfg, const char *name)
784
{
785
	const git_config_entry *entry;
Vicent Martí committed
786
	int ret;
787

788
	if ((ret = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS)) < 0)
Vicent Martí committed
789
		return ret;
790

791
	return git_config_parse_int32(out, entry->value);
792 793
}

794
int git_config_get_bool(int *out, const git_config *cfg, const char *name)
795 796
{
	const git_config_entry *entry;
797
	int ret;
798

799 800
	if ((ret = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS)) < 0)
		return ret;
801

802
	return git_config_parse_bool(out, entry->value);
803 804
}

805 806
int git_config_get_string(
	const char **out, const git_config *cfg, const char *name)
807
{
808 809 810 811
	const git_config_entry *entry;
	int ret = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS);
	*out = !ret ? (entry->value ? entry->value : "") : NULL;
	return ret;
812 813
}

814 815
const char *git_config__get_string_force(
	const git_config *cfg, const char *key, const char *fallback_value)
816
{
817 818 819
	const git_config_entry *entry;
	get_entry(&entry, cfg, key, false, GET_NO_ERRORS);
	return (entry && entry->value) ? entry->value : fallback_value;
820 821
}

822 823
int git_config__get_bool_force(
	const git_config *cfg, const char *key, int fallback_value)
824
{
825 826
	int val = fallback_value;
	const git_config_entry *entry;
827

828
	get_entry(&entry, cfg, key, false, GET_NO_ERRORS);
829

830 831
	if (entry && git_config_parse_bool(&val, entry->value) < 0)
		giterr_clear();
832

833
	return val;
834 835
}

836 837
int git_config__get_int_force(
	const git_config *cfg, const char *key, int fallback_value)
838
{
839 840
	int32_t val = (int32_t)fallback_value;
	const git_config_entry *entry;
Vicent Martí committed
841

842
	get_entry(&entry, cfg, key, false, GET_NO_ERRORS);
843

844 845
	if (entry && git_config_parse_int32(&val, entry->value) < 0)
		giterr_clear();
846

847
	return (int)val;
848 849
}

850
int git_config_get_multivar_foreach(
851 852
	const git_config *cfg, const char *name, const char *regexp,
	git_config_foreach_cb cb, void *payload)
853
{
854 855 856
	int err, found;
	git_config_iterator *iter;
	git_config_entry *entry;
857

858
	if ((err = git_config_multivar_iterator_new(&iter, cfg, name, regexp)) < 0)
859
		return err;
860

861 862 863
	found = 0;
	while ((err = iter->next(&entry, iter)) == 0) {
		found = 1;
864

865
		if ((err = cb(entry, payload)) != 0) {
866
			giterr_set_after_callback(err);
867
			break;
868
		}
869 870
	}

871
	iter->free(iter);
872 873 874 875 876 877 878
	if (err == GIT_ITEROVER)
		err = 0;

	if (found == 0 && err == 0)
		err = config_error_notfound(name);

	return err;
879 880
}

881
typedef struct {
882
	git_config_iterator parent;
883
	git_config_iterator *iter;
884
	char *name;
885 886
	regex_t regex;
	int have_regex;
887 888
} multivar_iter;

889
static int multivar_iter_next(git_config_entry **entry, git_config_iterator *_iter)
890 891
{
	multivar_iter *iter = (multivar_iter *) _iter;
892
	int error = 0;
893

894 895
	while ((error = iter->iter->next(entry, iter->iter)) == 0) {
		if (git__strcmp(iter->name, (*entry)->name))
896 897
			continue;

898 899
		if (!iter->have_regex)
			return 0;
900

901 902 903
		if (regexec(&iter->regex, (*entry)->value, 0, NULL, 0) == 0)
			return 0;
	}
904

905
	return error;
906
}
907

908 909 910 911
void multivar_iter_free(git_config_iterator *_iter)
{
	multivar_iter *iter = (multivar_iter *) _iter;

912
	iter->iter->free(iter->iter);
913

914
	git__free(iter->name);
915
	regfree(&iter->regex);
916 917 918
	git__free(iter);
}

919
int git_config_multivar_iterator_new(git_config_iterator **out, const git_config *cfg, const char *name, const char *regexp)
920
{
921 922 923 924 925 926
	multivar_iter *iter = NULL;
	git_config_iterator *inner = NULL;
	int error;

	if ((error = git_config_iterator_new(&inner, cfg)) < 0)
		return error;
927

928
	iter = git__calloc(1, sizeof(multivar_iter));
929 930
	GITERR_CHECK_ALLOC(iter);

931 932
	if ((error = git_config__normalize_name(name, &iter->name)) < 0)
		goto on_error;
933 934

	if (regexp != NULL) {
935 936 937 938 939 940 941 942 943
		error = regcomp(&iter->regex, regexp, REG_EXTENDED);
		if (error < 0) {
			giterr_set_regex(&iter->regex, error);
			error = -1;
			regfree(&iter->regex);
			goto on_error;
		}

		iter->have_regex = 1;
944 945
	}

946
	iter->iter = inner;
947
	iter->parent.free = multivar_iter_free;
948
	iter->parent.next = multivar_iter_next;
949

950 951 952
	*out = (git_config_iterator *) iter;

	return 0;
953 954 955 956 957 958

on_error:

	inner->free(inner);
	git__free(iter);
	return error;
959 960
}

961 962
int git_config_set_multivar(git_config *cfg, const char *name, const char *regexp, const char *value)
{
Ben Straub committed
963
	git_config_backend *file;
964
	file_internal *internal;
965

966
	internal = git_vector_get(&cfg->files, 0);
967
	if (!internal || !internal->file)
968
		return config_error_nofiles(name);
969
	file = internal->file;
970

971
	return file->set_multivar(file, name, regexp, value);
972 973
}

974 975 976 977 978 979 980 981 982 983 984 985 986
int git_config_delete_multivar(git_config *cfg, const char *name, const char *regexp)
{
	git_config_backend *file;
	file_internal *internal;

	internal = git_vector_get(&cfg->files, 0);
	if (!internal || !internal->file)
		return config_error_nofiles(name);
	file = internal->file;

	return file->del_multivar(file, name, regexp);
}

987 988 989 990 991 992 993
int git_config_next(git_config_entry **entry, git_config_iterator *iter)
{
	return iter->next(entry, iter);
}

void git_config_iterator_free(git_config_iterator *iter)
{
994 995 996
	if (iter == NULL)
		return;

997 998 999
	iter->free(iter);
}

1000
int git_config_find_global(git_buf *path)
1001
{
1002
	git_buf_sanitize(path);
1003
	return git_sysdir_find_global_file(path, GIT_CONFIG_FILENAME_GLOBAL);
1004 1005
}

1006
int git_config_find_xdg(git_buf *path)
1007
{
1008
	git_buf_sanitize(path);
1009
	return git_sysdir_find_xdg_file(path, GIT_CONFIG_FILENAME_XDG);
1010 1011
}

1012
int git_config_find_system(git_buf *path)
1013
{
1014
	git_buf_sanitize(path);
1015
	return git_sysdir_find_system_file(path, GIT_CONFIG_FILENAME_SYSTEM);
1016 1017
}

1018 1019 1020 1021 1022
int git_config__global_location(git_buf *buf)
{
	const git_buf *paths;
	const char *sep, *start;

1023
	if (git_sysdir_get(&paths, GIT_SYSDIR_GLOBAL) < 0)
1024 1025 1026
		return -1;

	/* no paths, so give up */
1027
	if (!paths || !git_buf_len(paths))
1028 1029
		return -1;

1030 1031 1032 1033 1034 1035
	/* find unescaped separator or end of string */
	for (sep = start = git_buf_cstr(paths); *sep; ++sep) {
		if (*sep == GIT_PATH_LIST_SEPARATOR &&
			(sep <= start || sep[-1] != '\\'))
			break;
	}
1036

1037
	if (git_buf_set(buf, start, (size_t)(sep - start)) < 0)
1038 1039 1040 1041 1042
		return -1;

	return git_buf_joinpath(buf, buf->ptr, GIT_CONFIG_FILENAME_GLOBAL);
}

1043
int git_config_open_default(git_config **out)
1044 1045 1046 1047 1048
{
	int error;
	git_config *cfg = NULL;
	git_buf buf = GIT_BUF_INIT;

1049 1050
	if ((error = git_config_new(&cfg)) < 0)
		return error;
1051

1052
	if (!git_config_find_global(&buf) || !git_config__global_location(&buf)) {
1053 1054
		error = git_config_add_file_ondisk(cfg, buf.ptr,
			GIT_CONFIG_LEVEL_GLOBAL, 0);
1055
	}
1056

1057
	if (!error && !git_config_find_xdg(&buf))
1058 1059
		error = git_config_add_file_ondisk(cfg, buf.ptr,
			GIT_CONFIG_LEVEL_XDG, 0);
1060

1061
	if (!error && !git_config_find_system(&buf))
1062 1063
		error = git_config_add_file_ondisk(cfg, buf.ptr,
			GIT_CONFIG_LEVEL_SYSTEM, 0);
1064 1065 1066

	git_buf_free(&buf);

1067
	if (error) {
1068 1069 1070 1071 1072 1073 1074 1075
		git_config_free(cfg);
		cfg = NULL;
	}

	*out = cfg;

	return error;
}
1076 1077 1078 1079

/***********
 * Parsers
 ***********/
1080

1081 1082
int git_config_lookup_map_value(
	int *out,
Ben Straub committed
1083
	const git_cvar_map *maps,
1084 1085 1086 1087 1088 1089 1090 1091 1092
	size_t map_n,
	const char *value)
{
	size_t i;

	if (!value)
		goto fail_parse;

	for (i = 0; i < map_n; ++i) {
Ben Straub committed
1093
		const git_cvar_map *m = maps + i;
1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 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

		switch (m->cvar_type) {
		case GIT_CVAR_FALSE:
		case GIT_CVAR_TRUE: {
			int bool_val;

			if (git__parse_bool(&bool_val, value) == 0 &&
				bool_val == (int)m->cvar_type) {
				*out = m->map_value;
				return 0;
			}
			break;
		}

		case GIT_CVAR_INT32:
			if (git_config_parse_int32(out, value) == 0)
				return 0;
			break;

		case GIT_CVAR_STRING:
			if (strcasecmp(value, m->str_match) == 0) {
				*out = m->map_value;
				return 0;
			}
			break;
		}
	}

fail_parse:
	giterr_set(GITERR_CONFIG, "Failed to map '%s'", value);
	return -1;
}

int git_config_parse_bool(int *out, const char *value)
{
	if (git__parse_bool(out, value) == 0)
		return 0;

	if (git_config_parse_int32(out, value) == 0) {
		*out = !!(*out);
		return 0;
	}

	giterr_set(GITERR_CONFIG, "Failed to parse '%s' as a boolean value", value);
	return -1;
}

int git_config_parse_int64(int64_t *out, const char *value)
{
	const char *num_end;
	int64_t num;

1146
	if (!value || git__strtol64(&num, value, &num_end, 0) < 0)
1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179
		goto fail_parse;

	switch (*num_end) {
	case 'g':
	case 'G':
		num *= 1024;
		/* fallthrough */

	case 'm':
	case 'M':
		num *= 1024;
		/* fallthrough */

	case 'k':
	case 'K':
		num *= 1024;

		/* check that that there are no more characters after the
		 * given modifier suffix */
		if (num_end[1] != '\0')
			return -1;

		/* fallthrough */

	case '\0':
		*out = num;
		return 0;

	default:
		goto fail_parse;
	}

fail_parse:
1180
	giterr_set(GITERR_CONFIG, "Failed to parse '%s' as an integer", value ? value : "(null)");
1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199
	return -1;
}

int git_config_parse_int32(int32_t *out, const char *value)
{
	int64_t tmp;
	int32_t truncate;

	if (git_config_parse_int64(&tmp, value) < 0)
		goto fail_parse;

	truncate = tmp & 0xFFFFFFFF;
	if (truncate != tmp)
		goto fail_parse;

	*out = truncate;
	return 0;

fail_parse:
1200
	giterr_set(GITERR_CONFIG, "Failed to parse '%s' as a 32-bit integer", value ? value : "(null)");
1201 1202
	return -1;
}
1203

1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238
/* Take something the user gave us and make it nice for our hash function */
int git_config__normalize_name(const char *in, char **out)
{
	char *name, *fdot, *ldot;

	assert(in && out);

	name = git__strdup(in);
	GITERR_CHECK_ALLOC(name);

	fdot = strchr(name, '.');
	ldot = strrchr(name, '.');

	if (fdot == NULL || fdot == name || ldot == NULL || !ldot[1])
		goto invalid;

	/* Validate and downcase up to first dot and after last dot */
	if (git_config_file_normalize_section(name, fdot) < 0 ||
		git_config_file_normalize_section(ldot + 1, NULL) < 0)
		goto invalid;

	/* If there is a middle range, make sure it doesn't have newlines */
	while (fdot < ldot)
		if (*fdot++ == '\n')
			goto invalid;

	*out = name;
	return 0;

invalid:
	git__free(name);
	giterr_set(GITERR_CONFIG, "Invalid config item name '%s'", in);
	return GIT_EINVALIDSPEC;
}

1239
struct rename_data {
1240
	git_config *config;
1241 1242
	git_buf *name;
	size_t old_len;
1243 1244 1245 1246 1247 1248
};

static int rename_config_entries_cb(
	const git_config_entry *entry,
	void *payload)
{
1249
	int error = 0;
1250
	struct rename_data *data = (struct rename_data *)payload;
1251
	size_t base_len = git_buf_len(data->name);
1252

1253 1254 1255
	if (base_len > 0 &&
		!(error = git_buf_puts(data->name, entry->name + data->old_len)))
	{
1256
		error = git_config_set_string(
1257
			data->config, git_buf_cstr(data->name), entry->value);
1258

1259
		git_buf_truncate(data->name, base_len);
1260 1261
	}

1262 1263 1264
	if (!error)
		error = git_config_delete_entry(data->config, entry->name);

1265
	return error;
1266 1267 1268 1269 1270 1271 1272 1273
}

int git_config_rename_section(
	git_repository *repo,
	const char *old_section_name,
	const char *new_section_name)
{
	git_config *config;
1274 1275
	git_buf pattern = GIT_BUF_INIT, replace = GIT_BUF_INIT;
	int error = 0;
1276 1277
	struct rename_data data;

1278 1279 1280 1281 1282 1283
	git_buf_text_puts_escape_regex(&pattern, old_section_name);

	if ((error = git_buf_puts(&pattern, "\\..+")) < 0)
		goto cleanup;

	if ((error = git_repository_config__weakptr(&config, repo)) < 0)
1284 1285
		goto cleanup;

1286 1287 1288 1289 1290
	data.config  = config;
	data.name    = &replace;
	data.old_len = strlen(old_section_name) + 1;

	if ((error = git_buf_join(&replace, '.', new_section_name, "")) < 0)
1291 1292
		goto cleanup;

1293 1294 1295 1296 1297 1298 1299
	if (new_section_name != NULL &&
		(error = git_config_file_normalize_section(
			replace.ptr, strchr(replace.ptr, '.'))) < 0)
	{
		giterr_set(
			GITERR_CONFIG, "Invalid config section '%s'", new_section_name);
		goto cleanup;
1300 1301
	}

1302 1303 1304
	error = git_config_foreach_match(
		config, git_buf_cstr(&pattern), rename_config_entries_cb, &data);

1305 1306
cleanup:
	git_buf_free(&pattern);
1307 1308
	git_buf_free(&replace);

1309 1310
	return error;
}
1311

1312
int git_config_init_backend(git_config_backend *backend, unsigned int version)
1313
{
1314 1315 1316
	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
		backend, version, git_config_backend, GIT_CONFIG_BACKEND_INIT);
	return 0;
1317
}