config_file.c 34.1 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 9
#include "config_file.h"

10
#include "config.h"
11
#include "filebuf.h"
12
#include "sysdir.h"
13
#include "buffer.h"
14
#include "buf_text.h"
15
#include "git2/config.h"
16
#include "git2/sys/config.h"
17
#include "git2/types.h"
18
#include "strmap.h"
19
#include "array.h"
20
#include "config_parse.h"
21

22
#include <ctype.h>
23 24
#include <sys/types.h>
#include <regex.h>
25

26 27
typedef struct cvar_t {
	struct cvar_t *next;
28
	git_config_entry *entry;
29
	bool included; /* whether this is part of [include] */
30
} cvar_t;
31

32
typedef struct git_config_file_iter {
33
	git_config_iterator parent;
34
	git_strmap_iter iter;
35
	cvar_t* next_var;
36 37
} git_config_file_iter;

38 39
/* Max depth for [include] directives */
#define MAX_INCLUDE_DEPTH 10
40

41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79
#define CVAR_LIST_HEAD(list) ((list)->head)

#define CVAR_LIST_TAIL(list) ((list)->tail)

#define CVAR_LIST_NEXT(var) ((var)->next)

#define CVAR_LIST_EMPTY(list) ((list)->head == NULL)

#define CVAR_LIST_APPEND(list, var) do {\
	if (CVAR_LIST_EMPTY(list)) {\
		CVAR_LIST_HEAD(list) = CVAR_LIST_TAIL(list) = var;\
	} else {\
		CVAR_LIST_NEXT(CVAR_LIST_TAIL(list)) = var;\
		CVAR_LIST_TAIL(list) = var;\
	}\
} while(0)

#define CVAR_LIST_REMOVE_HEAD(list) do {\
	CVAR_LIST_HEAD(list) = CVAR_LIST_NEXT(CVAR_LIST_HEAD(list));\
} while(0)

#define CVAR_LIST_REMOVE_AFTER(var) do {\
	CVAR_LIST_NEXT(var) = CVAR_LIST_NEXT(CVAR_LIST_NEXT(var));\
} while(0)

#define CVAR_LIST_FOREACH(list, iter)\
	for ((iter) = CVAR_LIST_HEAD(list);\
		 (iter) != NULL;\
		 (iter) = CVAR_LIST_NEXT(iter))

/*
 * Inspired by the FreeBSD functions
 */
#define CVAR_LIST_FOREACH_SAFE(start, iter, tmp)\
	for ((iter) = CVAR_LIST_HEAD(vars);\
		 (iter) && (((tmp) = CVAR_LIST_NEXT(iter) || 1));\
		 (iter) = (tmp))

typedef struct {
80
	git_atomic refcount;
81
	git_strmap *values;
82 83 84 85 86 87 88
} refcounted_strmap;

typedef struct {
	git_config_backend parent;
	/* mutex to coordinate accessing the values */
	git_mutex values_mutex;
	refcounted_strmap *values;
89
	const git_repository *repo;
90
	git_config_level_t level;
91 92 93 94 95
} diskfile_header;

typedef struct {
	diskfile_header header;

96 97
	git_array_t(git_config_parser) readers;

98 99 100 101
	bool locked;
	git_filebuf locked_buf;
	git_buf locked_content;

102
	struct config_file file;
103
} diskfile_backend;
104

105 106 107 108 109 110
typedef struct {
	diskfile_header header;

	diskfile_backend *snapshot_from;
} diskfile_readonly_backend;

111
static int config_read(git_strmap *values, const git_repository *repo, git_config_file *file, git_config_level_t level, int depth);
112
static int config_write(diskfile_backend *cfg, const char *orig_key, const char *key, const regex_t *preg, const char *value);
113
static char *escape_value(const char *ptr);
114

115
int git_config_file__snapshot(git_config_backend **out, diskfile_backend *in);
116
static int config_snapshot(git_config_backend **out, git_config_backend *in);
117 118 119 120 121 122 123

static int config_error_readonly(void)
{
	giterr_set(GITERR_CONFIG, "this backend is read-only");
	return -1;
}

124
static void cvar_free(cvar_t *var)
125 126 127 128
{
	if (var == NULL)
		return;

129 130 131
	git__free((char*)var->entry->name);
	git__free((char *)var->entry->value);
	git__free(var->entry);
132
	git__free(var);
133 134
}

135 136 137 138 139 140 141 142 143 144 145 146
int git_config_file_normalize_section(char *start, char *end)
{
	char *scan;

	if (start == end)
		return GIT_EINVALIDSPEC;

	/* Validate and downcase range */
	for (scan = start; *scan; ++scan) {
		if (end && scan >= end)
			break;
		if (isalnum(*scan))
147
			*scan = (char)git__tolower(*scan);
148 149 150 151 152 153 154 155 156 157
		else if (*scan != '-' || scan == start)
			return GIT_EINVALIDSPEC;
	}

	if (scan == start)
		return GIT_EINVALIDSPEC;

	return 0;
}

158 159 160 161 162 163 164 165 166
/* Add or append the new config option */
static int append_entry(git_strmap *values, cvar_t *var)
{
	git_strmap_iter pos;
	cvar_t *existing;
	int error = 0;

	pos = git_strmap_lookup_index(values, var->entry->name);
	if (!git_strmap_valid_index(values, pos)) {
167
		git_strmap_insert(values, var->entry->name, var, &error);
168 169 170 171 172 173 174 175 176 177 178 179 180 181
	} else {
		existing = git_strmap_value_at(values, pos);
		while (existing->next != NULL) {
			existing = existing->next;
		}
		existing->next = var;
	}

	if (error > 0)
		error = 0;

	return error;
}

182
static void free_vars(git_strmap *values)
183
{
184
	cvar_t *var = NULL;
185

186 187
	if (values == NULL)
		return;
188

189
	git_strmap_foreach_value(values, var,
190 191 192 193 194
		while (var != NULL) {
			cvar_t *next = CVAR_LIST_NEXT(var);
			cvar_free(var);
			var = next;
		});
195

196
	git_strmap_free(values);
197 198
}

199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219
static void refcounted_strmap_free(refcounted_strmap *map)
{
	if (!map)
		return;

	if (git_atomic_dec(&map->refcount) != 0)
		return;

	free_vars(map->values);
	git__free(map);
}

/**
 * Take the current values map from the backend and increase its
 * refcount. This is its own function to make sure we use the mutex to
 * avoid the map pointer from changing under us.
 */
static refcounted_strmap *refcounted_strmap_take(diskfile_header *h)
{
	refcounted_strmap *map;

220
	if (git_mutex_lock(&h->values_mutex) < 0) {
221
	    giterr_set(GITERR_OS, "failed to lock config backend");
222 223
	    return NULL;
	}
224 225 226 227 228 229 230 231 232 233 234 235 236 237 238

	map = h->values;
	git_atomic_inc(&map->refcount);

	git_mutex_unlock(&h->values_mutex);

	return map;
}

static int refcounted_strmap_alloc(refcounted_strmap **out)
{
	refcounted_strmap *map;
	int error;

	map = git__calloc(1, sizeof(refcounted_strmap));
239
	GITERR_CHECK_ALLOC(map);
240 241

	git_atomic_set(&map->refcount, 1);
242 243

	if ((error = git_strmap_alloc(&map->values)) < 0)
244
		git__free(map);
245 246
	else
		*out = map;
247 248 249 250

	return error;
}

251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266
static void config_file_clear(struct config_file *file)
{
	struct config_file *include;
	uint32_t i;

	if (file == NULL)
		return;

	git_array_foreach(file->includes, i, include) {
		config_file_clear(include);
	}
	git_array_clear(file->includes);

	git__free(file->path);
}

267
static int config_open(git_config_backend *cfg, git_config_level_t level, const git_repository *repo)
268
{
269
	int res;
270
	diskfile_backend *b = (diskfile_backend *)cfg;
271

272
	b->header.level = level;
273
	b->header.repo = repo;
274

275
	if ((res = refcounted_strmap_alloc(&b->header.values)) < 0)
276
		return res;
277

278
	if (!git_path_exists(b->file.path))
279 280
		return 0;

281
	if (res < 0 || (res = config_read(b->header.values->values, repo, &b->file, level, 0)) < 0) {
282
		refcounted_strmap_free(b->header.values);
283
		b->header.values = NULL;
284
	}
285

286 287 288
	return res;
}

289
static int config_is_modified(int *modified, struct config_file *file)
290
{
291
	git_config_file *include;
292 293 294
	git_buf buf = GIT_BUF_INIT;
	git_oid hash;
	uint32_t i;
295
	int error = 0;
296

297 298 299
	*modified = 0;

	if ((error = git_futils_readbuffer(&buf, file->path)) < 0)
300
		goto out;
301

302
	if ((error = git_hash_buf(&hash, buf.ptr, buf.size)) < 0)
303
		goto out;
304

305 306 307 308 309 310 311 312 313
	if (!git_oid_equal(&hash, &file->checksum)) {
		*modified = 1;
		goto out;
	}

	git_array_foreach(file->includes, i, include) {
		if ((error = config_is_modified(modified, include)) < 0 || *modified)
			goto out;
	}
314 315

out:
316 317
	git_buf_free(&buf);

318 319 320
	return error;
}

Ben Straub committed
321
static int config_refresh(git_config_backend *cfg)
322 323
{
	diskfile_backend *b = (diskfile_backend *)cfg;
324
	refcounted_strmap *values = NULL, *tmp;
325
	git_config_file *include;
326
	int error, modified;
327
	uint32_t i;
328

329
	if (b->header.parent.readonly)
330
		return config_error_readonly();
331

332 333 334 335 336 337 338 339
	error = config_is_modified(&modified, &b->file);
	if (error < 0 && error != GIT_ENOTFOUND)
		goto out;

	if (!modified)
		return 0;

	if ((error = refcounted_strmap_alloc(&values)) < 0)
340 341
		goto out;

342 343 344 345 346
	/* Reparse the current configuration */
	git_array_foreach(b->file.includes, i, include) {
		config_file_clear(include);
	}
	git_array_clear(b->file.includes);
347

348
	if ((error = config_read(values->values, b->header.repo, &b->file, b->header.level, 0)) < 0)
349
		goto out;
350

351 352 353 354
	if ((error = git_mutex_lock(&b->header.values_mutex)) < 0) {
		giterr_set(GITERR_OS, "failed to lock config backend");
		goto out;
	}
355

356 357 358
	tmp = b->header.values;
	b->header.values = values;
	values = tmp;
359

360
	git_mutex_unlock(&b->header.values_mutex);
361

362 363
out:
	refcounted_strmap_free(values);
364

365
	return (error == GIT_ENOTFOUND) ? 0 : error;
366 367
}

Ben Straub committed
368
static void backend_free(git_config_backend *_backend)
369
{
370
	diskfile_backend *backend = (diskfile_backend *)_backend;
371 372 373 374

	if (backend == NULL)
		return;

375
	config_file_clear(&backend->file);
376
	refcounted_strmap_free(backend->header.values);
377
	git_mutex_free(&backend->header.values_mutex);
378
	git__free(backend);
379 380
}

381
static void config_iterator_free(
382
	git_config_iterator* iter)
383
{
384
	iter->backend->free(iter->backend);
385 386
	git__free(iter);
}
387

388
static int config_iterator_next(
389
	git_config_entry **entry,
390
	git_config_iterator *iter)
391
{
392
	git_config_file_iter *it = (git_config_file_iter *) iter;
393
	diskfile_header *h = (diskfile_header *) it->parent.backend;
394
	git_strmap *values = h->values->values;
395
	int err = 0;
396
	cvar_t * var;
397

398
	if (it->next_var == NULL) {
399
		err = git_strmap_next((void**) &var, &(it->iter), values);
400
	} else {
401
		var = it->next_var;
402
	}
403

404
	if (err < 0) {
405
		it->next_var = NULL;
406
		return err;
407
	}
408

409
	*entry = var->entry;
410
	it->next_var = CVAR_LIST_NEXT(var);
411

412 413
	return 0;
}
414

415 416 417 418
static int config_iterator_new(
	git_config_iterator **iter,
	struct git_config_backend* backend)
{
419 420 421
	diskfile_header *h;
	git_config_file_iter *it;
	git_config_backend *snapshot;
422
	diskfile_header *bh = (diskfile_header *) backend;
423
	int error;
424

425 426 427
	if ((error = config_snapshot(&snapshot, backend)) < 0)
		return error;

428
	if ((error = snapshot->open(snapshot, bh->level, bh->repo)) < 0)
429 430 431
		return error;

	it = git__calloc(1, sizeof(git_config_file_iter));
432 433
	GITERR_CHECK_ALLOC(it);

434 435
	h = (diskfile_header *)snapshot;

436 437 438
	/* strmap_begin() is currently a macro returning 0 */
	GIT_UNUSED(h);

439
	it->parent.backend = snapshot;
440
	it->iter = git_strmap_begin(h->values);
441 442 443 444 445
	it->next_var = NULL;

	it->parent.next = config_iterator_next;
	it->parent.free = config_iterator_free;
	*iter = (git_config_iterator *) it;
446 447

	return 0;
448 449
}

Ben Straub committed
450
static int config_set(git_config_backend *cfg, const char *name, const char *value)
451
{
452
	diskfile_backend *b = (diskfile_backend *)cfg;
453 454
	refcounted_strmap *map;
	git_strmap *values;
455
	char *key, *esc_value = NULL;
456
	khiter_t pos;
457
	int rval, ret;
458

459
	if ((rval = git_config__normalize_name(name, &key)) < 0)
460
		return rval;
461

462 463
	if ((map = refcounted_strmap_take(&b->header)) == NULL)
		return -1;
464 465
	values = map->values;

466
	/*
467 468
	 * Try to find it in the existing values and update it if it
	 * only has one value.
469
	 */
470 471 472
	pos = git_strmap_lookup_index(values, key);
	if (git_strmap_valid_index(values, pos)) {
		cvar_t *existing = git_strmap_value_at(values, pos);
Russell Belfer committed
473

474
		if (existing->next != NULL) {
475
			giterr_set(GITERR_CONFIG, "multivar incompatible with simple set");
476 477
			ret = -1;
			goto out;
478
		}
479

480 481 482 483 484 485
		if (existing->included) {
			giterr_set(GITERR_CONFIG, "modifying included variable is not supported");
			ret = -1;
			goto out;
		}

Russell Belfer committed
486
		/* don't update if old and new values already match */
487
		if ((!existing->entry->value && !value) ||
488 489
			(existing->entry->value && value &&
			 !strcmp(existing->entry->value, value))) {
490 491
			ret = 0;
			goto out;
492
		}
493 494
	}

495
	/* No early returns due to sanity checks, let's write it out and refresh */
496

497
	if (value) {
498 499
		esc_value = escape_value(value);
		GITERR_CHECK_ALLOC(esc_value);
500 501
	}

502
	if ((ret = config_write(b, name, key, NULL, esc_value)) < 0)
503
		goto out;
504

505
	ret = config_refresh(cfg);
506

507
out:
508
	refcounted_strmap_free(map);
509 510 511
	git__free(esc_value);
	git__free(key);
	return ret;
512 513
}

514 515 516 517 518 519 520
/* release the map containing the entry as an equivalent to freeing it */
static void release_map(git_config_entry *entry)
{
	refcounted_strmap *map = (refcounted_strmap *) entry->payload;
	refcounted_strmap_free(map);
}

521 522 523
/*
 * Internal function that actually gets the value in string form
 */
524
static int config_get(git_config_backend *cfg, const char *key, git_config_entry **out)
525
{
526
	diskfile_header *h = (diskfile_header *)cfg;
527
	refcounted_strmap *map;
528 529
	git_strmap *values;
	khiter_t pos;
530
	cvar_t *var;
531
	int error = 0;
532

533
	if (!h->parent.readonly && ((error = config_refresh(cfg)) < 0))
534 535
		return error;

536 537
	if ((map = refcounted_strmap_take(h)) == NULL)
		return -1;
538 539
	values = map->values;

540
	pos = git_strmap_lookup_index(values, key);
541

542
	/* no error message; the config system will write one */
543 544
	if (!git_strmap_valid_index(values, pos)) {
		refcounted_strmap_free(map);
545
		return GIT_ENOTFOUND;
546
	}
547

548
	var = git_strmap_value_at(values, pos);
549 550 551 552
	while (var->next)
		var = var->next;

	*out = var->entry;
553 554 555 556
	(*out)->free = release_map;
	(*out)->payload = map;

	return error;
557 558
}

559
static int config_set_multivar(
Ben Straub committed
560
	git_config_backend *cfg, const char *name, const char *regexp, const char *value)
561 562 563 564
{
	diskfile_backend *b = (diskfile_backend *)cfg;
	char *key;
	regex_t preg;
565
	int result;
566

567
	assert(regexp);
568

569
	if ((result = git_config__normalize_name(name, &key)) < 0)
570
		return result;
571

572
	result = p_regcomp(&preg, regexp, REG_EXTENDED);
573
	if (result != 0) {
574
		giterr_set_regex(&preg, result);
575 576
		result = -1;
		goto out;
577
	}
578

579
	/* If we do have it, set call config_write() and reload */
580
	if ((result = config_write(b, name, key, &preg, value)) < 0)
581
		goto out;
582

583
	result = config_refresh(cfg);
584

585
out:
586
	git__free(key);
587
	regfree(&preg);
588 589

	return result;
590 591
}

Ben Straub committed
592
static int config_delete(git_config_backend *cfg, const char *name)
593
{
594
	cvar_t *var;
595
	diskfile_backend *b = (diskfile_backend *)cfg;
596
	refcounted_strmap *map;	git_strmap *values;
597
	char *key;
598
	int result;
599
	khiter_t pos;
600

601
	if ((result = git_config__normalize_name(name, &key)) < 0)
602
		return result;
603

604 605
	if ((map = refcounted_strmap_take(&b->header)) == NULL)
		return -1;
606 607
	values = b->header.values->values;

608
	pos = git_strmap_lookup_index(values, key);
609
	git__free(key);
610

611
	if (!git_strmap_valid_index(values, pos)) {
612
		refcounted_strmap_free(map);
613
		giterr_set(GITERR_CONFIG, "could not find key '%s' to delete", name);
614
		return GIT_ENOTFOUND;
615
	}
616

617
	var = git_strmap_value_at(values, pos);
618
	refcounted_strmap_free(map);
619

620 621 622 623 624
	if (var->included) {
		giterr_set(GITERR_CONFIG, "cannot delete included variable");
		return -1;
	}

625
	if (var->next != NULL) {
626
		giterr_set(GITERR_CONFIG, "cannot delete multivar with a single delete");
627 628
		return -1;
	}
629

630
	if ((result = config_write(b, name, var->entry->name, NULL, NULL)) < 0)
631
		return result;
632

633
	return config_refresh(cfg);
634 635
}

636 637 638
static int config_delete_multivar(git_config_backend *cfg, const char *name, const char *regexp)
{
	diskfile_backend *b = (diskfile_backend *)cfg;
639 640
	refcounted_strmap *map;
	git_strmap *values;
641 642 643 644 645 646 647 648
	char *key;
	regex_t preg;
	int result;
	khiter_t pos;

	if ((result = git_config__normalize_name(name, &key)) < 0)
		return result;

649 650
	if ((map = refcounted_strmap_take(&b->header)) == NULL)
		return -1;
651 652
	values = b->header.values->values;

653
	pos = git_strmap_lookup_index(values, key);
654

655
	if (!git_strmap_valid_index(values, pos)) {
656
		refcounted_strmap_free(map);
657
		git__free(key);
658
		giterr_set(GITERR_CONFIG, "could not find key '%s' to delete", name);
659 660 661
		return GIT_ENOTFOUND;
	}

662 663
	refcounted_strmap_free(map);

664
	result = p_regcomp(&preg, regexp, REG_EXTENDED);
665
	if (result != 0) {
666
		giterr_set_regex(&preg, result);
667 668
		result = -1;
		goto out;
669 670
	}

671
	if ((result = config_write(b, name, key, &preg, NULL)) < 0)
672
		goto out;
673

674
	result = config_refresh(cfg);
675

676
out:
677
	git__free(key);
678
	regfree(&preg);
679 680 681
	return result;
}

682 683 684 685 686 687 688
static int config_snapshot(git_config_backend **out, git_config_backend *in)
{
	diskfile_backend *b = (diskfile_backend *) in;

	return git_config_file__snapshot(out, b);
}

689 690 691 692 693
static int config_lock(git_config_backend *_cfg)
{
	diskfile_backend *cfg = (diskfile_backend *) _cfg;
	int error;

694
	if ((error = git_filebuf_open(&cfg->locked_buf, cfg->file.path, 0, GIT_CONFIG_FILE_MODE)) < 0)
695 696
		return error;

697
	error = git_futils_readbuffer(&cfg->locked_content, cfg->file.path);
698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724
	if (error < 0 && error != GIT_ENOTFOUND) {
		git_filebuf_cleanup(&cfg->locked_buf);
		return error;
	}

	cfg->locked = true;
	return 0;

}

static int config_unlock(git_config_backend *_cfg, int success)
{
	diskfile_backend *cfg = (diskfile_backend *) _cfg;
	int error = 0;

	if (success) {
		git_filebuf_write(&cfg->locked_buf, cfg->locked_content.ptr, cfg->locked_content.size);
		error = git_filebuf_commit(&cfg->locked_buf);
	}

	git_filebuf_cleanup(&cfg->locked_buf);
	git_buf_free(&cfg->locked_content);
	cfg->locked = false;

	return error;
}

Ben Straub committed
725
int git_config_file__ondisk(git_config_backend **out, const char *path)
726
{
727
	diskfile_backend *backend;
728

729
	backend = git__calloc(1, sizeof(diskfile_backend));
730
	GITERR_CHECK_ALLOC(backend);
731

732
	backend->header.parent.version = GIT_CONFIG_BACKEND_VERSION;
733
	git_mutex_init(&backend->header.values_mutex);
734

735 736 737
	backend->file.path = git__strdup(path);
	GITERR_CHECK_ALLOC(backend->file.path);
	git_array_init(backend->file.includes);
738

739 740 741 742 743 744 745 746
	backend->header.parent.open = config_open;
	backend->header.parent.get = config_get;
	backend->header.parent.set = config_set;
	backend->header.parent.set_multivar = config_set_multivar;
	backend->header.parent.del = config_delete;
	backend->header.parent.del_multivar = config_delete_multivar;
	backend->header.parent.iterator = config_iterator_new;
	backend->header.parent.snapshot = config_snapshot;
747 748
	backend->header.parent.lock = config_lock;
	backend->header.parent.unlock = config_unlock;
749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792
	backend->header.parent.free = backend_free;

	*out = (git_config_backend *)backend;

	return 0;
}

static int config_set_readonly(git_config_backend *cfg, const char *name, const char *value)
{
	GIT_UNUSED(cfg);
	GIT_UNUSED(name);
	GIT_UNUSED(value);

	return config_error_readonly();
}

static int config_set_multivar_readonly(
	git_config_backend *cfg, const char *name, const char *regexp, const char *value)
{
	GIT_UNUSED(cfg);
	GIT_UNUSED(name);
	GIT_UNUSED(regexp);
	GIT_UNUSED(value);

	return config_error_readonly();
}

static int config_delete_multivar_readonly(git_config_backend *cfg, const char *name, const char *regexp)
{
	GIT_UNUSED(cfg);
	GIT_UNUSED(name);
	GIT_UNUSED(regexp);

	return config_error_readonly();
}

static int config_delete_readonly(git_config_backend *cfg, const char *name)
{
	GIT_UNUSED(cfg);
	GIT_UNUSED(name);

	return config_error_readonly();
}

793 794 795 796 797 798 799 800 801 802 803 804 805 806 807
static int config_lock_readonly(git_config_backend *_cfg)
{
	GIT_UNUSED(_cfg);

	return config_error_readonly();
}

static int config_unlock_readonly(git_config_backend *_cfg, int success)
{
	GIT_UNUSED(_cfg);
	GIT_UNUSED(success);

	return config_error_readonly();
}

808 809 810 811 812 813 814
static void backend_readonly_free(git_config_backend *_backend)
{
	diskfile_backend *backend = (diskfile_backend *)_backend;

	if (backend == NULL)
		return;

815
	refcounted_strmap_free(backend->header.values);
816
	git_mutex_free(&backend->header.values_mutex);
817 818 819
	git__free(backend);
}

820
static int config_readonly_open(git_config_backend *cfg, git_config_level_t level, const git_repository *repo)
821 822 823
{
	diskfile_readonly_backend *b = (diskfile_readonly_backend *) cfg;
	diskfile_backend *src = b->snapshot_from;
824
	diskfile_header *src_header = &src->header;
825
	refcounted_strmap *src_map;
826 827
	int error;

828
	if (!src_header->parent.readonly && (error = config_refresh(&src_header->parent)) < 0)
829
		return error;
830

831
	/* We're just copying data, don't care about the level or repo*/
832
	GIT_UNUSED(level);
833
	GIT_UNUSED(repo);
834

835 836
	if ((src_map = refcounted_strmap_take(src_header)) == NULL)
		return -1;
837
	b->header.values = src_map;
838

839
	return 0;
840 841 842 843 844 845 846 847 848 849
}

int git_config_file__snapshot(git_config_backend **out, diskfile_backend *in)
{
	diskfile_readonly_backend *backend;

	backend = git__calloc(1, sizeof(diskfile_readonly_backend));
	GITERR_CHECK_ALLOC(backend);

	backend->header.parent.version = GIT_CONFIG_BACKEND_VERSION;
850
	git_mutex_init(&backend->header.values_mutex);
851 852 853

	backend->snapshot_from = in;

854
	backend->header.parent.readonly = 1;
855 856 857 858 859 860 861 862
	backend->header.parent.version = GIT_CONFIG_BACKEND_VERSION;
	backend->header.parent.open = config_readonly_open;
	backend->header.parent.get = config_get;
	backend->header.parent.set = config_set_readonly;
	backend->header.parent.set_multivar = config_set_multivar_readonly;
	backend->header.parent.del = config_delete_readonly;
	backend->header.parent.del_multivar = config_delete_multivar_readonly;
	backend->header.parent.iterator = config_iterator_new;
863 864
	backend->header.parent.lock = config_lock_readonly;
	backend->header.parent.unlock = config_unlock_readonly;
865
	backend->header.parent.free = backend_readonly_free;
866

Ben Straub committed
867
	*out = (git_config_backend *)backend;
868

869
	return 0;
870 871
}

872 873 874 875
static int included_path(git_buf *out, const char *dir, const char *path)
{
	/* From the user's home */
	if (path[0] == '~' && path[1] == '/')
876
		return git_sysdir_expand_global_file(out, &path[1]);
877 878 879 880

	return git_path_join_unrooted(out, path, dir, NULL);
}

881 882 883
/* Escape the values to write them to the file */
static char *escape_value(const char *ptr)
{
884
	git_buf buf;
885 886 887 888 889 890
	size_t len;
	const char *esc;

	assert(ptr);

	len = strlen(ptr);
891 892 893
	if (!len)
		return git__calloc(1, sizeof(char));

894 895
	if (git_buf_init(&buf, len) < 0)
		return NULL;
896 897

	while (*ptr != '\0') {
898
		if ((esc = strchr(git_config_escaped, *ptr)) != NULL) {
899
			git_buf_putc(&buf, '\\');
900
			git_buf_putc(&buf, git_config_escapes[esc - git_config_escaped]);
901 902 903 904 905 906 907 908 909 910 911 912 913 914
		} else {
			git_buf_putc(&buf, *ptr);
		}
		ptr++;
	}

	if (git_buf_oom(&buf)) {
		git_buf_free(&buf);
		return NULL;
	}

	return git_buf_detach(&buf);
}

915
struct parse_data {
916 917
	const git_repository *repo;
	const char *file_path;
918 919 920 921 922
	git_strmap *values;
	git_config_level_t level;
	int depth;
};

923
static int parse_include(git_config_parser *reader,
924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945
	struct parse_data *parse_data, const char *file)
{
	struct config_file *include;
	git_buf path = GIT_BUF_INIT;
	char *dir;
	int result;

	if ((result = git_path_dirname_r(&path, reader->file->path)) < 0)
		return result;

	dir = git_buf_detach(&path);
	result = included_path(&path, dir, file);
	git__free(dir);

	if (result < 0)
		return result;

	include = git_array_alloc(reader->file->includes);
	memset(include, 0, sizeof(*include));
	git_array_init(include->includes);
	include->path = git_buf_detach(&path);

946
	result = config_read(parse_data->values, parse_data->repo,
947
		include, parse_data->level, parse_data->depth+1);
948 949 950 951 952 953 954 955 956

	if (result == GIT_ENOTFOUND) {
		giterr_clear();
		result = 0;
	}

	return result;
}

957
static int do_match_gitdir(
958 959 960
	int *matches,
	const git_repository *repo,
	const char *cfg_file,
961 962
	const char *value,
	bool case_insensitive)
963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985
{
	git_buf path = GIT_BUF_INIT;
	int error, fnmatch_flags;

	if (value[0] == '.' && git_path_is_dirsep(value[1])) {
		git_path_dirname_r(&path, cfg_file);
		git_buf_joinpath(&path, path.ptr, value + 2);
	} else if (value[0] == '~' && git_path_is_dirsep(value[1]))
		git_sysdir_expand_global_file(&path, value + 1);
	else if (!git_path_is_absolute(value))
		git_buf_joinpath(&path, "**", value);
	else
		git_buf_sets(&path, value);

	if (git_buf_oom(&path)) {
		error = -1;
		goto out;
	}

	if (git_path_is_dirsep(value[strlen(value) - 1]))
		git_buf_puts(&path, "**");

	fnmatch_flags = FNM_PATHNAME|FNM_LEADING_DIR;
986 987
	if (case_insensitive)
		fnmatch_flags |= FNM_IGNORECASE;
988 989 990 991 992 993 994 995 996 997 998

	if ((error = p_fnmatch(path.ptr, git_repository_path(repo), fnmatch_flags)) < 0)
		goto out;

	*matches = (error == 0);

out:
	git_buf_free(&path);
	return error;
}

999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016
static int conditional_match_gitdir(
	int *matches,
	const git_repository *repo,
	const char *cfg_file,
	const char *value)
{
	return do_match_gitdir(matches, repo, cfg_file, value, false);
}

static int conditional_match_gitdir_i(
	int *matches,
	const git_repository *repo,
	const char *cfg_file,
	const char *value)
{
	return do_match_gitdir(matches, repo, cfg_file, value, true);
}

1017 1018 1019 1020
static const struct {
	const char *prefix;
	int (*matches)(int *matches, const git_repository *repo, const char *cfg, const char *value);
} conditions[] = {
1021 1022
	{ "gitdir:", conditional_match_gitdir },
	{ "gitdir/i:", conditional_match_gitdir_i }
1023 1024
};

1025
static int parse_conditional_include(git_config_parser *reader,
1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057
	struct parse_data *parse_data, const char *section, const char *file)
{
	char *condition;
	size_t i;
	int error = 0, matches;

	if (!parse_data->repo)
		return 0;

	condition = git__substrdup(section + strlen("includeIf."),
				   strlen(section) - strlen("includeIf.") - strlen(".path"));

	for (i = 0; i < ARRAY_SIZE(conditions); i++) {
		if (git__prefixcmp(condition, conditions[i].prefix))
			continue;

		if ((error = conditions[i].matches(&matches,
						   parse_data->repo,
						   parse_data->file_path,
						   condition + strlen(conditions[i].prefix))) < 0)
			break;

		if (matches)
			error = parse_include(reader, parse_data, file);

		break;
	}

	git__free(condition);
	return error;
}

1058
static int read_on_variable(
1059
	git_config_parser *reader,
1060 1061 1062 1063 1064 1065
	const char *current_section,
	char *var_name,
	char *var_value,
	const char *line,
	size_t line_len,
	void *data)
1066 1067 1068 1069 1070 1071
{
	struct parse_data *parse_data = (struct parse_data *)data;
	git_buf buf = GIT_BUF_INIT;
	cvar_t *var;
	int result = 0;

1072 1073 1074
	GIT_UNUSED(line);
	GIT_UNUSED(line_len);

1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099
	git__strtolower(var_name);
	git_buf_printf(&buf, "%s.%s", current_section, var_name);
	git__free(var_name);

	if (git_buf_oom(&buf)) {
		git__free(var_value);
		return -1;
	}

	var = git__calloc(1, sizeof(cvar_t));
	GITERR_CHECK_ALLOC(var);
	var->entry = git__calloc(1, sizeof(git_config_entry));
	GITERR_CHECK_ALLOC(var->entry);

	var->entry->name = git_buf_detach(&buf);
	var->entry->value = var_value;
	var->entry->level = parse_data->level;
	var->included = !!parse_data->depth;

	if ((result = append_entry(parse_data->values, var)) < 0)
		return result;

	result = 0;

	/* Add or append the new config option */
1100 1101
	if (!git__strcmp(var->entry->name, "include.path"))
		result = parse_include(reader, parse_data, var->entry->value);
1102 1103 1104 1105 1106
	else if (!git__prefixcmp(var->entry->name, "includeif.") &&
	         !git__suffixcmp(var->entry->name, ".path"))
		result = parse_conditional_include(reader, parse_data,
						   var->entry->name, var->entry->value);

1107 1108 1109 1110

	return result;
}

1111
static int config_read(
1112
	git_strmap *values,
1113
	const git_repository *repo,
1114
	git_config_file *file,
1115 1116
	git_config_level_t level,
	int depth)
1117 1118
{
	struct parse_data parse_data;
1119
	git_config_parser reader;
1120
	git_buf contents = GIT_BUF_INIT;
1121
	int error;
1122 1123

	if (depth >= MAX_INCLUDE_DEPTH) {
1124
		giterr_set(GITERR_CONFIG, "maximum config include depth reached");
1125 1126 1127
		return -1;
	}

1128
	if ((error = git_futils_readbuffer(&contents, file->path)) < 0)
1129 1130
		goto out;

1131 1132 1133
	git_parse_ctx_init(&reader.ctx, contents.ptr, contents.size);

	if ((error = git_hash_buf(&file->checksum, contents.ptr, contents.size)) < 0)
1134 1135
		goto out;

1136
	/* Initialize the reading position */
1137
	reader.file = file;
1138
	git_parse_ctx_init(&reader.ctx, contents.ptr, contents.size);
1139 1140

	/* If the file is empty, there's nothing for us to do */
1141
	if (!reader.ctx.content || *reader.ctx.content == '\0')
1142
		goto out;
1143

1144 1145
	parse_data.repo = repo;
	parse_data.file_path = file->path;
1146 1147 1148 1149
	parse_data.values = values;
	parse_data.level = level;
	parse_data.depth = depth;

1150
	error = git_config_parse(&reader, NULL, read_on_variable, NULL, NULL, &parse_data);
1151 1152

out:
1153
	git_buf_free(&contents);
1154
	return error;
1155 1156
}

1157
static int write_section(git_buf *fbuf, const char *key)
1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180
{
	int result;
	const char *dot;
	git_buf buf = GIT_BUF_INIT;

	/* All of this just for [section "subsection"] */
	dot = strchr(key, '.');
	git_buf_putc(&buf, '[');
	if (dot == NULL) {
		git_buf_puts(&buf, key);
	} else {
		char *escaped;
		git_buf_put(&buf, key, dot - key);
		escaped = escape_value(dot + 1);
		GITERR_CHECK_ALLOC(escaped);
		git_buf_printf(&buf, " \"%s\"", escaped);
		git__free(escaped);
	}
	git_buf_puts(&buf, "]\n");

	if (git_buf_oom(&buf))
		return -1;

1181
	result = git_buf_put(fbuf, git_buf_cstr(&buf), buf.size);
1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205
	git_buf_free(&buf);

	return result;
}

static const char *quotes_for_value(const char *value)
{
	const char *ptr;

	if (value[0] == ' ' || value[0] == '\0')
		return "\"";

	for (ptr = value; *ptr; ++ptr) {
		if (*ptr == ';' || *ptr == '#')
			return "\"";
	}

	if (ptr[-1] == ' ')
		return "\"";

	return "";
}

struct write_data {
1206
	git_buf *buf;
1207
	git_buf buffered_comment;
1208 1209
	unsigned int in_section : 1,
		preg_replaced : 1;
1210
	const char *orig_section;
1211
	const char *section;
1212
	const char *orig_name;
1213 1214 1215 1216 1217
	const char *name;
	const regex_t *preg;
	const char *value;
};

1218
static int write_line_to(git_buf *buf, const char *line, size_t line_len)
1219
{
1220
	int result = git_buf_put(buf, line, line_len);
1221 1222

	if (!result && line_len && line[line_len-1] != '\n')
1223
		result = git_buf_printf(buf, "\n");
1224 1225 1226 1227

	return result;
}

1228 1229 1230 1231 1232
static int write_line(struct write_data *write_data, const char *line, size_t line_len)
{
	return write_line_to(write_data->buf, line, line_len);
}

1233 1234 1235 1236 1237 1238
static int write_value(struct write_data *write_data)
{
	const char *q;
	int result;

	q = quotes_for_value(write_data->value);
1239
	result = git_buf_printf(write_data->buf,
1240
		"\t%s = %s%s%s\n", write_data->orig_name, q, write_data->value, q);
1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251

	/* If we are updating a single name/value, we're done.  Setting `value`
	 * to `NULL` will prevent us from trying to write it again later (in
	 * `write_on_section`) if we see the same section repeated.
	 */
	if (!write_data->preg)
		write_data->value = NULL;

	return result;
}

1252
static int write_on_section(
1253
	git_config_parser *reader,
1254 1255 1256 1257
	const char *current_section,
	const char *line,
	size_t line_len,
	void *data)
1258 1259 1260 1261
{
	struct write_data *write_data = (struct write_data *)data;
	int result = 0;

1262 1263
	GIT_UNUSED(reader);

1264 1265 1266 1267 1268 1269 1270 1271 1272 1273
	/* If we were previously in the correct section (but aren't anymore)
	 * and haven't written our value (for a simple name/value set, not
	 * a multivar), then append it to the end of the section before writing
	 * the new one.
	 */
	if (write_data->in_section && !write_data->preg && write_data->value)
		result = write_value(write_data);

	write_data->in_section = strcmp(current_section, write_data->section) == 0;

1274 1275 1276 1277 1278 1279 1280 1281
	/*
	 * If there were comments just before this section, dump them as well.
	 */
	if (!result) {
		result = git_buf_put(write_data->buf, write_data->buffered_comment.ptr, write_data->buffered_comment.size);
		git_buf_clear(&write_data->buffered_comment);
	}

1282
	if (!result)
1283
		result = write_line(write_data, line, line_len);
1284 1285 1286 1287

	return result;
}

1288
static int write_on_variable(
1289
	git_config_parser *reader,
1290 1291 1292 1293 1294 1295
	const char *current_section,
	char *var_name,
	char *var_value,
	const char *line,
	size_t line_len,
	void *data)
1296 1297 1298
{
	struct write_data *write_data = (struct write_data *)data;
	bool has_matched = false;
1299
	int error;
1300 1301 1302

	GIT_UNUSED(reader);
	GIT_UNUSED(current_section);
1303

1304 1305 1306 1307 1308 1309 1310 1311
	/*
	 * If there were comments just before this variable, let's dump them as well.
	 */
	if ((error = git_buf_put(write_data->buf, write_data->buffered_comment.ptr, write_data->buffered_comment.size)) < 0)
		return error;

	git_buf_clear(&write_data->buffered_comment);

1312 1313 1314 1315 1316 1317 1318 1319 1320
	/* See if we are to update this name/value pair; first examine name */
	if (write_data->in_section &&
		strcasecmp(write_data->name, var_name) == 0)
		has_matched = true;

	/* If we have a regex to match the value, see if it matches */
	if (has_matched && write_data->preg != NULL)
		has_matched = (regexec(write_data->preg, var_value, 0, NULL, 0) == 0);

1321 1322
	git__free(var_name);
	git__free(var_value);
1323 1324 1325 1326

	/* If this isn't the name/value we're looking for, simply dump the
	 * existing data back out and continue on.
	 */
1327 1328
	if (!has_matched)
		return write_line(write_data, line, line_len);
1329 1330 1331 1332 1333 1334 1335 1336 1337 1338

	write_data->preg_replaced = 1;

	/* If value is NULL, we are deleting this value; write nothing. */
	if (!write_data->value)
		return 0;

	return write_value(write_data);
}

1339
static int write_on_comment(git_config_parser *reader, const char *line, size_t line_len, void *data)
1340
{
1341 1342 1343 1344 1345
	struct write_data *write_data;

	GIT_UNUSED(reader);

	write_data = (struct write_data *)data;
1346
	return write_line_to(&write_data->buffered_comment, line, line_len);
1347 1348
}

1349
static int write_on_eof(
1350
	git_config_parser *reader, const char *current_section, void *data)
1351 1352 1353 1354
{
	struct write_data *write_data = (struct write_data *)data;
	int result = 0;

1355 1356
	GIT_UNUSED(reader);

1357 1358 1359 1360 1361 1362
	/*
	 * If we've buffered comments when reaching EOF, make sure to dump them.
	 */
	if ((result = git_buf_put(write_data->buf, write_data->buffered_comment.ptr, write_data->buffered_comment.size)) < 0)
		return result;

1363 1364 1365 1366 1367 1368
	/* If we are at the EOF and have not written our value (again, for a
	 * simple name/value set, not a multivar) then we have never seen the
	 * section in question and should create a new section and write the
	 * value.
	 */
	if ((!write_data->preg || !write_data->preg_replaced) && write_data->value) {
1369 1370
		/* write the section header unless we're already in it */
		if (!current_section || strcmp(current_section, write_data->section))
1371
			result = write_section(write_data->buf, write_data->orig_section);
1372 1373

		if (!result)
1374 1375 1376 1377 1378 1379 1380 1381 1382
			result = write_value(write_data);
	}

	return result;
}

/*
 * This is pretty much the parsing, except we write out anything we don't have
 */
1383
static int config_write(diskfile_backend *cfg, const char *orig_key, const char *key, const regex_t *preg, const char* value)
1384 1385
{
	int result;
1386
	char *orig_section, *section, *orig_name, *name, *ldot;
1387
	git_filebuf file = GIT_FILEBUF_INIT;
1388
	git_buf buf = GIT_BUF_INIT, contents = GIT_BUF_INIT;
1389
	git_config_parser reader;
1390 1391
	struct write_data write_data;

1392 1393
	memset(&reader, 0, sizeof(reader));
	reader.file = &cfg->file;
1394

1395
	if (cfg->locked) {
1396
		result = git_buf_puts(&contents, git_buf_cstr(&cfg->locked_content));
1397 1398 1399
	} else {
		/* Lock the file */
		if ((result = git_filebuf_open(
1400
			     &file, cfg->file.path, GIT_FILEBUF_HASH_CONTENTS, GIT_CONFIG_FILE_MODE)) < 0) {
1401
			git_buf_free(&contents);
1402
			return result;
1403
		}
1404

1405
		/* We need to read in our own config file */
1406
		result = git_futils_readbuffer(&contents, cfg->file.path);
1407
	}
1408 1409

	/* Initialise the reading position */
1410 1411
	if (result == 0 || result == GIT_ENOTFOUND) {
		git_parse_ctx_init(&reader.ctx, contents.ptr, contents.size);
1412
	} else {
1413
		git_filebuf_cleanup(&file);
1414 1415 1416 1417 1418 1419
		return -1; /* OS error when reading the file */
	}

	ldot = strrchr(key, '.');
	name = ldot + 1;
	section = git__strndup(key, ldot - key);
1420
	GITERR_CHECK_ALLOC(section);
1421

1422 1423 1424
	ldot = strrchr(orig_key, '.');
	orig_name = ldot + 1;
	orig_section = git__strndup(orig_key, ldot - orig_key);
1425
	GITERR_CHECK_ALLOC(orig_section);
1426

1427
	write_data.buf = &buf;
1428
	git_buf_init(&write_data.buffered_comment, 0);
1429
	write_data.orig_section = orig_section;
1430 1431 1432
	write_data.section = section;
	write_data.in_section = 0;
	write_data.preg_replaced = 0;
1433
	write_data.orig_name = orig_name;
1434 1435 1436 1437
	write_data.name = name;
	write_data.preg = preg;
	write_data.value = value;

1438 1439 1440 1441 1442 1443
	result = git_config_parse(&reader,
		write_on_section,
		write_on_variable,
		write_on_comment,
		write_on_eof,
		&write_data);
1444
	git__free(section);
1445
	git__free(orig_section);
1446
	git_buf_free(&write_data.buffered_comment);
1447 1448

	if (result < 0) {
1449 1450 1451 1452
		git_filebuf_cleanup(&file);
		goto done;
	}

1453 1454 1455 1456 1457 1458 1459 1460 1461
	if (cfg->locked) {
		size_t len = buf.asize;
		/* Update our copy with the modified contents */
		git_buf_free(&cfg->locked_content);
		git_buf_attach(&cfg->locked_content, git_buf_detach(&buf), len);
	} else {
		git_filebuf_write(&file, git_buf_cstr(&buf), git_buf_len(&buf));
		result = git_filebuf_commit(&file);
	}
1462 1463

done:
1464
	git_buf_free(&buf);
1465 1466
	git_buf_free(&contents);
	git_parse_ctx_clear(&reader.ctx);
1467 1468
	return result;
}