config.c 28.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 23 24 25 26 27 28 29
void git_config_entry_free(git_config_entry *entry)
{
	if (!entry)
		return;

	entry->free(entry);
}

30
typedef struct {
31 32
	git_refcount rc;

Ben Straub committed
33
	git_config_backend *file;
34
	git_config_level_t level;
35
} file_internal;
36

37 38
static void file_internal_free(file_internal *internal)
{
Ben Straub committed
39
	git_config_backend *file;
40 41 42 43 44 45

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

46
static void config_free(git_config *cfg)
47
{
48
	size_t i;
49
	file_internal *internal;
50

51
	for (i = 0; i < cfg->files.length; ++i) {
52
		internal = git_vector_get(&cfg->files, i);
53
		GIT_REFCOUNT_DEC(internal, file_internal_free);
54
	}
55

56
	git_vector_free(&cfg->files);
57

58
	git__memzero(cfg, sizeof(*cfg));
59
	git__free(cfg);
60 61
}

62 63 64 65 66 67 68 69
void git_config_free(git_config *cfg)
{
	if (cfg == NULL)
		return;

	GIT_REFCOUNT_DEC(cfg, config_free);
}

70
static int config_backend_cmp(const void *a, const void *b)
71
{
72 73
	const file_internal *bk_a = (const file_internal *)(a);
	const file_internal *bk_b = (const file_internal *)(b);
74

75
	return bk_b->level - bk_a->level;
76 77
}

78
int git_config_new(git_config **out)
79 80 81 82
{
	git_config *cfg;

	cfg = git__malloc(sizeof(git_config));
83
	GITERR_CHECK_ALLOC(cfg);
84 85 86

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

87
	if (git_vector_init(&cfg->files, 3, config_backend_cmp) < 0) {
88
		git__free(cfg);
Vicent Martí committed
89
		return -1;
90
	}
91

92
	*out = cfg;
93
	GIT_REFCOUNT_INC(cfg);
Vicent Martí committed
94
	return 0;
95
}
96

97 98 99
int git_config_add_file_ondisk(
	git_config *cfg,
	const char *path,
100
	git_config_level_t level,
101
	int force)
102
{
Ben Straub committed
103
	git_config_backend *file = NULL;
104
	struct stat st;
105
	int res;
106

107 108
	assert(cfg && path);

109 110 111 112
	res = p_stat(path, &st);
	if (res < 0 && errno != ENOENT) {
		giterr_set(GITERR_CONFIG, "Error stat'ing config file '%s'", path);
		return -1;
113 114
	}

Vicent Martí committed
115 116
	if (git_config_file__ondisk(&file, path) < 0)
		return -1;
117

Ben Straub committed
118
	if ((res = git_config_add_backend(cfg, file, level, force)) < 0) {
Vicent Marti committed
119 120 121 122 123
		/*
		 * free manually; the file is not owned by the config
		 * instance yet and will not be freed on cleanup
		 */
		file->free(file);
124
		return res;
125 126
	}

Vicent Martí committed
127
	return 0;
128 129
}

130
int git_config_open_ondisk(git_config **out, const char *path)
131
{
132 133
	int error;
	git_config *config;
134

135 136 137
	*out = NULL;

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

140 141 142 143 144 145
	if ((error = git_config_add_file_ondisk(config, path, GIT_CONFIG_LEVEL_LOCAL, 0)) < 0)
		git_config_free(config);
	else
		*out = config;

	return error;
146 147
}

148 149
int git_config_snapshot(git_config **out, git_config *in)
{
150
	int error = 0;
151 152 153 154 155 156 157 158 159 160 161 162 163
	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)
164
			break;
165 166 167

		if ((error = git_config_add_backend(config, b, internal->level, 0)) < 0) {
			b->free(b);
168
			break;
169 170 171
		}
	}

172 173 174 175
	if (error < 0)
		git_config_free(config);
	else
		*out = config;
176 177 178 179

	return error;
}

180 181
static int find_internal_file_by_level(
	file_internal **internal_out,
Ben Straub committed
182
	const git_config *cfg,
183
	git_config_level_t level)
184 185 186
{
	int pos = -1;
	file_internal *internal;
187
	size_t i;
188 189 190 191 192 193 194 195 196 197

	/* 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) {
198
			if (internal->level == level)
Russell Belfer committed
199
				pos = (int)i;
200 201 202 203 204
		}
	}

	if (pos == -1) {
		giterr_set(GITERR_CONFIG,
205
			"No config file exists for the given level '%i'", (int)level);
206 207 208 209 210 211 212 213 214 215 216 217 218 219
		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);

220
	giterr_set(GITERR_CONFIG, "A file with the same level (%i) has already been added to the config", (int)(*old)->level);
221 222 223 224 225
	return GIT_EEXISTS;
}

static void try_remove_existing_file_internal(
	git_config *cfg,
226
	git_config_level_t level)
227 228 229
{
	int pos = -1;
	file_internal *internal;
230
	size_t i;
231 232 233

	git_vector_foreach(&cfg->files, i, internal) {
		if (internal->level == level)
Russell Belfer committed
234
			pos = (int)i;
235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250
	}

	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,
251
	git_config_level_t level,
252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271
	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;
}

272 273 274 275 276 277 278 279
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);
}

280
int git_config_open_level(
Linquize committed
281 282
	git_config **cfg_out,
	const git_config *cfg_parent,
283
	git_config_level_t level)
284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304
{
	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
305
int git_config_add_backend(
306
	git_config *cfg,
Ben Straub committed
307
	git_config_backend *file,
308
	git_config_level_t level,
309
	int force)
310
{
311
	file_internal *internal;
Vicent Martí committed
312
	int result;
313

314
	assert(cfg && file);
315

Ben Straub committed
316
	GITERR_CHECK_VERSION(file, GIT_CONFIG_BACKEND_VERSION, "git_config_backend");
317

318
	if ((result = file->open(file, level)) < 0)
Vicent Martí committed
319
		return result;
320

321
	internal = git__malloc(sizeof(file_internal));
Vicent Martí committed
322
	GITERR_CHECK_ALLOC(internal);
323

324 325
	memset(internal, 0x0, sizeof(file_internal));

326
	internal->file = file;
327
	internal->level = level;
328

329
	if ((result = git_config__add_internal(cfg, internal, level, force)) < 0) {
330
		git__free(internal);
331
		return result;
332
	}
333

Vicent Martí committed
334
	return 0;
335 336
}

337 338 339 340
/*
 * Loop over all the variables
 */

341 342 343 344
typedef struct {
	git_config_iterator parent;
	git_config_iterator *current;
	const git_config *cfg;
345
	regex_t regex;
346 347 348 349 350 351 352 353 354 355 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
	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;

400 401 402 403 404 405
		error = iter->current->next(entry, iter->current);
		/* If this backend is empty, then keep going */
		if (error == GIT_ITEROVER)
			continue;

		return error;
406 407 408 409 410 411

	} while(1);

	return GIT_ITEROVER;
}

412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432
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;
}

433 434 435 436 437 438 439 440 441 442
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);
}

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

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

451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468
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;
}

469 470 471 472 473
int git_config_iterator_glob_new(git_config_iterator **out, const git_config *cfg, const char *regexp)
{
	all_iter *iter;
	int result;

474 475 476
	if (regexp == NULL)
		return git_config_iterator_new(out, cfg);

477 478 479
	iter = git__calloc(1, sizeof(all_iter));
	GITERR_CHECK_ALLOC(iter);

480
	if ((result = regcomp(&iter->regex, regexp, REG_EXTENDED)) != 0) {
481
		giterr_set_regex(&iter->regex, result);
482
		git__free(iter);
483
		return -1;
484 485
	}

486 487
	iter->parent.next = all_iter_glob_next;
	iter->parent.free = all_iter_glob_free;
488 489 490 491 492 493 494 495
	iter->i = cfg->files.length;
	iter->cfg = cfg;

	*out = (git_config_iterator *) iter;

	return 0;
}

496
int git_config_foreach(
Ben Straub committed
497
	const git_config *cfg, git_config_foreach_cb cb, void *payload)
498
{
Ben Straub committed
499
	return git_config_foreach_match(cfg, NULL, cb, payload);
500 501
}

502 503 504
int git_config_backend_foreach_match(
	git_config_backend *backend,
	const char *regexp,
505 506
	git_config_foreach_cb cb,
	void *payload)
507
{
508
	git_config_entry *entry;
509
	git_config_iterator* iter;
510
	regex_t regex;
511
	int error = 0;
512 513

	if (regexp != NULL) {
514
		if ((error = regcomp(&regex, regexp, REG_EXTENDED)) != 0) {
515
			giterr_set_regex(&regex, error);
516 517 518 519 520
			regfree(&regex);
			return -1;
		}
	}

521
	if ((error = backend->iterator(&iter, backend)) < 0) {
522 523 524
		iter = NULL;
		return -1;
	}
525

526
	while (!(iter->next(&entry, iter) < 0)) {
527
		/* skip non-matching keys if regexp was provided */
528
		if (regexp && regexec(&regex, entry->name, 0, NULL, 0) != 0)
529 530 531
			continue;

		/* abort iterator on non-zero return value */
532
		if ((error = cb(entry, payload)) != 0) {
533
			giterr_set_after_callback(error);
534
			break;
535
		}
536 537 538 539 540
	}

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

541
	iter->free(iter);
542

543
	return error;
544 545
}

546
int git_config_foreach_match(
Ben Straub committed
547
	const git_config *cfg,
548
	const char *regexp,
Ben Straub committed
549 550
	git_config_foreach_cb cb,
	void *payload)
551
{
552 553 554
	int error;
	git_config_iterator *iter;
	git_config_entry *entry;
555

556 557 558
	if ((error = git_config_iterator_glob_new(&iter, cfg, regexp)) < 0)
		return error;

559 560
	while (!(error = git_config_next(&entry, iter))) {
		if ((error = cb(entry, payload)) != 0) {
561
			giterr_set_after_callback(error);
562 563 564
			break;
		}
	}
565

566 567 568 569 570 571
	git_config_iterator_free(iter);

	if (error == GIT_ITEROVER)
		error = 0;

	return error;
572 573
}

574
/**************
575
 * Setters
576
 **************/
577

578 579 580 581 582 583 584
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;
}

585 586 587 588 589 590 591 592 593 594 595 596 597
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);
}

598
int git_config_set_int64(git_config *cfg, const char *name, int64_t value)
599
{
Vicent Marti committed
600
	char str_value[32]; /* All numbers should fit in here */
601
	p_snprintf(str_value, sizeof(str_value), "%" PRId64, value);
Vicent Marti committed
602
	return git_config_set_string(cfg, name, str_value);
603
}
604

605
int git_config_set_int32(git_config *cfg, const char *name, int32_t value)
606
{
607
	return git_config_set_int64(cfg, name, (int64_t)value);
608 609
}

610 611
int git_config_set_bool(git_config *cfg, const char *name, int value)
{
Vicent Marti committed
612
	return git_config_set_string(cfg, name, value ? "true" : "false");
613
}
614

615 616
int git_config_set_string(git_config *cfg, const char *name, const char *value)
{
617
	int error;
Ben Straub committed
618
	git_config_backend *file;
619
	file_internal *internal;
620

621 622 623 624 625
	if (!value) {
		giterr_set(GITERR_CONFIG, "The value to set cannot be NULL");
		return -1;
	}

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

631 632 633 634 635 636
	error = file->set(file, name, value);

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

	return error;
637 638
}

639 640 641 642 643 644 645 646
int git_config__update_entry(
	git_config *config,
	const char *key,
	const char *value,
	bool overwrite_existing,
	bool only_if_existing)
{
	int error = 0;
647
	git_config_entry *ce = NULL;
648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665

	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);

666
	git_config_entry_free(ce);
667 668 669
	return error;
}

670 671 672
/***********
 * Getters
 ***********/
673 674 675 676 677 678 679 680 681 682 683 684 685 686

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(
687
	git_config_entry **out,
688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706
	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;
	}

707
	res = GIT_ENOTFOUND;
708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730
	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(
731
	git_config_entry **out, const git_config *cfg, const char *name)
732 733 734 735 736
{
	return get_entry(out, cfg, name, true, GET_ALL_ERRORS);
}

int git_config__lookup_entry(
737
	git_config_entry **out,
738 739 740 741 742 743 744 745
	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);
}

746 747
int git_config_get_mapped(
	int *out,
Ben Straub committed
748
	const git_config *cfg,
749
	const char *name,
Ben Straub committed
750
	const git_cvar_map *maps,
751
	size_t map_n)
752
{
753
	git_config_entry *entry;
754
	int ret;
755

756
	if ((ret = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS)) < 0)
757
		return ret;
758

759 760 761 762
	ret = git_config_lookup_map_value(out, maps, map_n, entry->value);
	git_config_entry_free(entry);

	return ret;
763 764
}

Ben Straub committed
765
int git_config_get_int64(int64_t *out, const git_config *cfg, const char *name)
766
{
767
	git_config_entry *entry;
768
	int ret;
769

770
	if ((ret = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS)) < 0)
Vicent Martí committed
771
		return ret;
772

773 774 775 776
	ret = git_config_parse_int64(out, entry->value);
	git_config_entry_free(entry);

	return ret;
777 778
}

Ben Straub committed
779
int git_config_get_int32(int32_t *out, const git_config *cfg, const char *name)
780
{
781
	git_config_entry *entry;
Vicent Martí committed
782
	int ret;
783

784
	if ((ret = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS)) < 0)
Vicent Martí committed
785
		return ret;
786

787 788 789 790
	ret = git_config_parse_int32(out, entry->value);
	git_config_entry_free(entry);

	return ret;
791 792
}

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

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

801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820
	ret = git_config_parse_bool(out, entry->value);
	git_config_entry_free(entry);

	return ret;
}

static int is_readonly(const git_config *cfg)
{
	size_t i;
	file_internal *internal;

	git_vector_foreach(&cfg->files, i, internal) {
		if (!internal || !internal->file)
			continue;

		if (!internal->file->readonly)
			return 0;
	}

	return 1;
821 822
}

823 824
int git_config_get_path(git_buf *out, const git_config *cfg, const char *name)
{
825
	git_config_entry *entry;
826 827 828 829 830
	int error;

	if ((error = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS)) < 0)
		return error;

831 832 833 834
	 error = git_config_parse_path(out, entry->value);
	 git_config_entry_free(entry);

	 return error;
835 836
}

837 838
int git_config_get_string(
	const char **out, const git_config *cfg, const char *name)
839
{
840 841 842 843 844 845 846 847 848
	git_config_entry *entry;
	int ret;

	if (!is_readonly(cfg)) {
		giterr_set(GITERR_CONFIG, "get_string called on a live config object");
		return -1;
	}

	ret = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS);
849
	*out = !ret ? (entry->value ? entry->value : "") : NULL;
850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872

	git_config_entry_free(entry);

	return ret;
}

int git_config_get_string_buf(
	git_buf *out, const git_config *cfg, const char *name)
{
	git_config_entry *entry;
	int ret;
	const char *str;

	git_buf_sanitize(out);

	ret  = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS);
	str = !ret ? (entry->value ? entry->value : "") : NULL;

	if (str)
		ret = git_buf_puts(out, str);

	git_config_entry_free(entry);

873
	return ret;
874 875
}

876
char *git_config__get_string_force(
877
	const git_config *cfg, const char *key, const char *fallback_value)
878
{
879 880 881
	git_config_entry *entry;
	char *ret;

882
	get_entry(&entry, cfg, key, false, GET_NO_ERRORS);
883 884 885 886
	ret = (entry && entry->value) ? git__strdup(entry->value) : fallback_value ? git__strdup(fallback_value) : NULL;
	git_config_entry_free(entry);

	return ret;
887 888
}

889 890
int git_config__get_bool_force(
	const git_config *cfg, const char *key, int fallback_value)
891
{
892
	int val = fallback_value;
893
	git_config_entry *entry;
894

895
	get_entry(&entry, cfg, key, false, GET_NO_ERRORS);
896

897 898
	if (entry && git_config_parse_bool(&val, entry->value) < 0)
		giterr_clear();
899

900
	git_config_entry_free(entry);
901
	return val;
902 903
}

904 905
int git_config__get_int_force(
	const git_config *cfg, const char *key, int fallback_value)
906
{
907
	int32_t val = (int32_t)fallback_value;
908
	git_config_entry *entry;
Vicent Martí committed
909

910
	get_entry(&entry, cfg, key, false, GET_NO_ERRORS);
911

912 913
	if (entry && git_config_parse_int32(&val, entry->value) < 0)
		giterr_clear();
914

915
	git_config_entry_free(entry);
916
	return (int)val;
917 918
}

919
int git_config_get_multivar_foreach(
920 921
	const git_config *cfg, const char *name, const char *regexp,
	git_config_foreach_cb cb, void *payload)
922
{
923 924 925
	int err, found;
	git_config_iterator *iter;
	git_config_entry *entry;
926

927
	if ((err = git_config_multivar_iterator_new(&iter, cfg, name, regexp)) < 0)
928
		return err;
929

930 931 932
	found = 0;
	while ((err = iter->next(&entry, iter)) == 0) {
		found = 1;
933

934
		if ((err = cb(entry, payload)) != 0) {
935
			giterr_set_after_callback(err);
936
			break;
937
		}
938 939
	}

940
	iter->free(iter);
941 942 943 944 945 946 947
	if (err == GIT_ITEROVER)
		err = 0;

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

	return err;
948 949
}

950
typedef struct {
951
	git_config_iterator parent;
952
	git_config_iterator *iter;
953
	char *name;
954 955
	regex_t regex;
	int have_regex;
956 957
} multivar_iter;

958
static int multivar_iter_next(git_config_entry **entry, git_config_iterator *_iter)
959 960
{
	multivar_iter *iter = (multivar_iter *) _iter;
961
	int error = 0;
962

963 964
	while ((error = iter->iter->next(entry, iter->iter)) == 0) {
		if (git__strcmp(iter->name, (*entry)->name))
965 966
			continue;

967 968
		if (!iter->have_regex)
			return 0;
969

970 971 972
		if (regexec(&iter->regex, (*entry)->value, 0, NULL, 0) == 0)
			return 0;
	}
973

974
	return error;
975
}
976

977 978 979 980
void multivar_iter_free(git_config_iterator *_iter)
{
	multivar_iter *iter = (multivar_iter *) _iter;

981
	iter->iter->free(iter->iter);
982

983
	git__free(iter->name);
984 985
	if (iter->have_regex)
		regfree(&iter->regex);
986 987 988
	git__free(iter);
}

989
int git_config_multivar_iterator_new(git_config_iterator **out, const git_config *cfg, const char *name, const char *regexp)
990
{
991 992 993 994 995 996
	multivar_iter *iter = NULL;
	git_config_iterator *inner = NULL;
	int error;

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

998
	iter = git__calloc(1, sizeof(multivar_iter));
999 1000
	GITERR_CHECK_ALLOC(iter);

1001 1002
	if ((error = git_config__normalize_name(name, &iter->name)) < 0)
		goto on_error;
1003 1004

	if (regexp != NULL) {
1005
		error = regcomp(&iter->regex, regexp, REG_EXTENDED);
1006
		if (error != 0) {
1007 1008 1009 1010 1011 1012 1013
			giterr_set_regex(&iter->regex, error);
			error = -1;
			regfree(&iter->regex);
			goto on_error;
		}

		iter->have_regex = 1;
1014 1015
	}

1016
	iter->iter = inner;
1017
	iter->parent.free = multivar_iter_free;
1018
	iter->parent.next = multivar_iter_next;
1019

1020 1021 1022
	*out = (git_config_iterator *) iter;

	return 0;
1023 1024 1025 1026 1027 1028

on_error:

	inner->free(inner);
	git__free(iter);
	return error;
1029 1030
}

1031 1032
int git_config_set_multivar(git_config *cfg, const char *name, const char *regexp, const char *value)
{
Ben Straub committed
1033
	git_config_backend *file;
1034
	file_internal *internal;
1035

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

1041
	return file->set_multivar(file, name, regexp, value);
1042 1043
}

1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056
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);
}

1057 1058 1059 1060 1061 1062 1063
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)
{
1064 1065 1066
	if (iter == NULL)
		return;

1067 1068 1069
	iter->free(iter);
}

1070
int git_config_find_global(git_buf *path)
1071
{
1072
	git_buf_sanitize(path);
1073
	return git_sysdir_find_global_file(path, GIT_CONFIG_FILENAME_GLOBAL);
1074 1075
}

1076
int git_config_find_xdg(git_buf *path)
1077
{
1078
	git_buf_sanitize(path);
1079
	return git_sysdir_find_xdg_file(path, GIT_CONFIG_FILENAME_XDG);
1080 1081
}

1082
int git_config_find_system(git_buf *path)
1083
{
1084
	git_buf_sanitize(path);
1085
	return git_sysdir_find_system_file(path, GIT_CONFIG_FILENAME_SYSTEM);
1086 1087
}

1088 1089 1090 1091 1092
int git_config__global_location(git_buf *buf)
{
	const git_buf *paths;
	const char *sep, *start;

1093
	if (git_sysdir_get(&paths, GIT_SYSDIR_GLOBAL) < 0)
1094 1095 1096
		return -1;

	/* no paths, so give up */
1097
	if (!paths || !git_buf_len(paths))
1098 1099
		return -1;

1100 1101 1102 1103 1104 1105
	/* 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;
	}
1106

1107
	if (git_buf_set(buf, start, (size_t)(sep - start)) < 0)
1108 1109 1110 1111 1112
		return -1;

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

1113
int git_config_open_default(git_config **out)
1114 1115 1116 1117 1118
{
	int error;
	git_config *cfg = NULL;
	git_buf buf = GIT_BUF_INIT;

1119 1120
	if ((error = git_config_new(&cfg)) < 0)
		return error;
1121

1122
	if (!git_config_find_global(&buf) || !git_config__global_location(&buf)) {
1123 1124
		error = git_config_add_file_ondisk(cfg, buf.ptr,
			GIT_CONFIG_LEVEL_GLOBAL, 0);
1125
	}
1126

1127
	if (!error && !git_config_find_xdg(&buf))
1128 1129
		error = git_config_add_file_ondisk(cfg, buf.ptr,
			GIT_CONFIG_LEVEL_XDG, 0);
1130

1131
	if (!error && !git_config_find_system(&buf))
1132 1133
		error = git_config_add_file_ondisk(cfg, buf.ptr,
			GIT_CONFIG_LEVEL_SYSTEM, 0);
1134 1135 1136

	git_buf_free(&buf);

1137
	if (error) {
1138 1139 1140 1141 1142 1143 1144 1145
		git_config_free(cfg);
		cfg = NULL;
	}

	*out = cfg;

	return error;
}
1146 1147 1148 1149

/***********
 * Parsers
 ***********/
1150

1151 1152
int git_config_lookup_map_value(
	int *out,
Ben Straub committed
1153
	const git_cvar_map *maps,
1154 1155 1156 1157 1158 1159 1160 1161 1162
	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
1163
		const git_cvar_map *m = maps + i;
1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196

		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;
}

1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216
int git_config_lookup_map_enum(git_cvar_t *type_out, const char **str_out,
			       const git_cvar_map *maps, size_t map_n, int enum_val)
{
	size_t i;

	for (i = 0; i < map_n; i++) {
		const git_cvar_map *m = &maps[i];

		if (m->map_value != enum_val)
			continue;

		*type_out = m->cvar_type;
		*str_out = m->str_match;
		return 0;
	}

	giterr_set(GITERR_CONFIG, "invalid enum value");
	return GIT_ENOTFOUND;
}

1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235
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;

1236
	if (!value || git__strtol64(&num, value, &num_end, 0) < 0)
1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269
		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:
1270
	giterr_set(GITERR_CONFIG, "Failed to parse '%s' as an integer", value ? value : "(null)");
1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289
	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:
1290
	giterr_set(GITERR_CONFIG, "Failed to parse '%s' as a 32-bit integer", value ? value : "(null)");
1291 1292
	return -1;
}
1293

1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323
int git_config_parse_path(git_buf *out, const char *value)
{
	int error = 0;
	const git_buf *home;

	assert(out && value);

	git_buf_sanitize(out);

	if (value[0] == '~') {
		if (value[1] != '\0' && value[1] != '/') {
			giterr_set(GITERR_CONFIG, "retrieving a homedir by name is not supported");
			return -1;
		}

		if ((error = git_sysdir_get(&home, GIT_SYSDIR_GLOBAL)) < 0)
			return error;

		git_buf_sets(out, home->ptr);
		git_buf_puts(out, value + 1);

		if (git_buf_oom(out))
			return -1;

		return 0;
	}

	return git_buf_sets(out, value);
}

1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358
/* 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;
}

1359
struct rename_data {
1360
	git_config *config;
1361 1362
	git_buf *name;
	size_t old_len;
1363 1364 1365 1366 1367 1368
};

static int rename_config_entries_cb(
	const git_config_entry *entry,
	void *payload)
{
1369
	int error = 0;
1370
	struct rename_data *data = (struct rename_data *)payload;
1371
	size_t base_len = git_buf_len(data->name);
1372

1373 1374 1375
	if (base_len > 0 &&
		!(error = git_buf_puts(data->name, entry->name + data->old_len)))
	{
1376
		error = git_config_set_string(
1377
			data->config, git_buf_cstr(data->name), entry->value);
1378

1379
		git_buf_truncate(data->name, base_len);
1380 1381
	}

1382 1383 1384
	if (!error)
		error = git_config_delete_entry(data->config, entry->name);

1385
	return error;
1386 1387 1388 1389 1390 1391 1392 1393
}

int git_config_rename_section(
	git_repository *repo,
	const char *old_section_name,
	const char *new_section_name)
{
	git_config *config;
1394 1395
	git_buf pattern = GIT_BUF_INIT, replace = GIT_BUF_INIT;
	int error = 0;
1396 1397
	struct rename_data data;

1398 1399 1400 1401 1402 1403
	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)
1404 1405
		goto cleanup;

1406 1407 1408 1409 1410
	data.config  = config;
	data.name    = &replace;
	data.old_len = strlen(old_section_name) + 1;

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

1413 1414 1415 1416 1417 1418 1419
	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;
1420 1421
	}

1422 1423 1424
	error = git_config_foreach_match(
		config, git_buf_cstr(&pattern), rename_config_entries_cb, &data);

1425 1426
cleanup:
	git_buf_free(&pattern);
1427 1428
	git_buf_free(&replace);

1429 1430
	return error;
}
1431

1432
int git_config_init_backend(git_config_backend *backend, unsigned int version)
1433
{
1434 1435 1436
	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
		backend, version, git_config_backend, GIT_CONFIG_BACKEND_INIT);
	return 0;
1437
}