?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
compat/mingw: support POSIX semantics for atomic renames
[git/gitster.git] / config.c
bloba11bb85da303a7267e86a7a0b420fe22881e4d4f
1 /*
2 * GIT - The information manager from hell
3 *
4 * Copyright (C) Linus Torvalds, 2005
5 * Copyright (C) Johannes Schindelin, 2005
6 *
7 */
8
9 #define USE_THE_REPOSITORY_VARIABLE
10
11 #include "git-compat-util.h"
12 #include "abspath.h"
13 #include "advice.h"
14 #include "date.h"
15 #include "branch.h"
16 #include "config.h"
17 #include "parse.h"
18 #include "convert.h"
19 #include "environment.h"
20 #include "gettext.h"
21 #include "ident.h"
22 #include "repository.h"
23 #include "lockfile.h"
24 #include "mailmap.h"
25 #include "attr.h"
26 #include "exec-cmd.h"
27 #include "strbuf.h"
28 #include "quote.h"
29 #include "hashmap.h"
30 #include "string-list.h"
31 #include "object-name.h"
32 #include "object-store-ll.h"
33 #include "pager.h"
34 #include "path.h"
35 #include "utf8.h"
36 #include "color.h"
37 #include "refs.h"
38 #include "setup.h"
39 #include "strvec.h"
40 #include "trace2.h"
41 #include "wildmatch.h"
42 #include "ws.h"
43 #include "write-or-die.h"
44
45 struct config_source {
46 struct config_source *prev;
47 union {
48 FILE *file;
49 struct config_buf {
50 const char *buf;
51 size_t len;
52 size_t pos;
53 } buf;
54 } u;
55 enum config_origin_type origin_type;
56 const char *name;
57 const char *path;
58 enum config_error_action default_error_action;
59 int linenr;
60 int eof;
61 size_t total_len;
62 struct strbuf value;
63 struct strbuf var;
64 unsigned subsection_case_sensitive : 1;
65
66 int (*do_fgetc)(struct config_source *c);
67 int (*do_ungetc)(int c, struct config_source *conf);
68 long (*do_ftell)(struct config_source *c);
69 };
70 #define CONFIG_SOURCE_INIT { 0 }
71
72 static int pack_compression_seen;
73 static int zlib_compression_seen;
74
75 /*
76 * Config that comes from trusted scopes, namely:
77 * - CONFIG_SCOPE_SYSTEM (e.g. /etc/gitconfig)
78 * - CONFIG_SCOPE_GLOBAL (e.g. $HOME/.gitconfig, $XDG_CONFIG_HOME/git)
79 * - CONFIG_SCOPE_COMMAND (e.g. "-c" option, environment variables)
80 *
81 * This is declared here for code cleanliness, but unlike the other
82 * static variables, this does not hold config parser state.
83 */
84 static struct config_set protected_config;
85
86 static int config_file_fgetc(struct config_source *conf)
87 {
88 return getc_unlocked(conf->u.file);
89 }
90
91 static int config_file_ungetc(int c, struct config_source *conf)
92 {
93 return ungetc(c, conf->u.file);
94 }
95
96 static long config_file_ftell(struct config_source *conf)
97 {
98 return ftell(conf->u.file);
99 }
100
101 static int config_buf_fgetc(struct config_source *conf)
102 {
103 if (conf->u.buf.pos < conf->u.buf.len)
104 return conf->u.buf.buf[conf->u.buf.pos++];
105
106 return EOF;
107 }
108
109 static int config_buf_ungetc(int c, struct config_source *conf)
110 {
111 if (conf->u.buf.pos > 0) {
112 conf->u.buf.pos--;
113 if (conf->u.buf.buf[conf->u.buf.pos] != c)
114 BUG("config_buf can only ungetc the same character");
115 return c;
116 }
117
118 return EOF;
119 }
120
121 static long config_buf_ftell(struct config_source *conf)
122 {
123 return conf->u.buf.pos;
124 }
125
126 struct config_include_data {
127 int depth;
128 config_fn_t fn;
129 void *data;
130 const struct config_options *opts;
131 const struct git_config_source *config_source;
132 struct repository *repo;
133
134 /*
135 * All remote URLs discovered when reading all config files.
136 */
137 struct string_list *remote_urls;
138 };
139 #define CONFIG_INCLUDE_INIT { 0 }
140
141 static int git_config_include(const char *var, const char *value,
142 const struct config_context *ctx, void *data);
143
144 #define MAX_INCLUDE_DEPTH 10
145 static const char include_depth_advice[] = N_(
146 "exceeded maximum include depth (%d) while including\n"
147 " %s\n"
148 "from\n"
149 " %s\n"
150 "This might be due to circular includes.");
151 static int handle_path_include(const struct key_value_info *kvi,
152 const char *path,
153 struct config_include_data *inc)
154 {
155 int ret = 0;
156 struct strbuf buf = STRBUF_INIT;
157 char *expanded;
158
159 if (!path)
160 return config_error_nonbool("include.path");
161
162 expanded = interpolate_path(path, 0);
163 if (!expanded)
164 return error(_("could not expand include path '%s'"), path);
165 path = expanded;
166
167 /*
168 * Use an absolute path as-is, but interpret relative paths
169 * based on the including config file.
170 */
171 if (!is_absolute_path(path)) {
172 char *slash;
173
174 if (!kvi || !kvi->path) {
175 ret = error(_("relative config includes must come from files"));
176 goto cleanup;
177 }
178
179 slash = find_last_dir_sep(kvi->path);
180 if (slash)
181 strbuf_add(&buf, kvi->path, slash - kvi->path + 1);
182 strbuf_addstr(&buf, path);
183 path = buf.buf;
184 }
185
186 if (!access_or_die(path, R_OK, 0)) {
187 if (++inc->depth > MAX_INCLUDE_DEPTH)
188 die(_(include_depth_advice), MAX_INCLUDE_DEPTH, path,
189 !kvi ? "<unknown>" :
190 kvi->filename ? kvi->filename :
191 "the command line");
192 ret = git_config_from_file_with_options(git_config_include, path, inc,
193 kvi->scope, NULL);
194 inc->depth--;
195 }
196 cleanup:
197 strbuf_release(&buf);
198 free(expanded);
199 return ret;
200 }
201
202 static void add_trailing_starstar_for_dir(struct strbuf *pat)
203 {
204 if (pat->len && is_dir_sep(pat->buf[pat->len - 1]))
205 strbuf_addstr(pat, "**");
206 }
207
208 static int prepare_include_condition_pattern(const struct key_value_info *kvi,
209 struct strbuf *pat)
210 {
211 struct strbuf path = STRBUF_INIT;
212 char *expanded;
213 int prefix = 0;
214
215 expanded = interpolate_path(pat->buf, 1);
216 if (expanded) {
217 strbuf_reset(pat);
218 strbuf_addstr(pat, expanded);
219 free(expanded);
220 }
221
222 if (pat->buf[0] == '.' && is_dir_sep(pat->buf[1])) {
223 const char *slash;
224
225 if (!kvi || !kvi->path)
226 return error(_("relative config include "
227 "conditionals must come from files"));
228
229 strbuf_realpath(&path, kvi->path, 1);
230 slash = find_last_dir_sep(path.buf);
231 if (!slash)
232 BUG("how is this possible?");
233 strbuf_splice(pat, 0, 1, path.buf, slash - path.buf);
234 prefix = slash - path.buf + 1 /* slash */;
235 } else if (!is_absolute_path(pat->buf))
236 strbuf_insertstr(pat, 0, "**/");
237
238 add_trailing_starstar_for_dir(pat);
239
240 strbuf_release(&path);
241 return prefix;
242 }
243
244 static int include_by_gitdir(const struct key_value_info *kvi,
245 const struct config_options *opts,
246 const char *cond, size_t cond_len, int icase)
247 {
248 struct strbuf text = STRBUF_INIT;
249 struct strbuf pattern = STRBUF_INIT;
250 int ret = 0, prefix;
251 const char *git_dir;
252 int already_tried_absolute = 0;
253
254 if (opts->git_dir)
255 git_dir = opts->git_dir;
256 else
257 goto done;
258
259 strbuf_realpath(&text, git_dir, 1);
260 strbuf_add(&pattern, cond, cond_len);
261 prefix = prepare_include_condition_pattern(kvi, &pattern);
262
263 again:
264 if (prefix < 0)
265 goto done;
266
267 if (prefix > 0) {
268 /*
269 * perform literal matching on the prefix part so that
270 * any wildcard character in it can't create side effects.
271 */
272 if (text.len < prefix)
273 goto done;
274 if (!icase && strncmp(pattern.buf, text.buf, prefix))
275 goto done;
276 if (icase && strncasecmp(pattern.buf, text.buf, prefix))
277 goto done;
278 }
279
280 ret = !wildmatch(pattern.buf + prefix, text.buf + prefix,
281 WM_PATHNAME | (icase ? WM_CASEFOLD : 0));
282
283 if (!ret && !already_tried_absolute) {
284 /*
285 * We've tried e.g. matching gitdir:~/work, but if
286 * ~/work is a symlink to /mnt/storage/work
287 * strbuf_realpath() will expand it, so the rule won't
288 * match. Let's match against a
289 * strbuf_add_absolute_path() version of the path,
290 * which'll do the right thing
291 */
292 strbuf_reset(&text);
293 strbuf_add_absolute_path(&text, git_dir);
294 already_tried_absolute = 1;
295 goto again;
296 }
297 done:
298 strbuf_release(&pattern);
299 strbuf_release(&text);
300 return ret;
301 }
302
303 static int include_by_branch(struct config_include_data *data,
304 const char *cond, size_t cond_len)
305 {
306 int flags;
307 int ret;
308 struct strbuf pattern = STRBUF_INIT;
309 const char *refname, *shortname;
310
311 if (!data->repo || data->repo->ref_storage_format == REF_STORAGE_FORMAT_UNKNOWN)
312 return 0;
313
314 refname = refs_resolve_ref_unsafe(get_main_ref_store(data->repo),
315 "HEAD", 0, NULL, &flags);
316 if (!refname ||
317 !(flags & REF_ISSYMREF) ||
318 !skip_prefix(refname, "refs/heads/", &shortname))
319 return 0;
320
321 strbuf_add(&pattern, cond, cond_len);
322 add_trailing_starstar_for_dir(&pattern);
323 ret = !wildmatch(pattern.buf, shortname, WM_PATHNAME);
324 strbuf_release(&pattern);
325 return ret;
326 }
327
328 static int add_remote_url(const char *var, const char *value,
329 const struct config_context *ctx UNUSED, void *data)
330 {
331 struct string_list *remote_urls = data;
332 const char *remote_name;
333 size_t remote_name_len;
334 const char *key;
335
336 if (!parse_config_key(var, "remote", &remote_name, &remote_name_len,
337 &key) &&
338 remote_name &&
339 !strcmp(key, "url"))
340 string_list_append(remote_urls, value);
341 return 0;
342 }
343
344 static void populate_remote_urls(struct config_include_data *inc)
345 {
346 struct config_options opts;
347
348 opts = *inc->opts;
349 opts.unconditional_remote_url = 1;
350
351 inc->remote_urls = xmalloc(sizeof(*inc->remote_urls));
352 string_list_init_dup(inc->remote_urls);
353 config_with_options(add_remote_url, inc->remote_urls,
354 inc->config_source, inc->repo, &opts);
355 }
356
357 static int forbid_remote_url(const char *var, const char *value UNUSED,
358 const struct config_context *ctx UNUSED,
359 void *data UNUSED)
360 {
361 const char *remote_name;
362 size_t remote_name_len;
363 const char *key;
364
365 if (!parse_config_key(var, "remote", &remote_name, &remote_name_len,
366 &key) &&
367 remote_name &&
368 !strcmp(key, "url"))
369 die(_("remote URLs cannot be configured in file directly or indirectly included by includeIf.hasconfig:remote.*.url"));
370 return 0;
371 }
372
373 static int at_least_one_url_matches_glob(const char *glob, int glob_len,
374 struct string_list *remote_urls)
375 {
376 struct strbuf pattern = STRBUF_INIT;
377 struct string_list_item *url_item;
378 int found = 0;
379
380 strbuf_add(&pattern, glob, glob_len);
381 for_each_string_list_item(url_item, remote_urls) {
382 if (!wildmatch(pattern.buf, url_item->string, WM_PATHNAME)) {
383 found = 1;
384 break;
385 }
386 }
387 strbuf_release(&pattern);
388 return found;
389 }
390
391 static int include_by_remote_url(struct config_include_data *inc,
392 const char *cond, size_t cond_len)
393 {
394 if (inc->opts->unconditional_remote_url)
395 return 1;
396 if (!inc->remote_urls)
397 populate_remote_urls(inc);
398 return at_least_one_url_matches_glob(cond, cond_len,
399 inc->remote_urls);
400 }
401
402 static int include_condition_is_true(const struct key_value_info *kvi,
403 struct config_include_data *inc,
404 const char *cond, size_t cond_len)
405 {
406 const struct config_options *opts = inc->opts;
407
408 if (skip_prefix_mem(cond, cond_len, "gitdir:", &cond, &cond_len))
409 return include_by_gitdir(kvi, opts, cond, cond_len, 0);
410 else if (skip_prefix_mem(cond, cond_len, "gitdir/i:", &cond, &cond_len))
411 return include_by_gitdir(kvi, opts, cond, cond_len, 1);
412 else if (skip_prefix_mem(cond, cond_len, "onbranch:", &cond, &cond_len))
413 return include_by_branch(inc, cond, cond_len);
414 else if (skip_prefix_mem(cond, cond_len, "hasconfig:remote.*.url:", &cond,
415 &cond_len))
416 return include_by_remote_url(inc, cond, cond_len);
417
418 /* unknown conditionals are always false */
419 return 0;
420 }
421
422 static int git_config_include(const char *var, const char *value,
423 const struct config_context *ctx,
424 void *data)
425 {
426 struct config_include_data *inc = data;
427 const char *cond, *key;
428 size_t cond_len;
429 int ret;
430
431 /*
432 * Pass along all values, including "include" directives; this makes it
433 * possible to query information on the includes themselves.
434 */
435 ret = inc->fn(var, value, ctx, inc->data);
436 if (ret < 0)
437 return ret;
438
439 if (!strcmp(var, "include.path"))
440 ret = handle_path_include(ctx->kvi, value, inc);
441
442 if (!parse_config_key(var, "includeif", &cond, &cond_len, &key) &&
443 cond && include_condition_is_true(ctx->kvi, inc, cond, cond_len) &&
444 !strcmp(key, "path")) {
445 config_fn_t old_fn = inc->fn;
446
447 if (inc->opts->unconditional_remote_url)
448 inc->fn = forbid_remote_url;
449 ret = handle_path_include(ctx->kvi, value, inc);
450 inc->fn = old_fn;
451 }
452
453 return ret;
454 }
455
456 static void git_config_push_split_parameter(const char *key, const char *value)
457 {
458 struct strbuf env = STRBUF_INIT;
459 const char *old = getenv(CONFIG_DATA_ENVIRONMENT);
460 if (old && *old) {
461 strbuf_addstr(&env, old);
462 strbuf_addch(&env, ' ');
463 }
464 sq_quote_buf(&env, key);
465 strbuf_addch(&env, '=');
466 if (value)
467 sq_quote_buf(&env, value);
468 setenv(CONFIG_DATA_ENVIRONMENT, env.buf, 1);
469 strbuf_release(&env);
470 }
471
472 void git_config_push_parameter(const char *text)
473 {
474 const char *value;
475
476 /*
477 * When we see:
478 *
479 * section.subsection=with=equals.key=value
480 *
481 * we cannot tell if it means:
482 *
483 * [section "subsection=with=equals"]
484 * key = value
485 *
486 * or:
487 *
488 * [section]
489 * subsection = with=equals.key=value
490 *
491 * We parse left-to-right for the first "=", meaning we'll prefer to
492 * keep the value intact over the subsection. This is historical, but
493 * also sensible since values are more likely to contain odd or
494 * untrusted input than a section name.
495 *
496 * A missing equals is explicitly allowed (as a bool-only entry).
497 */
498 value = strchr(text, '=');
499 if (value) {
500 char *key = xmemdupz(text, value - text);
501 git_config_push_split_parameter(key, value + 1);
502 free(key);
503 } else {
504 git_config_push_split_parameter(text, NULL);
505 }
506 }
507
508 void git_config_push_env(const char *spec)
509 {
510 char *key;
511 const char *env_name;
512 const char *env_value;
513
514 env_name = strrchr(spec, '=');
515 if (!env_name)
516 die(_("invalid config format: %s"), spec);
517 key = xmemdupz(spec, env_name - spec);
518 env_name++;
519 if (!*env_name)
520 die(_("missing environment variable name for configuration '%.*s'"),
521 (int)(env_name - spec - 1), spec);
522
523 env_value = getenv(env_name);
524 if (!env_value)
525 die(_("missing environment variable '%s' for configuration '%.*s'"),
526 env_name, (int)(env_name - spec - 1), spec);
527
528 git_config_push_split_parameter(key, env_value);
529 free(key);
530 }
531
532 static inline int iskeychar(int c)
533 {
534 return isalnum(c) || c == '-';
535 }
536
537 /*
538 * Auxiliary function to sanity-check and split the key into the section
539 * identifier and variable name.
540 *
541 * Returns 0 on success, -1 when there is an invalid character in the key and
542 * -2 if there is no section name in the key.
543 *
544 * store_key - pointer to char* which will hold a copy of the key with
545 * lowercase section and variable name
546 * baselen - pointer to size_t which will hold the length of the
547 * section + subsection part, can be NULL
548 */
549 int git_config_parse_key(const char *key, char **store_key, size_t *baselen_)
550 {
551 size_t i, baselen;
552 int dot;
553 const char *last_dot = strrchr(key, '.');
554
555 /*
556 * Since "key" actually contains the section name and the real
557 * key name separated by a dot, we have to know where the dot is.
558 */
559
560 if (last_dot == NULL || last_dot == key) {
561 error(_("key does not contain a section: %s"), key);
562 return -CONFIG_NO_SECTION_OR_NAME;
563 }
564
565 if (!last_dot[1]) {
566 error(_("key does not contain variable name: %s"), key);
567 return -CONFIG_NO_SECTION_OR_NAME;
568 }
569
570 baselen = last_dot - key;
571 if (baselen_)
572 *baselen_ = baselen;
573
574 /*
575 * Validate the key and while at it, lower case it for matching.
576 */
577 *store_key = xmallocz(strlen(key));
578
579 dot = 0;
580 for (i = 0; key[i]; i++) {
581 unsigned char c = key[i];
582 if (c == '.')
583 dot = 1;
584 /* Leave the extended basename untouched.. */
585 if (!dot || i > baselen) {
586 if (!iskeychar(c) ||
587 (i == baselen + 1 && !isalpha(c))) {
588 error(_("invalid key: %s"), key);
589 goto out_free_ret_1;
590 }
591 c = tolower(c);
592 } else if (c == '\n') {
593 error(_("invalid key (newline): %s"), key);
594 goto out_free_ret_1;
595 }
596 (*store_key)[i] = c;
597 }
598
599 return 0;
600
601 out_free_ret_1:
602 FREE_AND_NULL(*store_key);
603 return -CONFIG_INVALID_KEY;
604 }
605
606 static int config_parse_pair(const char *key, const char *value,
607 struct key_value_info *kvi,
608 config_fn_t fn, void *data)
609 {
610 char *canonical_name;
611 int ret;
612 struct config_context ctx = {
613 .kvi = kvi,
614 };
615
616 if (!strlen(key))
617 return error(_("empty config key"));
618 if (git_config_parse_key(key, &canonical_name, NULL))
619 return -1;
620
621 ret = (fn(canonical_name, value, &ctx, data) < 0) ? -1 : 0;
622 free(canonical_name);
623 return ret;
624 }
625
626
627 /* for values read from `git_config_from_parameters()` */
628 void kvi_from_param(struct key_value_info *out)
629 {
630 out->filename = NULL;
631 out->linenr = -1;
632 out->origin_type = CONFIG_ORIGIN_CMDLINE;
633 out->scope = CONFIG_SCOPE_COMMAND;
634 out->path = NULL;
635 }
636
637 int git_config_parse_parameter(const char *text,
638 config_fn_t fn, void *data)
639 {
640 const char *value;
641 struct strbuf **pair;
642 int ret;
643 struct key_value_info kvi = KVI_INIT;
644
645 kvi_from_param(&kvi);
646
647 pair = strbuf_split_str(text, '=', 2);
648 if (!pair[0])
649 return error(_("bogus config parameter: %s"), text);
650
651 if (pair[0]->len && pair[0]->buf[pair[0]->len - 1] == '=') {
652 strbuf_setlen(pair[0], pair[0]->len - 1);
653 value = pair[1] ? pair[1]->buf : "";
654 } else {
655 value = NULL;
656 }
657
658 strbuf_trim(pair[0]);
659 if (!pair[0]->len) {
660 strbuf_list_free(pair);
661 return error(_("bogus config parameter: %s"), text);
662 }
663
664 ret = config_parse_pair(pair[0]->buf, value, &kvi, fn, data);
665 strbuf_list_free(pair);
666 return ret;
667 }
668
669 static int parse_config_env_list(char *env, struct key_value_info *kvi,
670 config_fn_t fn, void *data)
671 {
672 char *cur = env;
673 while (cur && *cur) {
674 const char *key = sq_dequote_step(cur, &cur);
675 if (!key)
676 return error(_("bogus format in %s"),
677 CONFIG_DATA_ENVIRONMENT);
678
679 if (!cur || isspace(*cur)) {
680 /* old-style 'key=value' */
681 if (git_config_parse_parameter(key, fn, data) < 0)
682 return -1;
683 }
684 else if (*cur == '=') {
685 /* new-style 'key'='value' */
686 const char *value;
687
688 cur++;
689 if (*cur == '\'') {
690 /* quoted value */
691 value = sq_dequote_step(cur, &cur);
692 if (!value || (cur && !isspace(*cur))) {
693 return error(_("bogus format in %s"),
694 CONFIG_DATA_ENVIRONMENT);
695 }
696 } else if (!*cur || isspace(*cur)) {
697 /* implicit bool: 'key'= */
698 value = NULL;
699 } else {
700 return error(_("bogus format in %s"),
701 CONFIG_DATA_ENVIRONMENT);
702 }
703
704 if (config_parse_pair(key, value, kvi, fn, data) < 0)
705 return -1;
706 }
707 else {
708 /* unknown format */
709 return error(_("bogus format in %s"),
710 CONFIG_DATA_ENVIRONMENT);
711 }
712
713 if (cur) {
714 while (isspace(*cur))
715 cur++;
716 }
717 }
718 return 0;
719 }
720
721 int git_config_from_parameters(config_fn_t fn, void *data)
722 {
723 const char *env;
724 struct strbuf envvar = STRBUF_INIT;
725 struct strvec to_free = STRVEC_INIT;
726 int ret = 0;
727 char *envw = NULL;
728 struct key_value_info kvi = KVI_INIT;
729
730 kvi_from_param(&kvi);
731 env = getenv(CONFIG_COUNT_ENVIRONMENT);
732 if (env) {
733 unsigned long count;
734 char *endp;
735 int i;
736
737 count = strtoul(env, &endp, 10);
738 if (*endp) {
739 ret = error(_("bogus count in %s"), CONFIG_COUNT_ENVIRONMENT);
740 goto out;
741 }
742 if (count > INT_MAX) {
743 ret = error(_("too many entries in %s"), CONFIG_COUNT_ENVIRONMENT);
744 goto out;
745 }
746
747 for (i = 0; i < count; i++) {
748 const char *key, *value;
749
750 strbuf_addf(&envvar, "GIT_CONFIG_KEY_%d", i);
751 key = getenv_safe(&to_free, envvar.buf);
752 if (!key) {
753 ret = error(_("missing config key %s"), envvar.buf);
754 goto out;
755 }
756 strbuf_reset(&envvar);
757
758 strbuf_addf(&envvar, "GIT_CONFIG_VALUE_%d", i);
759 value = getenv_safe(&to_free, envvar.buf);
760 if (!value) {
761 ret = error(_("missing config value %s"), envvar.buf);
762 goto out;
763 }
764 strbuf_reset(&envvar);
765
766 if (config_parse_pair(key, value, &kvi, fn, data) < 0) {
767 ret = -1;
768 goto out;
769 }
770 }
771 }
772
773 env = getenv(CONFIG_DATA_ENVIRONMENT);
774 if (env) {
775 /* sq_dequote will write over it */
776 envw = xstrdup(env);
777 if (parse_config_env_list(envw, &kvi, fn, data) < 0) {
778 ret = -1;
779 goto out;
780 }
781 }
782
783 out:
784 strbuf_release(&envvar);
785 strvec_clear(&to_free);
786 free(envw);
787 return ret;
788 }
789
790 static int get_next_char(struct config_source *cs)
791 {
792 int c = cs->do_fgetc(cs);
793
794 if (c == '\r') {
795 /* DOS like systems */
796 c = cs->do_fgetc(cs);
797 if (c != '\n') {
798 if (c != EOF)
799 cs->do_ungetc(c, cs);
800 c = '\r';
801 }
802 }
803
804 if (c != EOF && ++cs->total_len > INT_MAX) {
805 /*
806 * This is an absurdly long config file; refuse to parse
807 * further in order to protect downstream code from integer
808 * overflows. Note that we can't return an error specifically,
809 * but we can mark EOF and put trash in the return value,
810 * which will trigger a parse error.
811 */
812 cs->eof = 1;
813 return 0;
814 }
815
816 if (c == '\n')
817 cs->linenr++;
818 if (c == EOF) {
819 cs->eof = 1;
820 cs->linenr++;
821 c = '\n';
822 }
823 return c;
824 }
825
826 static char *parse_value(struct config_source *cs)
827 {
828 int quote = 0, comment = 0;
829 size_t trim_len = 0;
830
831 strbuf_reset(&cs->value);
832 for (;;) {
833 int c = get_next_char(cs);
834 if (c == '\n') {
835 if (quote) {
836 cs->linenr--;
837 return NULL;
838 }
839 if (trim_len)
840 strbuf_setlen(&cs->value, trim_len);
841 return cs->value.buf;
842 }
843 if (comment)
844 continue;
845 if (isspace(c) && !quote) {
846 if (!trim_len)
847 trim_len = cs->value.len;
848 if (cs->value.len)
849 strbuf_addch(&cs->value, c);
850 continue;
851 }
852 if (!quote) {
853 if (c == ';' || c == '#') {
854 comment = 1;
855 continue;
856 }
857 }
858 if (trim_len)
859 trim_len = 0;
860 if (c == '\\') {
861 c = get_next_char(cs);
862 switch (c) {
863 case '\n':
864 continue;
865 case 't':
866 c = '\t';
867 break;
868 case 'b':
869 c = '\b';
870 break;
871 case 'n':
872 c = '\n';
873 break;
874 /* Some characters escape as themselves */
875 case '\\': case '"':
876 break;
877 /* Reject unknown escape sequences */
878 default:
879 return NULL;
880 }
881 strbuf_addch(&cs->value, c);
882 continue;
883 }
884 if (c == '"') {
885 quote = 1 - quote;
886 continue;
887 }
888 strbuf_addch(&cs->value, c);
889 }
890 }
891
892 static int get_value(struct config_source *cs, struct key_value_info *kvi,
893 config_fn_t fn, void *data, struct strbuf *name)
894 {
895 int c;
896 char *value;
897 int ret;
898 struct config_context ctx = {
899 .kvi = kvi,
900 };
901
902 /* Get the full name */
903 for (;;) {
904 c = get_next_char(cs);
905 if (cs->eof)
906 break;
907 if (!iskeychar(c))
908 break;
909 strbuf_addch(name, tolower(c));
910 }
911
912 while (c == ' ' || c == '\t')
913 c = get_next_char(cs);
914
915 value = NULL;
916 if (c != '\n') {
917 if (c != '=')
918 return -1;
919 value = parse_value(cs);
920 if (!value)
921 return -1;
922 }
923 /*
924 * We already consumed the \n, but we need linenr to point to
925 * the line we just parsed during the call to fn to get
926 * accurate line number in error messages.
927 */
928 cs->linenr--;
929 kvi->linenr = cs->linenr;
930 ret = fn(name->buf, value, &ctx, data);
931 if (ret >= 0)
932 cs->linenr++;
933 return ret;
934 }
935
936 static int get_extended_base_var(struct config_source *cs, struct strbuf *name,
937 int c)
938 {
939 cs->subsection_case_sensitive = 0;
940 do {
941 if (c == '\n')
942 goto error_incomplete_line;
943 c = get_next_char(cs);
944 } while (isspace(c));
945
946 /* We require the format to be '[base "extension"]' */
947 if (c != '"')
948 return -1;
949 strbuf_addch(name, '.');
950
951 for (;;) {
952 int c = get_next_char(cs);
953 if (c == '\n')
954 goto error_incomplete_line;
955 if (c == '"')
956 break;
957 if (c == '\\') {
958 c = get_next_char(cs);
959 if (c == '\n')
960 goto error_incomplete_line;
961 }
962 strbuf_addch(name, c);
963 }
964
965 /* Final ']' */
966 if (get_next_char(cs) != ']')
967 return -1;
968 return 0;
969 error_incomplete_line:
970 cs->linenr--;
971 return -1;
972 }
973
974 static int get_base_var(struct config_source *cs, struct strbuf *name)
975 {
976 cs->subsection_case_sensitive = 1;
977 for (;;) {
978 int c = get_next_char(cs);
979 if (cs->eof)
980 return -1;
981 if (c == ']')
982 return 0;
983 if (isspace(c))
984 return get_extended_base_var(cs, name, c);
985 if (!iskeychar(c) && c != '.')
986 return -1;
987 strbuf_addch(name, tolower(c));
988 }
989 }
990
991 struct parse_event_data {
992 enum config_event_t previous_type;
993 size_t previous_offset;
994 const struct config_options *opts;
995 };
996
997 static int do_event(struct config_source *cs, enum config_event_t type,
998 struct parse_event_data *data)
999 {
1000 size_t offset;
1001
1002 if (!data->opts || !data->opts->event_fn)
1003 return 0;
1004
1005 if (type == CONFIG_EVENT_WHITESPACE &&
1006 data->previous_type == type)
1007 return 0;
1008
1009 offset = cs->do_ftell(cs);
1010 /*
1011 * At EOF, the parser always "inserts" an extra '\n', therefore
1012 * the end offset of the event is the current file position, otherwise
1013 * we will already have advanced to the next event.
1014 */
1015 if (type != CONFIG_EVENT_EOF)
1016 offset--;
1017
1018 if (data->previous_type != CONFIG_EVENT_EOF &&
1019 data->opts->event_fn(data->previous_type, data->previous_offset,
1020 offset, cs, data->opts->event_fn_data) < 0)
1021 return -1;
1022
1023 data->previous_type = type;
1024 data->previous_offset = offset;
1025
1026 return 0;
1027 }
1028
1029 static void kvi_from_source(struct config_source *cs,
1030 enum config_scope scope,
1031 struct key_value_info *out)
1032 {
1033 out->filename = strintern(cs->name);
1034 out->origin_type = cs->origin_type;
1035 out->linenr = cs->linenr;
1036 out->scope = scope;
1037 out->path = cs->path;
1038 }
1039
1040 static int git_parse_source(struct config_source *cs, config_fn_t fn,
1041 struct key_value_info *kvi, void *data,
1042 const struct config_options *opts)
1043 {
1044 int comment = 0;
1045 size_t baselen = 0;
1046 struct strbuf *var = &cs->var;
1047 int error_return = 0;
1048 char *error_msg = NULL;
1049
1050 /* U+FEFF Byte Order Mark in UTF8 */
1051 const char *bomptr = utf8_bom;
1052
1053 /* For the parser event callback */
1054 struct parse_event_data event_data = {
1055 CONFIG_EVENT_EOF, 0, opts
1056 };
1057
1058 for (;;) {
1059 int c;
1060
1061 c = get_next_char(cs);
1062 if (bomptr && *bomptr) {
1063 /* We are at the file beginning; skip UTF8-encoded BOM
1064 * if present. Sane editors won't put this in on their
1065 * own, but e.g. Windows Notepad will do it happily. */
1066 if (c == (*bomptr & 0377)) {
1067 bomptr++;
1068 continue;
1069 } else {
1070 /* Do not tolerate partial BOM. */
1071 if (bomptr != utf8_bom)
1072 break;
1073 /* No BOM at file beginning. Cool. */
1074 bomptr = NULL;
1075 }
1076 }
1077 if (c == '\n') {
1078 if (cs->eof) {
1079 if (do_event(cs, CONFIG_EVENT_EOF, &event_data) < 0)
1080 return -1;
1081 return 0;
1082 }
1083 if (do_event(cs, CONFIG_EVENT_WHITESPACE, &event_data) < 0)
1084 return -1;
1085 comment = 0;
1086 continue;
1087 }
1088 if (comment)
1089 continue;
1090 if (isspace(c)) {
1091 if (do_event(cs, CONFIG_EVENT_WHITESPACE, &event_data) < 0)
1092 return -1;
1093 continue;
1094 }
1095 if (c == '#' || c == ';') {
1096 if (do_event(cs, CONFIG_EVENT_COMMENT, &event_data) < 0)
1097 return -1;
1098 comment = 1;
1099 continue;
1100 }
1101 if (c == '[') {
1102 if (do_event(cs, CONFIG_EVENT_SECTION, &event_data) < 0)
1103 return -1;
1104
1105 /* Reset prior to determining a new stem */
1106 strbuf_reset(var);
1107 if (get_base_var(cs, var) < 0 || var->len < 1)
1108 break;
1109 strbuf_addch(var, '.');
1110 baselen = var->len;
1111 continue;
1112 }
1113 if (!isalpha(c))
1114 break;
1115
1116 if (do_event(cs, CONFIG_EVENT_ENTRY, &event_data) < 0)
1117 return -1;
1118
1119 /*
1120 * Truncate the var name back to the section header
1121 * stem prior to grabbing the suffix part of the name
1122 * and the value.
1123 */
1124 strbuf_setlen(var, baselen);
1125 strbuf_addch(var, tolower(c));
1126 if (get_value(cs, kvi, fn, data, var) < 0)
1127 break;
1128 }
1129
1130 if (do_event(cs, CONFIG_EVENT_ERROR, &event_data) < 0)
1131 return -1;
1132
1133 switch (cs->origin_type) {
1134 case CONFIG_ORIGIN_BLOB:
1135 error_msg = xstrfmt(_("bad config line %d in blob %s"),
1136 cs->linenr, cs->name);
1137 break;
1138 case CONFIG_ORIGIN_FILE:
1139 error_msg = xstrfmt(_("bad config line %d in file %s"),
1140 cs->linenr, cs->name);
1141 break;
1142 case CONFIG_ORIGIN_STDIN:
1143 error_msg = xstrfmt(_("bad config line %d in standard input"),
1144 cs->linenr);
1145 break;
1146 case CONFIG_ORIGIN_SUBMODULE_BLOB:
1147 error_msg = xstrfmt(_("bad config line %d in submodule-blob %s"),
1148 cs->linenr, cs->name);
1149 break;
1150 case CONFIG_ORIGIN_CMDLINE:
1151 error_msg = xstrfmt(_("bad config line %d in command line %s"),
1152 cs->linenr, cs->name);
1153 break;
1154 default:
1155 error_msg = xstrfmt(_("bad config line %d in %s"),
1156 cs->linenr, cs->name);
1157 }
1158
1159 switch (opts && opts->error_action ?
1160 opts->error_action :
1161 cs->default_error_action) {
1162 case CONFIG_ERROR_DIE:
1163 die("%s", error_msg);
1164 break;
1165 case CONFIG_ERROR_ERROR:
1166 error_return = error("%s", error_msg);
1167 break;
1168 case CONFIG_ERROR_SILENT:
1169 error_return = -1;
1170 break;
1171 case CONFIG_ERROR_UNSET:
1172 BUG("config error action unset");
1173 }
1174
1175 free(error_msg);
1176 return error_return;
1177 }
1178
1179 NORETURN
1180 static void die_bad_number(const char *name, const char *value,
1181 const struct key_value_info *kvi)
1182 {
1183 const char *error_type = (errno == ERANGE) ?
1184 N_("out of range") : N_("invalid unit");
1185 const char *bad_numeric = N_("bad numeric config value '%s' for '%s': %s");
1186
1187 if (!kvi)
1188 BUG("kvi should not be NULL");
1189
1190 if (!value)
1191 value = "";
1192
1193 if (!kvi->filename)
1194 die(_(bad_numeric), value, name, _(error_type));
1195
1196 switch (kvi->origin_type) {
1197 case CONFIG_ORIGIN_BLOB:
1198 die(_("bad numeric config value '%s' for '%s' in blob %s: %s"),
1199 value, name, kvi->filename, _(error_type));
1200 case CONFIG_ORIGIN_FILE:
1201 die(_("bad numeric config value '%s' for '%s' in file %s: %s"),
1202 value, name, kvi->filename, _(error_type));
1203 case CONFIG_ORIGIN_STDIN:
1204 die(_("bad numeric config value '%s' for '%s' in standard input: %s"),
1205 value, name, _(error_type));
1206 case CONFIG_ORIGIN_SUBMODULE_BLOB:
1207 die(_("bad numeric config value '%s' for '%s' in submodule-blob %s: %s"),
1208 value, name, kvi->filename, _(error_type));
1209 case CONFIG_ORIGIN_CMDLINE:
1210 die(_("bad numeric config value '%s' for '%s' in command line %s: %s"),
1211 value, name, kvi->filename, _(error_type));
1212 default:
1213 die(_("bad numeric config value '%s' for '%s' in %s: %s"),
1214 value, name, kvi->filename, _(error_type));
1215 }
1216 }
1217
1218 int git_config_int(const char *name, const char *value,
1219 const struct key_value_info *kvi)
1220 {
1221 int ret;
1222 if (!git_parse_int(value, &ret))
1223 die_bad_number(name, value, kvi);
1224 return ret;
1225 }
1226
1227 int64_t git_config_int64(const char *name, const char *value,
1228 const struct key_value_info *kvi)
1229 {
1230 int64_t ret;
1231 if (!git_parse_int64(value, &ret))
1232 die_bad_number(name, value, kvi);
1233 return ret;
1234 }
1235
1236 unsigned long git_config_ulong(const char *name, const char *value,
1237 const struct key_value_info *kvi)
1238 {
1239 unsigned long ret;
1240 if (!git_parse_ulong(value, &ret))
1241 die_bad_number(name, value, kvi);
1242 return ret;
1243 }
1244
1245 ssize_t git_config_ssize_t(const char *name, const char *value,
1246 const struct key_value_info *kvi)
1247 {
1248 ssize_t ret;
1249 if (!git_parse_ssize_t(value, &ret))
1250 die_bad_number(name, value, kvi);
1251 return ret;
1252 }
1253
1254 double git_config_double(const char *name, const char *value,
1255 const struct key_value_info *kvi)
1256 {
1257 double ret;
1258 if (!git_parse_double(value, &ret))
1259 die_bad_number(name, value, kvi);
1260 return ret;
1261 }
1262
1263 static const struct fsync_component_name {
1264 const char *name;
1265 enum fsync_component component_bits;
1266 } fsync_component_names[] = {
1267 { "loose-object", FSYNC_COMPONENT_LOOSE_OBJECT },
1268 { "pack", FSYNC_COMPONENT_PACK },
1269 { "pack-metadata", FSYNC_COMPONENT_PACK_METADATA },
1270 { "commit-graph", FSYNC_COMPONENT_COMMIT_GRAPH },
1271 { "index", FSYNC_COMPONENT_INDEX },
1272 { "objects", FSYNC_COMPONENTS_OBJECTS },
1273 { "reference", FSYNC_COMPONENT_REFERENCE },
1274 { "derived-metadata", FSYNC_COMPONENTS_DERIVED_METADATA },
1275 { "committed", FSYNC_COMPONENTS_COMMITTED },
1276 { "added", FSYNC_COMPONENTS_ADDED },
1277 { "all", FSYNC_COMPONENTS_ALL },
1278 };
1279
1280 static enum fsync_component parse_fsync_components(const char *var, const char *string)
1281 {
1282 enum fsync_component current = FSYNC_COMPONENTS_PLATFORM_DEFAULT;
1283 enum fsync_component positive = 0, negative = 0;
1284
1285 while (string) {
1286 int i;
1287 size_t len;
1288 const char *ep;
1289 int negated = 0;
1290 int found = 0;
1291
1292 string = string + strspn(string, ", \t\n\r");
1293 ep = strchrnul(string, ',');
1294 len = ep - string;
1295 if (!strcmp(string, "none")) {
1296 current = FSYNC_COMPONENT_NONE;
1297 goto next_name;
1298 }
1299
1300 if (*string == '-') {
1301 negated = 1;
1302 string++;
1303 len--;
1304 if (!len)
1305 warning(_("invalid value for variable %s"), var);
1306 }
1307
1308 if (!len)
1309 break;
1310
1311 for (i = 0; i < ARRAY_SIZE(fsync_component_names); ++i) {
1312 const struct fsync_component_name *n = &fsync_component_names[i];
1313
1314 if (strncmp(n->name, string, len))
1315 continue;
1316
1317 found = 1;
1318 if (negated)
1319 negative |= n->component_bits;
1320 else
1321 positive |= n->component_bits;
1322 }
1323
1324 if (!found) {
1325 char *component = xstrndup(string, len);
1326 warning(_("ignoring unknown core.fsync component '%s'"), component);
1327 free(component);
1328 }
1329
1330 next_name:
1331 string = ep;
1332 }
1333
1334 return (current & ~negative) | positive;
1335 }
1336
1337 int git_config_bool_or_int(const char *name, const char *value,
1338 const struct key_value_info *kvi, int *is_bool)
1339 {
1340 int v = git_parse_maybe_bool_text(value);
1341 if (0 <= v) {
1342 *is_bool = 1;
1343 return v;
1344 }
1345 *is_bool = 0;
1346 return git_config_int(name, value, kvi);
1347 }
1348
1349 int git_config_bool(const char *name, const char *value)
1350 {
1351 int v = git_parse_maybe_bool(value);
1352 if (v < 0)
1353 die(_("bad boolean config value '%s' for '%s'"), value, name);
1354 return v;
1355 }
1356
1357 int git_config_string(char **dest, const char *var, const char *value)
1358 {
1359 if (!value)
1360 return config_error_nonbool(var);
1361 *dest = xstrdup(value);
1362 return 0;
1363 }
1364
1365 int git_config_pathname(char **dest, const char *var, const char *value)
1366 {
1367 if (!value)
1368 return config_error_nonbool(var);
1369 *dest = interpolate_path(value, 0);
1370 if (!*dest)
1371 die(_("failed to expand user dir in: '%s'"), value);
1372 return 0;
1373 }
1374
1375 int git_config_expiry_date(timestamp_t *timestamp, const char *var, const char *value)
1376 {
1377 if (!value)
1378 return config_error_nonbool(var);
1379 if (parse_expiry_date(value, timestamp))
1380 return error(_("'%s' for '%s' is not a valid timestamp"),
1381 value, var);
1382 return 0;
1383 }
1384
1385 int git_config_color(char *dest, const char *var, const char *value)
1386 {
1387 if (!value)
1388 return config_error_nonbool(var);
1389 if (color_parse(value, dest) < 0)
1390 return -1;
1391 return 0;
1392 }
1393
1394 static int git_default_core_config(const char *var, const char *value,
1395 const struct config_context *ctx, void *cb)
1396 {
1397 /* This needs a better name */
1398 if (!strcmp(var, "core.filemode")) {
1399 trust_executable_bit = git_config_bool(var, value);
1400 return 0;
1401 }
1402 if (!strcmp(var, "core.trustctime")) {
1403 trust_ctime = git_config_bool(var, value);
1404 return 0;
1405 }
1406 if (!strcmp(var, "core.checkstat")) {
1407 if (!value)
1408 return config_error_nonbool(var);
1409 if (!strcasecmp(value, "default"))
1410 check_stat = 1;
1411 else if (!strcasecmp(value, "minimal"))
1412 check_stat = 0;
1413 else
1414 return error(_("invalid value for '%s': '%s'"),
1415 var, value);
1416 }
1417
1418 if (!strcmp(var, "core.quotepath")) {
1419 quote_path_fully = git_config_bool(var, value);
1420 return 0;
1421 }
1422
1423 if (!strcmp(var, "core.symlinks")) {
1424 has_symlinks = git_config_bool(var, value);
1425 return 0;
1426 }
1427
1428 if (!strcmp(var, "core.ignorecase")) {
1429 ignore_case = git_config_bool(var, value);
1430 return 0;
1431 }
1432
1433 if (!strcmp(var, "core.attributesfile")) {
1434 FREE_AND_NULL(git_attributes_file);
1435 return git_config_pathname(&git_attributes_file, var, value);
1436 }
1437
1438 if (!strcmp(var, "core.hookspath")) {
1439 FREE_AND_NULL(git_hooks_path);
1440 return git_config_pathname(&git_hooks_path, var, value);
1441 }
1442
1443 if (!strcmp(var, "core.bare")) {
1444 is_bare_repository_cfg = git_config_bool(var, value);
1445 return 0;
1446 }
1447
1448 if (!strcmp(var, "core.ignorestat")) {
1449 assume_unchanged = git_config_bool(var, value);
1450 return 0;
1451 }
1452
1453 if (!strcmp(var, "core.abbrev")) {
1454 if (!value)
1455 return config_error_nonbool(var);
1456 if (!strcasecmp(value, "auto"))
1457 default_abbrev = -1;
1458 else if (!git_parse_maybe_bool_text(value))
1459 default_abbrev = GIT_MAX_HEXSZ;
1460 else {
1461 int abbrev = git_config_int(var, value, ctx->kvi);
1462 if (abbrev < minimum_abbrev)
1463 return error(_("abbrev length out of range: %d"), abbrev);
1464 default_abbrev = abbrev;
1465 }
1466 return 0;
1467 }
1468
1469 if (!strcmp(var, "core.disambiguate"))
1470 return set_disambiguate_hint_config(var, value);
1471
1472 if (!strcmp(var, "core.loosecompression")) {
1473 int level = git_config_int(var, value, ctx->kvi);
1474 if (level == -1)
1475 level = Z_DEFAULT_COMPRESSION;
1476 else if (level < 0 || level > Z_BEST_COMPRESSION)
1477 die(_("bad zlib compression level %d"), level);
1478 zlib_compression_level = level;
1479 zlib_compression_seen = 1;
1480 return 0;
1481 }
1482
1483 if (!strcmp(var, "core.compression")) {
1484 int level = git_config_int(var, value, ctx->kvi);
1485 if (level == -1)
1486 level = Z_DEFAULT_COMPRESSION;
1487 else if (level < 0 || level > Z_BEST_COMPRESSION)
1488 die(_("bad zlib compression level %d"), level);
1489 if (!zlib_compression_seen)
1490 zlib_compression_level = level;
1491 if (!pack_compression_seen)
1492 pack_compression_level = level;
1493 return 0;
1494 }
1495
1496 if (!strcmp(var, "core.packedgitwindowsize")) {
1497 int pgsz_x2 = getpagesize() * 2;
1498 packed_git_window_size = git_config_ulong(var, value, ctx->kvi);
1499
1500 /* This value must be multiple of (pagesize * 2) */
1501 packed_git_window_size /= pgsz_x2;
1502 if (packed_git_window_size < 1)
1503 packed_git_window_size = 1;
1504 packed_git_window_size *= pgsz_x2;
1505 return 0;
1506 }
1507
1508 if (!strcmp(var, "core.bigfilethreshold")) {
1509 big_file_threshold = git_config_ulong(var, value, ctx->kvi);
1510 return 0;
1511 }
1512
1513 if (!strcmp(var, "core.packedgitlimit")) {
1514 packed_git_limit = git_config_ulong(var, value, ctx->kvi);
1515 return 0;
1516 }
1517
1518 if (!strcmp(var, "core.deltabasecachelimit")) {
1519 delta_base_cache_limit = git_config_ulong(var, value, ctx->kvi);
1520 return 0;
1521 }
1522
1523 if (!strcmp(var, "core.autocrlf")) {
1524 if (value && !strcasecmp(value, "input")) {
1525 auto_crlf = AUTO_CRLF_INPUT;
1526 return 0;
1527 }
1528 auto_crlf = git_config_bool(var, value);
1529 return 0;
1530 }
1531
1532 if (!strcmp(var, "core.safecrlf")) {
1533 int eol_rndtrp_die;
1534 if (value && !strcasecmp(value, "warn")) {
1535 global_conv_flags_eol = CONV_EOL_RNDTRP_WARN;
1536 return 0;
1537 }
1538 eol_rndtrp_die = git_config_bool(var, value);
1539 global_conv_flags_eol = eol_rndtrp_die ?
1540 CONV_EOL_RNDTRP_DIE : 0;
1541 return 0;
1542 }
1543
1544 if (!strcmp(var, "core.eol")) {
1545 if (value && !strcasecmp(value, "lf"))
1546 core_eol = EOL_LF;
1547 else if (value && !strcasecmp(value, "crlf"))
1548 core_eol = EOL_CRLF;
1549 else if (value && !strcasecmp(value, "native"))
1550 core_eol = EOL_NATIVE;
1551 else
1552 core_eol = EOL_UNSET;
1553 return 0;
1554 }
1555
1556 if (!strcmp(var, "core.checkroundtripencoding")) {
1557 FREE_AND_NULL(check_roundtrip_encoding);
1558 return git_config_string(&check_roundtrip_encoding, var, value);
1559 }
1560
1561 if (!strcmp(var, "core.editor")) {
1562 FREE_AND_NULL(editor_program);
1563 return git_config_string(&editor_program, var, value);
1564 }
1565
1566 if (!strcmp(var, "core.commentchar") ||
1567 !strcmp(var, "core.commentstring")) {
1568 if (!value)
1569 return config_error_nonbool(var);
1570 else if (!strcasecmp(value, "auto"))
1571 auto_comment_line_char = 1;
1572 else if (value[0]) {
1573 if (strchr(value, '\n'))
1574 return error(_("%s cannot contain newline"), var);
1575 comment_line_str = value;
1576 FREE_AND_NULL(comment_line_str_to_free);
1577 auto_comment_line_char = 0;
1578 } else
1579 return error(_("%s must have at least one character"), var);
1580 return 0;
1581 }
1582
1583 if (!strcmp(var, "core.askpass")) {
1584 FREE_AND_NULL(askpass_program);
1585 return git_config_string(&askpass_program, var, value);
1586 }
1587
1588 if (!strcmp(var, "core.excludesfile")) {
1589 FREE_AND_NULL(excludes_file);
1590 return git_config_pathname(&excludes_file, var, value);
1591 }
1592
1593 if (!strcmp(var, "core.whitespace")) {
1594 if (!value)
1595 return config_error_nonbool(var);
1596 whitespace_rule_cfg = parse_whitespace_rule(value);
1597 return 0;
1598 }
1599
1600 if (!strcmp(var, "core.fsync")) {
1601 if (!value)
1602 return config_error_nonbool(var);
1603 fsync_components = parse_fsync_components(var, value);
1604 return 0;
1605 }
1606
1607 if (!strcmp(var, "core.fsyncmethod")) {
1608 if (!value)
1609 return config_error_nonbool(var);
1610 if (!strcmp(value, "fsync"))
1611 fsync_method = FSYNC_METHOD_FSYNC;
1612 else if (!strcmp(value, "writeout-only"))
1613 fsync_method = FSYNC_METHOD_WRITEOUT_ONLY;
1614 else if (!strcmp(value, "batch"))
1615 fsync_method = FSYNC_METHOD_BATCH;
1616 else
1617 warning(_("ignoring unknown core.fsyncMethod value '%s'"), value);
1618
1619 }
1620
1621 if (!strcmp(var, "core.fsyncobjectfiles")) {
1622 if (fsync_object_files < 0)
1623 warning(_("core.fsyncObjectFiles is deprecated; use core.fsync instead"));
1624 fsync_object_files = git_config_bool(var, value);
1625 return 0;
1626 }
1627
1628 if (!strcmp(var, "core.preloadindex")) {
1629 core_preload_index = git_config_bool(var, value);
1630 return 0;
1631 }
1632
1633 if (!strcmp(var, "core.createobject")) {
1634 if (!value)
1635 return config_error_nonbool(var);
1636 if (!strcmp(value, "rename"))
1637 object_creation_mode = OBJECT_CREATION_USES_RENAMES;
1638 else if (!strcmp(value, "link"))
1639 object_creation_mode = OBJECT_CREATION_USES_HARDLINKS;
1640 else
1641 die(_("invalid mode for object creation: %s"), value);
1642 return 0;
1643 }
1644
1645 if (!strcmp(var, "core.sparsecheckout")) {
1646 core_apply_sparse_checkout = git_config_bool(var, value);
1647 return 0;
1648 }
1649
1650 if (!strcmp(var, "core.sparsecheckoutcone")) {
1651 core_sparse_checkout_cone = git_config_bool(var, value);
1652 return 0;
1653 }
1654
1655 if (!strcmp(var, "core.precomposeunicode")) {
1656 precomposed_unicode = git_config_bool(var, value);
1657 return 0;
1658 }
1659
1660 if (!strcmp(var, "core.protecthfs")) {
1661 protect_hfs = git_config_bool(var, value);
1662 return 0;
1663 }
1664
1665 if (!strcmp(var, "core.protectntfs")) {
1666 protect_ntfs = git_config_bool(var, value);
1667 return 0;
1668 }
1669
1670 if (!strcmp(var, "core.maxtreedepth")) {
1671 max_allowed_tree_depth = git_config_int(var, value, ctx->kvi);
1672 return 0;
1673 }
1674
1675 /* Add other config variables here and to Documentation/config.txt. */
1676 return platform_core_config(var, value, ctx, cb);
1677 }
1678
1679 static int git_default_sparse_config(const char *var, const char *value)
1680 {
1681 if (!strcmp(var, "sparse.expectfilesoutsideofpatterns")) {
1682 sparse_expect_files_outside_of_patterns = git_config_bool(var, value);
1683 return 0;
1684 }
1685
1686 /* Add other config variables here and to Documentation/config/sparse.txt. */
1687 return 0;
1688 }
1689
1690 static int git_default_i18n_config(const char *var, const char *value)
1691 {
1692 if (!strcmp(var, "i18n.commitencoding")) {
1693 FREE_AND_NULL(git_commit_encoding);
1694 return git_config_string(&git_commit_encoding, var, value);
1695 }
1696
1697 if (!strcmp(var, "i18n.logoutputencoding")) {
1698 FREE_AND_NULL(git_log_output_encoding);
1699 return git_config_string(&git_log_output_encoding, var, value);
1700 }
1701
1702 /* Add other config variables here and to Documentation/config.txt. */
1703 return 0;
1704 }
1705
1706 static int git_default_branch_config(const char *var, const char *value)
1707 {
1708 if (!strcmp(var, "branch.autosetupmerge")) {
1709 if (value && !strcmp(value, "always")) {
1710 git_branch_track = BRANCH_TRACK_ALWAYS;
1711 return 0;
1712 } else if (value && !strcmp(value, "inherit")) {
1713 git_branch_track = BRANCH_TRACK_INHERIT;
1714 return 0;
1715 } else if (value && !strcmp(value, "simple")) {
1716 git_branch_track = BRANCH_TRACK_SIMPLE;
1717 return 0;
1718 }
1719 git_branch_track = git_config_bool(var, value);
1720 return 0;
1721 }
1722 if (!strcmp(var, "branch.autosetuprebase")) {
1723 if (!value)
1724 return config_error_nonbool(var);
1725 else if (!strcmp(value, "never"))
1726 autorebase = AUTOREBASE_NEVER;
1727 else if (!strcmp(value, "local"))
1728 autorebase = AUTOREBASE_LOCAL;
1729 else if (!strcmp(value, "remote"))
1730 autorebase = AUTOREBASE_REMOTE;
1731 else if (!strcmp(value, "always"))
1732 autorebase = AUTOREBASE_ALWAYS;
1733 else
1734 return error(_("malformed value for %s"), var);
1735 return 0;
1736 }
1737
1738 /* Add other config variables here and to Documentation/config.txt. */
1739 return 0;
1740 }
1741
1742 static int git_default_push_config(const char *var, const char *value)
1743 {
1744 if (!strcmp(var, "push.default")) {
1745 if (!value)
1746 return config_error_nonbool(var);
1747 else if (!strcmp(value, "nothing"))
1748 push_default = PUSH_DEFAULT_NOTHING;
1749 else if (!strcmp(value, "matching"))
1750 push_default = PUSH_DEFAULT_MATCHING;
1751 else if (!strcmp(value, "simple"))
1752 push_default = PUSH_DEFAULT_SIMPLE;
1753 else if (!strcmp(value, "upstream"))
1754 push_default = PUSH_DEFAULT_UPSTREAM;
1755 else if (!strcmp(value, "tracking")) /* deprecated */
1756 push_default = PUSH_DEFAULT_UPSTREAM;
1757 else if (!strcmp(value, "current"))
1758 push_default = PUSH_DEFAULT_CURRENT;
1759 else {
1760 error(_("malformed value for %s: %s"), var, value);
1761 return error(_("must be one of nothing, matching, simple, "
1762 "upstream or current"));
1763 }
1764 return 0;
1765 }
1766
1767 /* Add other config variables here and to Documentation/config.txt. */
1768 return 0;
1769 }
1770
1771 static int git_default_mailmap_config(const char *var, const char *value)
1772 {
1773 if (!strcmp(var, "mailmap.file")) {
1774 FREE_AND_NULL(git_mailmap_file);
1775 return git_config_pathname(&git_mailmap_file, var, value);
1776 }
1777
1778 if (!strcmp(var, "mailmap.blob")) {
1779 FREE_AND_NULL(git_mailmap_blob);
1780 return git_config_string(&git_mailmap_blob, var, value);
1781 }
1782
1783 /* Add other config variables here and to Documentation/config.txt. */
1784 return 0;
1785 }
1786
1787 static int git_default_attr_config(const char *var, const char *value)
1788 {
1789 if (!strcmp(var, "attr.tree")) {
1790 FREE_AND_NULL(git_attr_tree);
1791 return git_config_string(&git_attr_tree, var, value);
1792 }
1793
1794 /*
1795 * Add other attribute related config variables here and to
1796 * Documentation/config/attr.txt.
1797 */
1798 return 0;
1799 }
1800
1801 int git_default_config(const char *var, const char *value,
1802 const struct config_context *ctx, void *cb)
1803 {
1804 if (starts_with(var, "core."))
1805 return git_default_core_config(var, value, ctx, cb);
1806
1807 if (starts_with(var, "user.") ||
1808 starts_with(var, "author.") ||
1809 starts_with(var, "committer."))
1810 return git_ident_config(var, value, ctx, cb);
1811
1812 if (starts_with(var, "i18n."))
1813 return git_default_i18n_config(var, value);
1814
1815 if (starts_with(var, "branch."))
1816 return git_default_branch_config(var, value);
1817
1818 if (starts_with(var, "push."))
1819 return git_default_push_config(var, value);
1820
1821 if (starts_with(var, "mailmap."))
1822 return git_default_mailmap_config(var, value);
1823
1824 if (starts_with(var, "attr."))
1825 return git_default_attr_config(var, value);
1826
1827 if (starts_with(var, "advice.") || starts_with(var, "color.advice"))
1828 return git_default_advice_config(var, value);
1829
1830 if (!strcmp(var, "pager.color") || !strcmp(var, "color.pager")) {
1831 pager_use_color = git_config_bool(var,value);
1832 return 0;
1833 }
1834
1835 if (!strcmp(var, "pack.packsizelimit")) {
1836 pack_size_limit_cfg = git_config_ulong(var, value, ctx->kvi);
1837 return 0;
1838 }
1839
1840 if (!strcmp(var, "pack.compression")) {
1841 int level = git_config_int(var, value, ctx->kvi);
1842 if (level == -1)
1843 level = Z_DEFAULT_COMPRESSION;
1844 else if (level < 0 || level > Z_BEST_COMPRESSION)
1845 die(_("bad pack compression level %d"), level);
1846 pack_compression_level = level;
1847 pack_compression_seen = 1;
1848 return 0;
1849 }
1850
1851 if (starts_with(var, "sparse."))
1852 return git_default_sparse_config(var, value);
1853
1854 /* Add other config variables here and to Documentation/config.txt. */
1855 return 0;
1856 }
1857
1858 /*
1859 * All source specific fields in the union, die_on_error, name and the callbacks
1860 * fgetc, ungetc, ftell of top need to be initialized before calling
1861 * this function.
1862 */
1863 static int do_config_from(struct config_source *top, config_fn_t fn,
1864 void *data, enum config_scope scope,
1865 const struct config_options *opts)
1866 {
1867 struct key_value_info kvi = KVI_INIT;
1868 int ret;
1869
1870 /* push config-file parsing state stack */
1871 top->linenr = 1;
1872 top->eof = 0;
1873 top->total_len = 0;
1874 strbuf_init(&top->value, 1024);
1875 strbuf_init(&top->var, 1024);
1876 kvi_from_source(top, scope, &kvi);
1877
1878 ret = git_parse_source(top, fn, &kvi, data, opts);
1879
1880 strbuf_release(&top->value);
1881 strbuf_release(&top->var);
1882
1883 return ret;
1884 }
1885
1886 static int do_config_from_file(config_fn_t fn,
1887 const enum config_origin_type origin_type,
1888 const char *name, const char *path, FILE *f,
1889 void *data, enum config_scope scope,
1890 const struct config_options *opts)
1891 {
1892 struct config_source top = CONFIG_SOURCE_INIT;
1893 int ret;
1894
1895 top.u.file = f;
1896 top.origin_type = origin_type;
1897 top.name = name;
1898 top.path = path;
1899 top.default_error_action = CONFIG_ERROR_DIE;
1900 top.do_fgetc = config_file_fgetc;
1901 top.do_ungetc = config_file_ungetc;
1902 top.do_ftell = config_file_ftell;
1903
1904 flockfile(f);
1905 ret = do_config_from(&top, fn, data, scope, opts);
1906 funlockfile(f);
1907 return ret;
1908 }
1909
1910 static int git_config_from_stdin(config_fn_t fn, void *data,
1911 enum config_scope scope)
1912 {
1913 return do_config_from_file(fn, CONFIG_ORIGIN_STDIN, "", NULL, stdin,
1914 data, scope, NULL);
1915 }
1916
1917 int git_config_from_file_with_options(config_fn_t fn, const char *filename,
1918 void *data, enum config_scope scope,
1919 const struct config_options *opts)
1920 {
1921 int ret = -1;
1922 FILE *f;
1923
1924 if (!filename)
1925 BUG("filename cannot be NULL");
1926 f = fopen_or_warn(filename, "r");
1927 if (f) {
1928 ret = do_config_from_file(fn, CONFIG_ORIGIN_FILE, filename,
1929 filename, f, data, scope, opts);
1930 fclose(f);
1931 }
1932 return ret;
1933 }
1934
1935 int git_config_from_file(config_fn_t fn, const char *filename, void *data)
1936 {
1937 return git_config_from_file_with_options(fn, filename, data,
1938 CONFIG_SCOPE_UNKNOWN, NULL);
1939 }
1940
1941 int git_config_from_mem(config_fn_t fn,
1942 const enum config_origin_type origin_type,
1943 const char *name, const char *buf, size_t len,
1944 void *data, enum config_scope scope,
1945 const struct config_options *opts)
1946 {
1947 struct config_source top = CONFIG_SOURCE_INIT;
1948
1949 top.u.buf.buf = buf;
1950 top.u.buf.len = len;
1951 top.u.buf.pos = 0;
1952 top.origin_type = origin_type;
1953 top.name = name;
1954 top.path = NULL;
1955 top.default_error_action = CONFIG_ERROR_ERROR;
1956 top.do_fgetc = config_buf_fgetc;
1957 top.do_ungetc = config_buf_ungetc;
1958 top.do_ftell = config_buf_ftell;
1959
1960 return do_config_from(&top, fn, data, scope, opts);
1961 }
1962
1963 int git_config_from_blob_oid(config_fn_t fn,
1964 const char *name,
1965 struct repository *repo,
1966 const struct object_id *oid,
1967 void *data,
1968 enum config_scope scope)
1969 {
1970 enum object_type type;
1971 char *buf;
1972 unsigned long size;
1973 int ret;
1974
1975 buf = repo_read_object_file(repo, oid, &type, &size);
1976 if (!buf)
1977 return error(_("unable to load config blob object '%s'"), name);
1978 if (type != OBJ_BLOB) {
1979 free(buf);
1980 return error(_("reference '%s' does not point to a blob"), name);
1981 }
1982
1983 ret = git_config_from_mem(fn, CONFIG_ORIGIN_BLOB, name, buf, size,
1984 data, scope, NULL);
1985 free(buf);
1986
1987 return ret;
1988 }
1989
1990 static int git_config_from_blob_ref(config_fn_t fn,
1991 struct repository *repo,
1992 const char *name,
1993 void *data,
1994 enum config_scope scope)
1995 {
1996 struct object_id oid;
1997
1998 if (repo_get_oid(repo, name, &oid) < 0)
1999 return error(_("unable to resolve config blob '%s'"), name);
2000 return git_config_from_blob_oid(fn, name, repo, &oid, data, scope);
2001 }
2002
2003 char *git_system_config(void)
2004 {
2005 char *system_config = xstrdup_or_null(getenv("GIT_CONFIG_SYSTEM"));
2006 if (!system_config)
2007 system_config = system_path(ETC_GITCONFIG);
2008 normalize_path_copy(system_config, system_config);
2009 return system_config;
2010 }
2011
2012 char *git_global_config(void)
2013 {
2014 char *user_config, *xdg_config;
2015
2016 git_global_config_paths(&user_config, &xdg_config);
2017 if (!user_config) {
2018 free(xdg_config);
2019 return NULL;
2020 }
2021
2022 if (access_or_warn(user_config, R_OK, 0) && xdg_config &&
2023 !access_or_warn(xdg_config, R_OK, 0)) {
2024 free(user_config);
2025 return xdg_config;
2026 } else {
2027 free(xdg_config);
2028 return user_config;
2029 }
2030 }
2031
2032 void git_global_config_paths(char **user_out, char **xdg_out)
2033 {
2034 char *user_config = xstrdup_or_null(getenv("GIT_CONFIG_GLOBAL"));
2035 char *xdg_config = NULL;
2036
2037 if (!user_config) {
2038 user_config = interpolate_path("~/.gitconfig", 0);
2039 xdg_config = xdg_config_home("config");
2040 }
2041
2042 *user_out = user_config;
2043 *xdg_out = xdg_config;
2044 }
2045
2046 int git_config_system(void)
2047 {
2048 return !git_env_bool("GIT_CONFIG_NOSYSTEM", 0);
2049 }
2050
2051 static int do_git_config_sequence(const struct config_options *opts,
2052 const struct repository *repo,
2053 config_fn_t fn, void *data)
2054 {
2055 int ret = 0;
2056 char *system_config = git_system_config();
2057 char *xdg_config = NULL;
2058 char *user_config = NULL;
2059 char *repo_config;
2060 char *worktree_config;
2061
2062 /*
2063 * Ensure that either:
2064 * - the git_dir and commondir are both set, or
2065 * - the git_dir and commondir are both NULL
2066 */
2067 if (!opts->git_dir != !opts->commondir)
2068 BUG("only one of commondir and git_dir is non-NULL");
2069
2070 if (opts->commondir) {
2071 repo_config = mkpathdup("%s/config", opts->commondir);
2072 worktree_config = mkpathdup("%s/config.worktree", opts->git_dir);
2073 } else {
2074 repo_config = NULL;
2075 worktree_config = NULL;
2076 }
2077
2078 if (git_config_system() && system_config &&
2079 !access_or_die(system_config, R_OK,
2080 opts->system_gently ? ACCESS_EACCES_OK : 0))
2081 ret += git_config_from_file_with_options(fn, system_config,
2082 data, CONFIG_SCOPE_SYSTEM,
2083 NULL);
2084
2085 git_global_config_paths(&user_config, &xdg_config);
2086
2087 if (xdg_config && !access_or_die(xdg_config, R_OK, ACCESS_EACCES_OK))
2088 ret += git_config_from_file_with_options(fn, xdg_config, data,
2089 CONFIG_SCOPE_GLOBAL, NULL);
2090
2091 if (user_config && !access_or_die(user_config, R_OK, ACCESS_EACCES_OK))
2092 ret += git_config_from_file_with_options(fn, user_config, data,
2093 CONFIG_SCOPE_GLOBAL, NULL);
2094
2095 if (!opts->ignore_repo && repo_config &&
2096 !access_or_die(repo_config, R_OK, 0))
2097 ret += git_config_from_file_with_options(fn, repo_config, data,
2098 CONFIG_SCOPE_LOCAL, NULL);
2099
2100 if (!opts->ignore_worktree && worktree_config &&
2101 repo && repo->repository_format_worktree_config &&
2102 !access_or_die(worktree_config, R_OK, 0)) {
2103 ret += git_config_from_file_with_options(fn, worktree_config, data,
2104 CONFIG_SCOPE_WORKTREE,
2105 NULL);
2106 }
2107
2108 if (!opts->ignore_cmdline && git_config_from_parameters(fn, data) < 0)
2109 die(_("unable to parse command-line config"));
2110
2111 free(system_config);
2112 free(xdg_config);
2113 free(user_config);
2114 free(repo_config);
2115 free(worktree_config);
2116 return ret;
2117 }
2118
2119 int config_with_options(config_fn_t fn, void *data,
2120 const struct git_config_source *config_source,
2121 struct repository *repo,
2122 const struct config_options *opts)
2123 {
2124 struct config_include_data inc = CONFIG_INCLUDE_INIT;
2125 int ret;
2126
2127 if (opts->respect_includes) {
2128 inc.fn = fn;
2129 inc.data = data;
2130 inc.opts = opts;
2131 inc.repo = repo;
2132 inc.config_source = config_source;
2133 fn = git_config_include;
2134 data = &inc;
2135 }
2136
2137 /*
2138 * If we have a specific filename, use it. Otherwise, follow the
2139 * regular lookup sequence.
2140 */
2141 if (config_source && config_source->use_stdin) {
2142 ret = git_config_from_stdin(fn, data, config_source->scope);
2143 } else if (config_source && config_source->file) {
2144 ret = git_config_from_file_with_options(fn, config_source->file,
2145 data, config_source->scope,
2146 NULL);
2147 } else if (config_source && config_source->blob) {
2148 ret = git_config_from_blob_ref(fn, repo, config_source->blob,
2149 data, config_source->scope);
2150 } else {
2151 ret = do_git_config_sequence(opts, repo, fn, data);
2152 }
2153
2154 if (inc.remote_urls) {
2155 string_list_clear(inc.remote_urls, 0);
2156 FREE_AND_NULL(inc.remote_urls);
2157 }
2158 return ret;
2159 }
2160
2161 static void configset_iter(struct config_set *set, config_fn_t fn, void *data)
2162 {
2163 int i, value_index;
2164 struct string_list *values;
2165 struct config_set_element *entry;
2166 struct configset_list *list = &set->list;
2167 struct config_context ctx = CONFIG_CONTEXT_INIT;
2168
2169 for (i = 0; i < list->nr; i++) {
2170 entry = list->items[i].e;
2171 value_index = list->items[i].value_index;
2172 values = &entry->value_list;
2173
2174 ctx.kvi = values->items[value_index].util;
2175 if (fn(entry->key, values->items[value_index].string, &ctx, data) < 0)
2176 git_die_config_linenr(entry->key,
2177 ctx.kvi->filename,
2178 ctx.kvi->linenr);
2179 }
2180 }
2181
2182 void read_early_config(struct repository *repo, config_fn_t cb, void *data)
2183 {
2184 struct config_options opts = {0};
2185 struct strbuf commondir = STRBUF_INIT;
2186 struct strbuf gitdir = STRBUF_INIT;
2187
2188 opts.respect_includes = 1;
2189
2190 if (repo && repo->gitdir) {
2191 opts.commondir = repo_get_common_dir(repo);
2192 opts.git_dir = repo_get_git_dir(repo);
2193 /*
2194 * When setup_git_directory() was not yet asked to discover the
2195 * GIT_DIR, we ask discover_git_directory() to figure out whether there
2196 * is any repository config we should use (but unlike
2197 * setup_git_directory_gently(), no global state is changed, most
2198 * notably, the current working directory is still the same after the
2199 * call).
2200 */
2201 } else if (!discover_git_directory(&commondir, &gitdir)) {
2202 opts.commondir = commondir.buf;
2203 opts.git_dir = gitdir.buf;
2204 }
2205
2206 config_with_options(cb, data, NULL, NULL, &opts);
2207
2208 strbuf_release(&commondir);
2209 strbuf_release(&gitdir);
2210 }
2211
2212 void read_very_early_config(config_fn_t cb, void *data)
2213 {
2214 struct config_options opts = { 0 };
2215
2216 opts.respect_includes = 1;
2217 opts.ignore_repo = 1;
2218 opts.ignore_worktree = 1;
2219 opts.ignore_cmdline = 1;
2220 opts.system_gently = 1;
2221
2222 config_with_options(cb, data, NULL, NULL, &opts);
2223 }
2224
2225 RESULT_MUST_BE_USED
2226 static int configset_find_element(struct config_set *set, const char *key,
2227 struct config_set_element **dest)
2228 {
2229 struct config_set_element k;
2230 struct config_set_element *found_entry;
2231 char *normalized_key;
2232 int ret;
2233
2234 /*
2235 * `key` may come from the user, so normalize it before using it
2236 * for querying entries from the hashmap.
2237 */
2238 ret = git_config_parse_key(key, &normalized_key, NULL);
2239 if (ret)
2240 return ret;
2241
2242 hashmap_entry_init(&k.ent, strhash(normalized_key));
2243 k.key = normalized_key;
2244 found_entry = hashmap_get_entry(&set->config_hash, &k, ent, NULL);
2245 free(normalized_key);
2246 *dest = found_entry;
2247 return 0;
2248 }
2249
2250 static int configset_add_value(const struct key_value_info *kvi_p,
2251 struct config_set *set, const char *key,
2252 const char *value)
2253 {
2254 struct config_set_element *e;
2255 struct string_list_item *si;
2256 struct configset_list_item *l_item;
2257 struct key_value_info *kv_info = xmalloc(sizeof(*kv_info));
2258 int ret;
2259
2260 ret = configset_find_element(set, key, &e);
2261 if (ret)
2262 return ret;
2263 /*
2264 * Since the keys are being fed by git_config*() callback mechanism, they
2265 * are already normalized. So simply add them without any further munging.
2266 */
2267 if (!e) {
2268 e = xmalloc(sizeof(*e));
2269 hashmap_entry_init(&e->ent, strhash(key));
2270 e->key = xstrdup(key);
2271 string_list_init_dup(&e->value_list);
2272 hashmap_add(&set->config_hash, &e->ent);
2273 }
2274 si = string_list_append_nodup(&e->value_list, xstrdup_or_null(value));
2275
2276 ALLOC_GROW(set->list.items, set->list.nr + 1, set->list.alloc);
2277 l_item = &set->list.items[set->list.nr++];
2278 l_item->e = e;
2279 l_item->value_index = e->value_list.nr - 1;
2280
2281 *kv_info = *kvi_p;
2282 si->util = kv_info;
2283
2284 return 0;
2285 }
2286
2287 static int config_set_element_cmp(const void *cmp_data UNUSED,
2288 const struct hashmap_entry *eptr,
2289 const struct hashmap_entry *entry_or_key,
2290 const void *keydata UNUSED)
2291 {
2292 const struct config_set_element *e1, *e2;
2293
2294 e1 = container_of(eptr, const struct config_set_element, ent);
2295 e2 = container_of(entry_or_key, const struct config_set_element, ent);
2296
2297 return strcmp(e1->key, e2->key);
2298 }
2299
2300 void git_configset_init(struct config_set *set)
2301 {
2302 hashmap_init(&set->config_hash, config_set_element_cmp, NULL, 0);
2303 set->hash_initialized = 1;
2304 set->list.nr = 0;
2305 set->list.alloc = 0;
2306 set->list.items = NULL;
2307 }
2308
2309 void git_configset_clear(struct config_set *set)
2310 {
2311 struct config_set_element *entry;
2312 struct hashmap_iter iter;
2313 if (!set->hash_initialized)
2314 return;
2315
2316 hashmap_for_each_entry(&set->config_hash, &iter, entry,
2317 ent /* member name */) {
2318 free(entry->key);
2319 string_list_clear(&entry->value_list, 1);
2320 }
2321 hashmap_clear_and_free(&set->config_hash, struct config_set_element, ent);
2322 set->hash_initialized = 0;
2323 free(set->list.items);
2324 set->list.nr = 0;
2325 set->list.alloc = 0;
2326 set->list.items = NULL;
2327 }
2328
2329 static int config_set_callback(const char *key, const char *value,
2330 const struct config_context *ctx,
2331 void *cb)
2332 {
2333 struct config_set *set = cb;
2334 configset_add_value(ctx->kvi, set, key, value);
2335 return 0;
2336 }
2337
2338 int git_configset_add_file(struct config_set *set, const char *filename)
2339 {
2340 return git_config_from_file(config_set_callback, filename, set);
2341 }
2342
2343 int git_configset_get_value(struct config_set *set, const char *key,
2344 const char **value, struct key_value_info *kvi)
2345 {
2346 const struct string_list *values = NULL;
2347 int ret;
2348 struct string_list_item item;
2349 /*
2350 * Follows "last one wins" semantic, i.e., if there are multiple matches for the
2351 * queried key in the files of the configset, the value returned will be the last
2352 * value in the value list for that key.
2353 */
2354 if ((ret = git_configset_get_value_multi(set, key, &values)))
2355 return ret;
2356
2357 assert(values->nr > 0);
2358 item = values->items[values->nr - 1];
2359 *value = item.string;
2360 if (kvi)
2361 *kvi = *((struct key_value_info *)item.util);
2362 return 0;
2363 }
2364
2365 int git_configset_get_value_multi(struct config_set *set, const char *key,
2366 const struct string_list **dest)
2367 {
2368 struct config_set_element *e;
2369 int ret;
2370
2371 if ((ret = configset_find_element(set, key, &e)))
2372 return ret;
2373 else if (!e)
2374 return 1;
2375 *dest = &e->value_list;
2376
2377 return 0;
2378 }
2379
2380 static int check_multi_string(struct string_list_item *item, void *util)
2381 {
2382 return item->string ? 0 : config_error_nonbool(util);
2383 }
2384
2385 int git_configset_get_string_multi(struct config_set *cs, const char *key,
2386 const struct string_list **dest)
2387 {
2388 int ret;
2389
2390 if ((ret = git_configset_get_value_multi(cs, key, dest)))
2391 return ret;
2392 if ((ret = for_each_string_list((struct string_list *)*dest,
2393 check_multi_string, (void *)key)))
2394 return ret;
2395
2396 return 0;
2397 }
2398
2399 int git_configset_get(struct config_set *set, const char *key)
2400 {
2401 struct config_set_element *e;
2402 int ret;
2403
2404 if ((ret = configset_find_element(set, key, &e)))
2405 return ret;
2406 else if (!e)
2407 return 1;
2408 return 0;
2409 }
2410
2411 int git_configset_get_string(struct config_set *set, const char *key, char **dest)
2412 {
2413 const char *value;
2414 if (!git_configset_get_value(set, key, &value, NULL))
2415 return git_config_string(dest, key, value);
2416 else
2417 return 1;
2418 }
2419
2420 static int git_configset_get_string_tmp(struct config_set *set, const char *key,
2421 const char **dest)
2422 {
2423 const char *value;
2424 if (!git_configset_get_value(set, key, &value, NULL)) {
2425 if (!value)
2426 return config_error_nonbool(key);
2427 *dest = value;
2428 return 0;
2429 } else {
2430 return 1;
2431 }
2432 }
2433
2434 int git_configset_get_int(struct config_set *set, const char *key, int *dest)
2435 {
2436 const char *value;
2437 struct key_value_info kvi;
2438
2439 if (!git_configset_get_value(set, key, &value, &kvi)) {
2440 *dest = git_config_int(key, value, &kvi);
2441 return 0;
2442 } else
2443 return 1;
2444 }
2445
2446 int git_configset_get_ulong(struct config_set *set, const char *key, unsigned long *dest)
2447 {
2448 const char *value;
2449 struct key_value_info kvi;
2450
2451 if (!git_configset_get_value(set, key, &value, &kvi)) {
2452 *dest = git_config_ulong(key, value, &kvi);
2453 return 0;
2454 } else
2455 return 1;
2456 }
2457
2458 int git_configset_get_bool(struct config_set *set, const char *key, int *dest)
2459 {
2460 const char *value;
2461 if (!git_configset_get_value(set, key, &value, NULL)) {
2462 *dest = git_config_bool(key, value);
2463 return 0;
2464 } else
2465 return 1;
2466 }
2467
2468 int git_configset_get_bool_or_int(struct config_set *set, const char *key,
2469 int *is_bool, int *dest)
2470 {
2471 const char *value;
2472 struct key_value_info kvi;
2473
2474 if (!git_configset_get_value(set, key, &value, &kvi)) {
2475 *dest = git_config_bool_or_int(key, value, &kvi, is_bool);
2476 return 0;
2477 } else
2478 return 1;
2479 }
2480
2481 int git_configset_get_maybe_bool(struct config_set *set, const char *key, int *dest)
2482 {
2483 const char *value;
2484 if (!git_configset_get_value(set, key, &value, NULL)) {
2485 *dest = git_parse_maybe_bool(value);
2486 if (*dest == -1)
2487 return -1;
2488 return 0;
2489 } else
2490 return 1;
2491 }
2492
2493 int git_configset_get_pathname(struct config_set *set, const char *key, char **dest)
2494 {
2495 const char *value;
2496 if (!git_configset_get_value(set, key, &value, NULL))
2497 return git_config_pathname(dest, key, value);
2498 else
2499 return 1;
2500 }
2501
2502 /* Functions use to read configuration from a repository */
2503 static void repo_read_config(struct repository *repo)
2504 {
2505 struct config_options opts = { 0 };
2506
2507 opts.respect_includes = 1;
2508 opts.commondir = repo->commondir;
2509 opts.git_dir = repo->gitdir;
2510
2511 if (!repo->config)
2512 CALLOC_ARRAY(repo->config, 1);
2513 else
2514 git_configset_clear(repo->config);
2515
2516 git_configset_init(repo->config);
2517 if (config_with_options(config_set_callback, repo->config, NULL,
2518 repo, &opts) < 0)
2519 /*
2520 * config_with_options() normally returns only
2521 * zero, as most errors are fatal, and
2522 * non-fatal potential errors are guarded by "if"
2523 * statements that are entered only when no error is
2524 * possible.
2525 *
2526 * If we ever encounter a non-fatal error, it means
2527 * something went really wrong and we should stop
2528 * immediately.
2529 */
2530 die(_("unknown error occurred while reading the configuration files"));
2531 }
2532
2533 static void git_config_check_init(struct repository *repo)
2534 {
2535 if (repo->config && repo->config->hash_initialized)
2536 return;
2537 repo_read_config(repo);
2538 }
2539
2540 void repo_config_clear(struct repository *repo)
2541 {
2542 if (!repo->config || !repo->config->hash_initialized)
2543 return;
2544 git_configset_clear(repo->config);
2545 }
2546
2547 void repo_config(struct repository *repo, config_fn_t fn, void *data)
2548 {
2549 git_config_check_init(repo);
2550 configset_iter(repo->config, fn, data);
2551 }
2552
2553 int repo_config_get(struct repository *repo, const char *key)
2554 {
2555 git_config_check_init(repo);
2556 return git_configset_get(repo->config, key);
2557 }
2558
2559 int repo_config_get_value(struct repository *repo,
2560 const char *key, const char **value)
2561 {
2562 git_config_check_init(repo);
2563 return git_configset_get_value(repo->config, key, value, NULL);
2564 }
2565
2566 int repo_config_get_value_multi(struct repository *repo, const char *key,
2567 const struct string_list **dest)
2568 {
2569 git_config_check_init(repo);
2570 return git_configset_get_value_multi(repo->config, key, dest);
2571 }
2572
2573 int repo_config_get_string_multi(struct repository *repo, const char *key,
2574 const struct string_list **dest)
2575 {
2576 git_config_check_init(repo);
2577 return git_configset_get_string_multi(repo->config, key, dest);
2578 }
2579
2580 int repo_config_get_string(struct repository *repo,
2581 const char *key, char **dest)
2582 {
2583 int ret;
2584 git_config_check_init(repo);
2585 ret = git_configset_get_string(repo->config, key, dest);
2586 if (ret < 0)
2587 git_die_config(repo, key, NULL);
2588 return ret;
2589 }
2590
2591 int repo_config_get_string_tmp(struct repository *repo,
2592 const char *key, const char **dest)
2593 {
2594 int ret;
2595 git_config_check_init(repo);
2596 ret = git_configset_get_string_tmp(repo->config, key, dest);
2597 if (ret < 0)
2598 git_die_config(repo, key, NULL);
2599 return ret;
2600 }
2601
2602 int repo_config_get_int(struct repository *repo,
2603 const char *key, int *dest)
2604 {
2605 git_config_check_init(repo);
2606 return git_configset_get_int(repo->config, key, dest);
2607 }
2608
2609 int repo_config_get_ulong(struct repository *repo,
2610 const char *key, unsigned long *dest)
2611 {
2612 git_config_check_init(repo);
2613 return git_configset_get_ulong(repo->config, key, dest);
2614 }
2615
2616 int repo_config_get_bool(struct repository *repo,
2617 const char *key, int *dest)
2618 {
2619 git_config_check_init(repo);
2620 return git_configset_get_bool(repo->config, key, dest);
2621 }
2622
2623 int repo_config_get_bool_or_int(struct repository *repo,
2624 const char *key, int *is_bool, int *dest)
2625 {
2626 git_config_check_init(repo);
2627 return git_configset_get_bool_or_int(repo->config, key, is_bool, dest);
2628 }
2629
2630 int repo_config_get_maybe_bool(struct repository *repo,
2631 const char *key, int *dest)
2632 {
2633 git_config_check_init(repo);
2634 return git_configset_get_maybe_bool(repo->config, key, dest);
2635 }
2636
2637 int repo_config_get_pathname(struct repository *repo,
2638 const char *key, char **dest)
2639 {
2640 int ret;
2641 git_config_check_init(repo);
2642 ret = git_configset_get_pathname(repo->config, key, dest);
2643 if (ret < 0)
2644 git_die_config(repo, key, NULL);
2645 return ret;
2646 }
2647
2648 /* Read values into protected_config. */
2649 static void read_protected_config(void)
2650 {
2651 struct config_options opts = {
2652 .respect_includes = 1,
2653 .ignore_repo = 1,
2654 .ignore_worktree = 1,
2655 .system_gently = 1,
2656 };
2657
2658 git_configset_init(&protected_config);
2659 config_with_options(config_set_callback, &protected_config, NULL,
2660 NULL, &opts);
2661 }
2662
2663 void git_protected_config(config_fn_t fn, void *data)
2664 {
2665 if (!protected_config.hash_initialized)
2666 read_protected_config();
2667 configset_iter(&protected_config, fn, data);
2668 }
2669
2670 int repo_config_get_expiry(struct repository *r, const char *key, char **output)
2671 {
2672 int ret = repo_config_get_string(r, key, output);
2673
2674 if (ret)
2675 return ret;
2676 if (strcmp(*output, "now")) {
2677 timestamp_t now = approxidate("now");
2678 if (approxidate(*output) >= now)
2679 git_die_config(r, key, _("Invalid %s: '%s'"), key, *output);
2680 }
2681 return ret;
2682 }
2683
2684 int repo_config_get_expiry_in_days(struct repository *r, const char *key,
2685 timestamp_t *expiry, timestamp_t now)
2686 {
2687 const char *expiry_string;
2688 intmax_t days;
2689 timestamp_t when;
2690
2691 if (repo_config_get_string_tmp(r, key, &expiry_string))
2692 return 1; /* no such thing */
2693
2694 if (git_parse_signed(expiry_string, &days, maximum_signed_value_of_type(int))) {
2695 const int scale = 86400;
2696 *expiry = now - days * scale;
2697 return 0;
2698 }
2699
2700 if (!parse_expiry_date(expiry_string, &when)) {
2701 *expiry = when;
2702 return 0;
2703 }
2704 return -1; /* thing exists but cannot be parsed */
2705 }
2706
2707 int repo_config_get_split_index(struct repository *r)
2708 {
2709 int val;
2710
2711 if (!repo_config_get_maybe_bool(r, "core.splitindex", &val))
2712 return val;
2713
2714 return -1; /* default value */
2715 }
2716
2717 int repo_config_get_max_percent_split_change(struct repository *r)
2718 {
2719 int val = -1;
2720
2721 if (!repo_config_get_int(r, "splitindex.maxpercentchange", &val)) {
2722 if (0 <= val && val <= 100)
2723 return val;
2724
2725 return error(_("splitIndex.maxPercentChange value '%d' "
2726 "should be between 0 and 100"), val);
2727 }
2728
2729 return -1; /* default value */
2730 }
2731
2732 int repo_config_get_index_threads(struct repository *r, int *dest)
2733 {
2734 int is_bool, val;
2735
2736 val = git_env_ulong("GIT_TEST_INDEX_THREADS", 0);
2737 if (val) {
2738 *dest = val;
2739 return 0;
2740 }
2741
2742 if (!repo_config_get_bool_or_int(r, "index.threads", &is_bool, &val)) {
2743 if (is_bool)
2744 *dest = val ? 0 : 1;
2745 else
2746 *dest = val;
2747 return 0;
2748 }
2749
2750 return 1;
2751 }
2752
2753 NORETURN
2754 void git_die_config_linenr(const char *key, const char *filename, int linenr)
2755 {
2756 if (!filename)
2757 die(_("unable to parse '%s' from command-line config"), key);
2758 else
2759 die(_("bad config variable '%s' in file '%s' at line %d"),
2760 key, filename, linenr);
2761 }
2762
2763 void git_die_config(struct repository *r, const char *key, const char *err, ...)
2764 {
2765 const struct string_list *values;
2766 struct key_value_info *kv_info;
2767 report_fn error_fn = get_error_routine();
2768
2769 if (err) {
2770 va_list params;
2771 va_start(params, err);
2772 error_fn(err, params);
2773 va_end(params);
2774 }
2775 if (repo_config_get_value_multi(r, key, &values))
2776 BUG("for key '%s' we must have a value to report on", key);
2777 kv_info = values->items[values->nr - 1].util;
2778 git_die_config_linenr(key, kv_info->filename, kv_info->linenr);
2779 }
2780
2781 /*
2782 * Find all the stuff for git_config_set() below.
2783 */
2784
2785 struct config_store_data {
2786 size_t baselen;
2787 char *key;
2788 int do_not_match;
2789 const char *fixed_value;
2790 regex_t *value_pattern;
2791 int multi_replace;
2792 struct {
2793 size_t begin, end;
2794 enum config_event_t type;
2795 int is_keys_section;
2796 } *parsed;
2797 unsigned int parsed_nr, parsed_alloc, *seen, seen_nr, seen_alloc;
2798 unsigned int key_seen:1, section_seen:1, is_keys_section:1;
2799 };
2800 #define CONFIG_STORE_INIT { 0 }
2801
2802 static void config_store_data_clear(struct config_store_data *store)
2803 {
2804 free(store->key);
2805 if (store->value_pattern != NULL &&
2806 store->value_pattern != CONFIG_REGEX_NONE) {
2807 regfree(store->value_pattern);
2808 free(store->value_pattern);
2809 }
2810 free(store->parsed);
2811 free(store->seen);
2812 memset(store, 0, sizeof(*store));
2813 }
2814
2815 static int matches(const char *key, const char *value,
2816 const struct config_store_data *store)
2817 {
2818 if (strcmp(key, store->key))
2819 return 0; /* not ours */
2820 if (store->fixed_value && value)
2821 return !strcmp(store->fixed_value, value);
2822 if (!store->value_pattern)
2823 return 1; /* always matches */
2824 if (store->value_pattern == CONFIG_REGEX_NONE)
2825 return 0; /* never matches */
2826
2827 return store->do_not_match ^
2828 (value && !regexec(store->value_pattern, value, 0, NULL, 0));
2829 }
2830
2831 static int store_aux_event(enum config_event_t type, size_t begin, size_t end,
2832 struct config_source *cs, void *data)
2833 {
2834 struct config_store_data *store = data;
2835
2836 ALLOC_GROW(store->parsed, store->parsed_nr + 1, store->parsed_alloc);
2837 store->parsed[store->parsed_nr].begin = begin;
2838 store->parsed[store->parsed_nr].end = end;
2839 store->parsed[store->parsed_nr].type = type;
2840
2841 if (type == CONFIG_EVENT_SECTION) {
2842 int (*cmpfn)(const char *, const char *, size_t);
2843
2844 if (cs->var.len < 2 || cs->var.buf[cs->var.len - 1] != '.')
2845 return error(_("invalid section name '%s'"), cs->var.buf);
2846
2847 if (cs->subsection_case_sensitive)
2848 cmpfn = strncasecmp;
2849 else
2850 cmpfn = strncmp;
2851
2852 /* Is this the section we were looking for? */
2853 store->is_keys_section =
2854 store->parsed[store->parsed_nr].is_keys_section =
2855 cs->var.len - 1 == store->baselen &&
2856 !cmpfn(cs->var.buf, store->key, store->baselen);
2857 if (store->is_keys_section) {
2858 store->section_seen = 1;
2859 ALLOC_GROW(store->seen, store->seen_nr + 1,
2860 store->seen_alloc);
2861 store->seen[store->seen_nr] = store->parsed_nr;
2862 }
2863 }
2864
2865 store->parsed_nr++;
2866
2867 return 0;
2868 }
2869
2870 static int store_aux(const char *key, const char *value,
2871 const struct config_context *ctx UNUSED, void *cb)
2872 {
2873 struct config_store_data *store = cb;
2874
2875 if (store->key_seen) {
2876 if (matches(key, value, store)) {
2877 if (store->seen_nr == 1 && store->multi_replace == 0) {
2878 warning(_("%s has multiple values"), key);
2879 }
2880
2881 ALLOC_GROW(store->seen, store->seen_nr + 1,
2882 store->seen_alloc);
2883
2884 store->seen[store->seen_nr] = store->parsed_nr;
2885 store->seen_nr++;
2886 }
2887 } else if (store->is_keys_section) {
2888 /*
2889 * Do not increment matches yet: this may not be a match, but we
2890 * are in the desired section.
2891 */
2892 ALLOC_GROW(store->seen, store->seen_nr + 1, store->seen_alloc);
2893 store->seen[store->seen_nr] = store->parsed_nr;
2894 store->section_seen = 1;
2895
2896 if (matches(key, value, store)) {
2897 store->seen_nr++;
2898 store->key_seen = 1;
2899 }
2900 }
2901
2902 return 0;
2903 }
2904
2905 static int write_error(const char *filename)
2906 {
2907 error(_("failed to write new configuration file %s"), filename);
2908
2909 /* Same error code as "failed to rename". */
2910 return 4;
2911 }
2912
2913 static struct strbuf store_create_section(const char *key,
2914 const struct config_store_data *store)
2915 {
2916 const char *dot;
2917 size_t i;
2918 struct strbuf sb = STRBUF_INIT;
2919
2920 dot = memchr(key, '.', store->baselen);
2921 if (dot) {
2922 strbuf_addf(&sb, "[%.*s \"", (int)(dot - key), key);
2923 for (i = dot - key + 1; i < store->baselen; i++) {
2924 if (key[i] == '"' || key[i] == '\\')
2925 strbuf_addch(&sb, '\\');
2926 strbuf_addch(&sb, key[i]);
2927 }
2928 strbuf_addstr(&sb, "\"]\n");
2929 } else {
2930 strbuf_addch(&sb, '[');
2931 strbuf_add(&sb, key, store->baselen);
2932 strbuf_addstr(&sb, "]\n");
2933 }
2934
2935 return sb;
2936 }
2937
2938 static ssize_t write_section(int fd, const char *key,
2939 const struct config_store_data *store)
2940 {
2941 struct strbuf sb = store_create_section(key, store);
2942 ssize_t ret;
2943
2944 ret = write_in_full(fd, sb.buf, sb.len);
2945 strbuf_release(&sb);
2946
2947 return ret;
2948 }
2949
2950 static ssize_t write_pair(int fd, const char *key, const char *value,
2951 const char *comment,
2952 const struct config_store_data *store)
2953 {
2954 int i;
2955 ssize_t ret;
2956 const char *quote = "";
2957 struct strbuf sb = STRBUF_INIT;
2958
2959 /*
2960 * Check to see if the value needs to be surrounded with a dq pair.
2961 * Note that problematic characters are always backslash-quoted; this
2962 * check is about not losing leading or trailing SP and strings that
2963 * follow beginning-of-comment characters (i.e. ';' and '#') by the
2964 * configuration parser.
2965 */
2966 if (value[0] == ' ')
2967 quote = "\"";
2968 for (i = 0; value[i]; i++)
2969 if (value[i] == ';' || value[i] == '#')
2970 quote = "\"";
2971 if (i && value[i - 1] == ' ')
2972 quote = "\"";
2973
2974 strbuf_addf(&sb, "\t%s = %s", key + store->baselen + 1, quote);
2975
2976 for (i = 0; value[i]; i++)
2977 switch (value[i]) {
2978 case '\n':
2979 strbuf_addstr(&sb, "\\n");
2980 break;
2981 case '\t':
2982 strbuf_addstr(&sb, "\\t");
2983 break;
2984 case '"':
2985 case '\\':
2986 strbuf_addch(&sb, '\\');
2987 /* fallthrough */
2988 default:
2989 strbuf_addch(&sb, value[i]);
2990 break;
2991 }
2992
2993 if (comment)
2994 strbuf_addf(&sb, "%s%s\n", quote, comment);
2995 else
2996 strbuf_addf(&sb, "%s\n", quote);
2997
2998 ret = write_in_full(fd, sb.buf, sb.len);
2999 strbuf_release(&sb);
3000
3001 return ret;
3002 }
3003
3004 /*
3005 * If we are about to unset the last key(s) in a section, and if there are
3006 * no comments surrounding (or included in) the section, we will want to
3007 * extend begin/end to remove the entire section.
3008 *
3009 * Note: the parameter `seen_ptr` points to the index into the store.seen
3010 * array. * This index may be incremented if a section has more than one
3011 * entry (which all are to be removed).
3012 */
3013 static void maybe_remove_section(struct config_store_data *store,
3014 size_t *begin_offset, size_t *end_offset,
3015 int *seen_ptr)
3016 {
3017 size_t begin;
3018 int i, seen, section_seen = 0;
3019
3020 /*
3021 * First, ensure that this is the first key, and that there are no
3022 * comments before the entry nor before the section header.
3023 */
3024 seen = *seen_ptr;
3025 for (i = store->seen[seen]; i > 0; i--) {
3026 enum config_event_t type = store->parsed[i - 1].type;
3027
3028 if (type == CONFIG_EVENT_COMMENT)
3029 /* There is a comment before this entry or section */
3030 return;
3031 if (type == CONFIG_EVENT_ENTRY) {
3032 if (!section_seen)
3033 /* This is not the section's first entry. */
3034 return;
3035 /* We encountered no comment before the section. */
3036 break;
3037 }
3038 if (type == CONFIG_EVENT_SECTION) {
3039 if (!store->parsed[i - 1].is_keys_section)
3040 break;
3041 section_seen = 1;
3042 }
3043 }
3044 begin = store->parsed[i].begin;
3045
3046 /*
3047 * Next, make sure that we are removing the last key(s) in the section,
3048 * and that there are no comments that are possibly about the current
3049 * section.
3050 */
3051 for (i = store->seen[seen] + 1; i < store->parsed_nr; i++) {
3052 enum config_event_t type = store->parsed[i].type;
3053
3054 if (type == CONFIG_EVENT_COMMENT)
3055 return;
3056 if (type == CONFIG_EVENT_SECTION) {
3057 if (store->parsed[i].is_keys_section)
3058 continue;
3059 break;
3060 }
3061 if (type == CONFIG_EVENT_ENTRY) {
3062 if (++seen < store->seen_nr &&
3063 i == store->seen[seen])
3064 /* We want to remove this entry, too */
3065 continue;
3066 /* There is another entry in this section. */
3067 return;
3068 }
3069 }
3070
3071 /*
3072 * We are really removing the last entry/entries from this section, and
3073 * there are no enclosed or surrounding comments. Remove the entire,
3074 * now-empty section.
3075 */
3076 *seen_ptr = seen;
3077 *begin_offset = begin;
3078 if (i < store->parsed_nr)
3079 *end_offset = store->parsed[i].begin;
3080 else
3081 *end_offset = store->parsed[store->parsed_nr - 1].end;
3082 }
3083
3084 int repo_config_set_in_file_gently(struct repository *r, const char *config_filename,
3085 const char *key, const char *comment, const char *value)
3086 {
3087 return repo_config_set_multivar_in_file_gently(r, config_filename, key, value, NULL, comment, 0);
3088 }
3089
3090 void repo_config_set_in_file(struct repository *r, const char *config_filename,
3091 const char *key, const char *value)
3092 {
3093 repo_config_set_multivar_in_file(r, config_filename, key, value, NULL, 0);
3094 }
3095
3096 int repo_config_set_gently(struct repository *r, const char *key, const char *value)
3097 {
3098 return repo_config_set_multivar_gently(r, key, value, NULL, 0);
3099 }
3100
3101 int repo_config_set_worktree_gently(struct repository *r,
3102 const char *key, const char *value)
3103 {
3104 /* Only use worktree-specific config if it is already enabled. */
3105 if (r->repository_format_worktree_config) {
3106 char *file = repo_git_path(r, "config.worktree");
3107 int ret = repo_config_set_multivar_in_file_gently(
3108 r, file, key, value, NULL, NULL, 0);
3109 free(file);
3110 return ret;
3111 }
3112 return repo_config_set_multivar_gently(r, key, value, NULL, 0);
3113 }
3114
3115 void repo_config_set(struct repository *r, const char *key, const char *value)
3116 {
3117 repo_config_set_multivar(r, key, value, NULL, 0);
3118
3119 trace2_cmd_set_config(key, value);
3120 }
3121
3122 char *git_config_prepare_comment_string(const char *comment)
3123 {
3124 size_t leading_blanks;
3125 char *prepared;
3126
3127 if (!comment)
3128 return NULL;
3129
3130 if (strchr(comment, '\n'))
3131 die(_("no multi-line comment allowed: '%s'"), comment);
3132
3133 /*
3134 * If it begins with one or more leading whitespace characters
3135 * followed by '#", the comment string is used as-is.
3136 *
3137 * If it begins with '#', a SP is inserted between the comment
3138 * and the value the comment is about.
3139 *
3140 * Otherwise, the value is followed by a SP followed by '#'
3141 * followed by SP and then the comment string comes.
3142 */
3143
3144 leading_blanks = strspn(comment, " \t");
3145 if (leading_blanks && comment[leading_blanks] == '#')
3146 prepared = xstrdup(comment); /* use it as-is */
3147 else if (comment[0] == '#')
3148 prepared = xstrfmt(" %s", comment);
3149 else
3150 prepared = xstrfmt(" # %s", comment);
3151
3152 return prepared;
3153 }
3154
3155 static void validate_comment_string(const char *comment)
3156 {
3157 size_t leading_blanks;
3158
3159 if (!comment)
3160 return;
3161 /*
3162 * The front-end must have massaged the comment string
3163 * properly before calling us.
3164 */
3165 if (strchr(comment, '\n'))
3166 BUG("multi-line comments are not permitted: '%s'", comment);
3167
3168 leading_blanks = strspn(comment, " \t");
3169 if (!leading_blanks || comment[leading_blanks] != '#')
3170 BUG("comment must begin with one or more SP followed by '#': '%s'",
3171 comment);
3172 }
3173
3174 /*
3175 * If value==NULL, unset in (remove from) config,
3176 * if value_pattern!=NULL, disregard key/value pairs where value does not match.
3177 * if value_pattern==CONFIG_REGEX_NONE, do not match any existing values
3178 * (only add a new one)
3179 * if flags contains the CONFIG_FLAGS_MULTI_REPLACE flag, all matching
3180 * key/values are removed before a single new pair is written. If the
3181 * flag is not present, then replace only the first match.
3182 *
3183 * Returns 0 on success.
3184 *
3185 * This function does this:
3186 *
3187 * - it locks the config file by creating ".git/config.lock"
3188 *
3189 * - it then parses the config using store_aux() as validator to find
3190 * the position on the key/value pair to replace. If it is to be unset,
3191 * it must be found exactly once.
3192 *
3193 * - the config file is mmap()ed and the part before the match (if any) is
3194 * written to the lock file, then the changed part and the rest.
3195 *
3196 * - the config file is removed and the lock file rename()d to it.
3197 *
3198 */
3199 int repo_config_set_multivar_in_file_gently(struct repository *r,
3200 const char *config_filename,
3201 const char *key, const char *value,
3202 const char *value_pattern,
3203 const char *comment,
3204 unsigned flags)
3205 {
3206 int fd = -1, in_fd = -1;
3207 int ret;
3208 struct lock_file lock = LOCK_INIT;
3209 char *filename_buf = NULL;
3210 char *contents = NULL;
3211 size_t contents_sz;
3212 struct config_store_data store = CONFIG_STORE_INIT;
3213
3214 validate_comment_string(comment);
3215
3216 /* parse-key returns negative; flip the sign to feed exit(3) */
3217 ret = 0 - git_config_parse_key(key, &store.key, &store.baselen);
3218 if (ret)
3219 goto out_free;
3220
3221 store.multi_replace = (flags & CONFIG_FLAGS_MULTI_REPLACE) != 0;
3222
3223 if (!config_filename)
3224 config_filename = filename_buf = repo_git_path(r, "config");
3225
3226 /*
3227 * The lock serves a purpose in addition to locking: the new
3228 * contents of .git/config will be written into it.
3229 */
3230 fd = hold_lock_file_for_update(&lock, config_filename, 0);
3231 if (fd < 0) {
3232 error_errno(_("could not lock config file %s"), config_filename);
3233 ret = CONFIG_NO_LOCK;
3234 goto out_free;
3235 }
3236
3237 /*
3238 * If .git/config does not exist yet, write a minimal version.
3239 */
3240 in_fd = open(config_filename, O_RDONLY);
3241 if ( in_fd < 0 ) {
3242 if ( ENOENT != errno ) {
3243 error_errno(_("opening %s"), config_filename);
3244 ret = CONFIG_INVALID_FILE; /* same as "invalid config file" */
3245 goto out_free;
3246 }
3247 /* if nothing to unset, error out */
3248 if (!value) {
3249 ret = CONFIG_NOTHING_SET;
3250 goto out_free;
3251 }
3252
3253 free(store.key);
3254 store.key = xstrdup(key);
3255 if (write_section(fd, key, &store) < 0 ||
3256 write_pair(fd, key, value, comment, &store) < 0)
3257 goto write_err_out;
3258 } else {
3259 struct stat st;
3260 size_t copy_begin, copy_end;
3261 int i, new_line = 0;
3262 struct config_options opts;
3263
3264 if (!value_pattern)
3265 store.value_pattern = NULL;
3266 else if (value_pattern == CONFIG_REGEX_NONE)
3267 store.value_pattern = CONFIG_REGEX_NONE;
3268 else if (flags & CONFIG_FLAGS_FIXED_VALUE)
3269 store.fixed_value = value_pattern;
3270 else {
3271 if (value_pattern[0] == '!') {
3272 store.do_not_match = 1;
3273 value_pattern++;
3274 } else
3275 store.do_not_match = 0;
3276
3277 store.value_pattern = (regex_t*)xmalloc(sizeof(regex_t));
3278 if (regcomp(store.value_pattern, value_pattern,
3279 REG_EXTENDED)) {
3280 error(_("invalid pattern: %s"), value_pattern);
3281 FREE_AND_NULL(store.value_pattern);
3282 ret = CONFIG_INVALID_PATTERN;
3283 goto out_free;
3284 }
3285 }
3286
3287 ALLOC_GROW(store.parsed, 1, store.parsed_alloc);
3288 store.parsed[0].end = 0;
3289
3290 memset(&opts, 0, sizeof(opts));
3291 opts.event_fn = store_aux_event;
3292 opts.event_fn_data = &store;
3293
3294 /*
3295 * After this, store.parsed will contain offsets of all the
3296 * parsed elements, and store.seen will contain a list of
3297 * matches, as indices into store.parsed.
3298 *
3299 * As a side effect, we make sure to transform only a valid
3300 * existing config file.
3301 */
3302 if (git_config_from_file_with_options(store_aux,
3303 config_filename,
3304 &store, CONFIG_SCOPE_UNKNOWN,
3305 &opts)) {
3306 error(_("invalid config file %s"), config_filename);
3307 ret = CONFIG_INVALID_FILE;
3308 goto out_free;
3309 }
3310
3311 /* if nothing to unset, or too many matches, error out */
3312 if ((store.seen_nr == 0 && value == NULL) ||
3313 (store.seen_nr > 1 && !store.multi_replace)) {
3314 ret = CONFIG_NOTHING_SET;
3315 goto out_free;
3316 }
3317
3318 if (fstat(in_fd, &st) == -1) {
3319 error_errno(_("fstat on %s failed"), config_filename);
3320 ret = CONFIG_INVALID_FILE;
3321 goto out_free;
3322 }
3323
3324 contents_sz = xsize_t(st.st_size);
3325 contents = xmmap_gently(NULL, contents_sz, PROT_READ,
3326 MAP_PRIVATE, in_fd, 0);
3327 if (contents == MAP_FAILED) {
3328 if (errno == ENODEV && S_ISDIR(st.st_mode))
3329 errno = EISDIR;
3330 error_errno(_("unable to mmap '%s'%s"),
3331 config_filename, mmap_os_err());
3332 ret = CONFIG_INVALID_FILE;
3333 contents = NULL;
3334 goto out_free;
3335 }
3336 close(in_fd);
3337 in_fd = -1;
3338
3339 if (chmod(get_lock_file_path(&lock), st.st_mode & 07777) < 0) {
3340 error_errno(_("chmod on %s failed"), get_lock_file_path(&lock));
3341 ret = CONFIG_NO_WRITE;
3342 goto out_free;
3343 }
3344
3345 if (store.seen_nr == 0) {
3346 if (!store.seen_alloc) {
3347 /* Did not see key nor section */
3348 ALLOC_GROW(store.seen, 1, store.seen_alloc);
3349 store.seen[0] = store.parsed_nr
3350 - !!store.parsed_nr;
3351 }
3352 store.seen_nr = 1;
3353 }
3354
3355 for (i = 0, copy_begin = 0; i < store.seen_nr; i++) {
3356 size_t replace_end;
3357 int j = store.seen[i];
3358
3359 new_line = 0;
3360 if (!store.key_seen) {
3361 copy_end = store.parsed[j].end;
3362 /* include '\n' when copying section header */
3363 if (copy_end > 0 && copy_end < contents_sz &&
3364 contents[copy_end - 1] != '\n' &&
3365 contents[copy_end] == '\n')
3366 copy_end++;
3367 replace_end = copy_end;
3368 } else {
3369 replace_end = store.parsed[j].end;
3370 copy_end = store.parsed[j].begin;
3371 if (!value)
3372 maybe_remove_section(&store,
3373 &copy_end,
3374 &replace_end, &i);
3375 /*
3376 * Swallow preceding white-space on the same
3377 * line.
3378 */
3379 while (copy_end > 0 ) {
3380 char c = contents[copy_end - 1];
3381
3382 if (isspace(c) && c != '\n')
3383 copy_end--;
3384 else
3385 break;
3386 }
3387 }
3388
3389 if (copy_end > 0 && contents[copy_end-1] != '\n')
3390 new_line = 1;
3391
3392 /* write the first part of the config */
3393 if (copy_end > copy_begin) {
3394 if (write_in_full(fd, contents + copy_begin,
3395 copy_end - copy_begin) < 0)
3396 goto write_err_out;
3397 if (new_line &&
3398 write_str_in_full(fd, "\n") < 0)
3399 goto write_err_out;
3400 }
3401 copy_begin = replace_end;
3402 }
3403
3404 /* write the pair (value == NULL means unset) */
3405 if (value) {
3406 if (!store.section_seen) {
3407 if (write_section(fd, key, &store) < 0)
3408 goto write_err_out;
3409 }
3410 if (write_pair(fd, key, value, comment, &store) < 0)
3411 goto write_err_out;
3412 }
3413
3414 /* write the rest of the config */
3415 if (copy_begin < contents_sz)
3416 if (write_in_full(fd, contents + copy_begin,
3417 contents_sz - copy_begin) < 0)
3418 goto write_err_out;
3419
3420 munmap(contents, contents_sz);
3421 contents = NULL;
3422 }
3423
3424 if (commit_lock_file(&lock) < 0) {
3425 error_errno(_("could not write config file %s"), config_filename);
3426 ret = CONFIG_NO_WRITE;
3427 goto out_free;
3428 }
3429
3430 ret = 0;
3431
3432 /* Invalidate the config cache */
3433 repo_config_clear(r);
3434
3435 out_free:
3436 rollback_lock_file(&lock);
3437 free(filename_buf);
3438 if (contents)
3439 munmap(contents, contents_sz);
3440 if (in_fd >= 0)
3441 close(in_fd);
3442 config_store_data_clear(&store);
3443 return ret;
3444
3445 write_err_out:
3446 ret = write_error(get_lock_file_path(&lock));
3447 goto out_free;
3448 }
3449
3450 void repo_config_set_multivar_in_file(struct repository *r,
3451 const char *config_filename,
3452 const char *key, const char *value,
3453 const char *value_pattern, unsigned flags)
3454 {
3455 if (!repo_config_set_multivar_in_file_gently(r, config_filename, key, value,
3456 value_pattern, NULL, flags))
3457 return;
3458 if (value)
3459 die(_("could not set '%s' to '%s'"), key, value);
3460 else
3461 die(_("could not unset '%s'"), key);
3462 }
3463
3464 int repo_config_set_multivar_gently(struct repository *r, const char *key,
3465 const char *value,
3466 const char *value_pattern, unsigned flags)
3467 {
3468 char *file = repo_git_path(r, "config");
3469 int res = repo_config_set_multivar_in_file_gently(r, file,
3470 key, value,
3471 value_pattern,
3472 NULL, flags);
3473 free(file);
3474 return res;
3475 }
3476
3477 void repo_config_set_multivar(struct repository *r,
3478 const char *key, const char *value,
3479 const char *value_pattern, unsigned flags)
3480 {
3481 char *file = repo_git_path(r, "config");
3482 repo_config_set_multivar_in_file(r, file, key, value,
3483 value_pattern, flags);
3484 free(file);
3485 }
3486
3487 static size_t section_name_match (const char *buf, const char *name)
3488 {
3489 size_t i = 0, j = 0;
3490 int dot = 0;
3491 if (buf[i] != '[')
3492 return 0;
3493 for (i = 1; buf[i] && buf[i] != ']'; i++) {
3494 if (!dot && isspace(buf[i])) {
3495 dot = 1;
3496 if (name[j++] != '.')
3497 break;
3498 for (i++; isspace(buf[i]); i++)
3499 ; /* do nothing */
3500 if (buf[i] != '"')
3501 break;
3502 continue;
3503 }
3504 if (buf[i] == '\\' && dot)
3505 i++;
3506 else if (buf[i] == '"' && dot) {
3507 for (i++; isspace(buf[i]); i++)
3508 ; /* do_nothing */
3509 break;
3510 }
3511 if (buf[i] != name[j++])
3512 break;
3513 }
3514 if (buf[i] == ']' && name[j] == 0) {
3515 /*
3516 * We match, now just find the right length offset by
3517 * gobbling up any whitespace after it, as well
3518 */
3519 i++;
3520 for (; buf[i] && isspace(buf[i]); i++)
3521 ; /* do nothing */
3522 return i;
3523 }
3524 return 0;
3525 }
3526
3527 static int section_name_is_ok(const char *name)
3528 {
3529 /* Empty section names are bogus. */
3530 if (!*name)
3531 return 0;
3532
3533 /*
3534 * Before a dot, we must be alphanumeric or dash. After the first dot,
3535 * anything goes, so we can stop checking.
3536 */
3537 for (; *name && *name != '.'; name++)
3538 if (*name != '-' && !isalnum(*name))
3539 return 0;
3540 return 1;
3541 }
3542
3543 #define GIT_CONFIG_MAX_LINE_LEN (512 * 1024)
3544
3545 /* if new_name == NULL, the section is removed instead */
3546 static int repo_config_copy_or_rename_section_in_file(
3547 struct repository *r,
3548 const char *config_filename,
3549 const char *old_name,
3550 const char *new_name, int copy)
3551 {
3552 int ret = 0, remove = 0;
3553 char *filename_buf = NULL;
3554 struct lock_file lock = LOCK_INIT;
3555 int out_fd;
3556 struct strbuf buf = STRBUF_INIT;
3557 FILE *config_file = NULL;
3558 struct stat st;
3559 struct strbuf copystr = STRBUF_INIT;
3560 struct config_store_data store;
3561 uint32_t line_nr = 0;
3562
3563 memset(&store, 0, sizeof(store));
3564
3565 if (new_name && !section_name_is_ok(new_name)) {
3566 ret = error(_("invalid section name: %s"), new_name);
3567 goto out_no_rollback;
3568 }
3569
3570 if (!config_filename)
3571 config_filename = filename_buf = repo_git_path(r, "config");
3572
3573 out_fd = hold_lock_file_for_update(&lock, config_filename, 0);
3574 if (out_fd < 0) {
3575 ret = error(_("could not lock config file %s"), config_filename);
3576 goto out;
3577 }
3578
3579 if (!(config_file = fopen(config_filename, "rb"))) {
3580 ret = warn_on_fopen_errors(config_filename);
3581 if (ret)
3582 goto out;
3583 /* no config file means nothing to rename, no error */
3584 goto commit_and_out;
3585 }
3586
3587 if (fstat(fileno(config_file), &st) == -1) {
3588 ret = error_errno(_("fstat on %s failed"), config_filename);
3589 goto out;
3590 }
3591
3592 if (chmod(get_lock_file_path(&lock), st.st_mode & 07777) < 0) {
3593 ret = error_errno(_("chmod on %s failed"),
3594 get_lock_file_path(&lock));
3595 goto out;
3596 }
3597
3598 while (!strbuf_getwholeline(&buf, config_file, '\n')) {
3599 size_t i, length;
3600 int is_section = 0;
3601 char *output = buf.buf;
3602
3603 line_nr++;
3604
3605 if (buf.len >= GIT_CONFIG_MAX_LINE_LEN) {
3606 ret = error(_("refusing to work with overly long line "
3607 "in '%s' on line %"PRIuMAX),
3608 config_filename, (uintmax_t)line_nr);
3609 goto out;
3610 }
3611
3612 for (i = 0; buf.buf[i] && isspace(buf.buf[i]); i++)
3613 ; /* do nothing */
3614 if (buf.buf[i] == '[') {
3615 /* it's a section */
3616 size_t offset;
3617 is_section = 1;
3618
3619 /*
3620 * When encountering a new section under -c we
3621 * need to flush out any section we're already
3622 * coping and begin anew. There might be
3623 * multiple [branch "$name"] sections.
3624 */
3625 if (copystr.len > 0) {
3626 if (write_in_full(out_fd, copystr.buf, copystr.len) < 0) {
3627 ret = write_error(get_lock_file_path(&lock));
3628 goto out;
3629 }
3630 strbuf_reset(&copystr);
3631 }
3632
3633 offset = section_name_match(&buf.buf[i], old_name);
3634 if (offset > 0) {
3635 ret++;
3636 if (!new_name) {
3637 remove = 1;
3638 continue;
3639 }
3640 store.baselen = strlen(new_name);
3641 if (!copy) {
3642 if (write_section(out_fd, new_name, &store) < 0) {
3643 ret = write_error(get_lock_file_path(&lock));
3644 goto out;
3645 }
3646 /*
3647 * We wrote out the new section, with
3648 * a newline, now skip the old
3649 * section's length
3650 */
3651 output += offset + i;
3652 if (strlen(output) > 0) {
3653 /*
3654 * More content means there's
3655 * a declaration to put on the
3656 * next line; indent with a
3657 * tab
3658 */
3659 output -= 1;
3660 output[0] = '\t';
3661 }
3662 } else {
3663 strbuf_release(&copystr);
3664 copystr = store_create_section(new_name, &store);
3665 }
3666 }
3667 remove = 0;
3668 }
3669 if (remove)
3670 continue;
3671 length = strlen(output);
3672
3673 if (!is_section && copystr.len > 0) {
3674 strbuf_add(&copystr, output, length);
3675 }
3676
3677 if (write_in_full(out_fd, output, length) < 0) {
3678 ret = write_error(get_lock_file_path(&lock));
3679 goto out;
3680 }
3681 }
3682
3683 /*
3684 * Copy a trailing section at the end of the config, won't be
3685 * flushed by the usual "flush because we have a new section
3686 * logic in the loop above.
3687 */
3688 if (copystr.len > 0) {
3689 if (write_in_full(out_fd, copystr.buf, copystr.len) < 0) {
3690 ret = write_error(get_lock_file_path(&lock));
3691 goto out;
3692 }
3693 strbuf_reset(&copystr);
3694 }
3695
3696 fclose(config_file);
3697 config_file = NULL;
3698 commit_and_out:
3699 if (commit_lock_file(&lock) < 0)
3700 ret = error_errno(_("could not write config file %s"),
3701 config_filename);
3702 out:
3703 if (config_file)
3704 fclose(config_file);
3705 rollback_lock_file(&lock);
3706 out_no_rollback:
3707 free(filename_buf);
3708 config_store_data_clear(&store);
3709 strbuf_release(&buf);
3710 strbuf_release(&copystr);
3711 return ret;
3712 }
3713
3714 int repo_config_rename_section_in_file(struct repository *r, const char *config_filename,
3715 const char *old_name, const char *new_name)
3716 {
3717 return repo_config_copy_or_rename_section_in_file(r, config_filename,
3718 old_name, new_name, 0);
3719 }
3720
3721 int repo_config_rename_section(struct repository *r, const char *old_name, const char *new_name)
3722 {
3723 return repo_config_rename_section_in_file(r, NULL, old_name, new_name);
3724 }
3725
3726 int repo_config_copy_section_in_file(struct repository *r, const char *config_filename,
3727 const char *old_name, const char *new_name)
3728 {
3729 return repo_config_copy_or_rename_section_in_file(r, config_filename,
3730 old_name, new_name, 1);
3731 }
3732
3733 int repo_config_copy_section(struct repository *r, const char *old_name, const char *new_name)
3734 {
3735 return repo_config_copy_section_in_file(r, NULL, old_name, new_name);
3736 }
3737
3738 /*
3739 * Call this to report error for your variable that should not
3740 * get a boolean value (i.e. "[my] var" means "true").
3741 */
3742 #undef config_error_nonbool
3743 int config_error_nonbool(const char *var)
3744 {
3745 return error(_("missing value for '%s'"), var);
3746 }
3747
3748 int parse_config_key(const char *var,
3749 const char *section,
3750 const char **subsection, size_t *subsection_len,
3751 const char **key)
3752 {
3753 const char *dot;
3754
3755 /* Does it start with "section." ? */
3756 if (!skip_prefix(var, section, &var) || *var != '.')
3757 return -1;
3758
3759 /*
3760 * Find the key; we don't know yet if we have a subsection, but we must
3761 * parse backwards from the end, since the subsection may have dots in
3762 * it, too.
3763 */
3764 dot = strrchr(var, '.');
3765 *key = dot + 1;
3766
3767 /* Did we have a subsection at all? */
3768 if (dot == var) {
3769 if (subsection) {
3770 *subsection = NULL;
3771 *subsection_len = 0;
3772 }
3773 }
3774 else {
3775 if (!subsection)
3776 return -1;
3777 *subsection = var + 1;
3778 *subsection_len = dot - *subsection;
3779 }
3780
3781 return 0;
3782 }
3783
3784 const char *config_origin_type_name(enum config_origin_type type)
3785 {
3786 switch (type) {
3787 case CONFIG_ORIGIN_BLOB:
3788 return "blob";
3789 case CONFIG_ORIGIN_FILE:
3790 return "file";
3791 case CONFIG_ORIGIN_STDIN:
3792 return "standard input";
3793 case CONFIG_ORIGIN_SUBMODULE_BLOB:
3794 return "submodule-blob";
3795 case CONFIG_ORIGIN_CMDLINE:
3796 return "command line";
3797 default:
3798 BUG("unknown config origin type");
3799 }
3800 }
3801
3802 const char *config_scope_name(enum config_scope scope)
3803 {
3804 switch (scope) {
3805 case CONFIG_SCOPE_SYSTEM:
3806 return "system";
3807 case CONFIG_SCOPE_GLOBAL:
3808 return "global";
3809 case CONFIG_SCOPE_LOCAL:
3810 return "local";
3811 case CONFIG_SCOPE_WORKTREE:
3812 return "worktree";
3813 case CONFIG_SCOPE_COMMAND:
3814 return "command";
3815 case CONFIG_SCOPE_SUBMODULE:
3816 return "submodule";
3817 default:
3818 return "unknown";
3819 }
3820 }
3821
3822 int lookup_config(const char **mapping, int nr_mapping, const char *var)
3823 {
3824 int i;
3825
3826 for (i = 0; i < nr_mapping; i++) {
3827 const char *name = mapping[i];
3828
3829 if (name && !strcasecmp(var, name))
3830 return i;
3831 }
3832 return -1;
3833 }
Mirror of Junio's Git repository with all the branches