git.oblomov.eu Git - git/blob - config.c

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