2 * GIT - The information manager from hell
4 * Copyright (C) Linus Torvalds, 2005
5 * Copyright (C) Johannes Schindelin, 2005
8 #include "git-compat-util.h"
16 #include "environment.h"
19 #include "repository.h"
26 #include "string-list.h"
27 #include "object-name.h"
28 #include "object-store.h"
33 #include "replace-object.h"
40 #include "write-or-die.h"
42 struct config_source
{
43 struct config_source
*prev
;
52 enum config_origin_type origin_type
;
55 enum config_error_action default_error_action
;
61 unsigned subsection_case_sensitive
: 1;
63 int (*do_fgetc
)(struct config_source
*c
);
64 int (*do_ungetc
)(int c
, struct config_source
*conf
);
65 long (*do_ftell
)(struct config_source
*c
);
67 #define CONFIG_SOURCE_INIT { 0 }
69 struct config_reader
{
71 * These members record the "current" config source, which can be
72 * accessed by parsing callbacks.
74 * The "source" variable will be non-NULL only when we are actually
75 * parsing a real config source (file, blob, cmdline, etc).
77 * The "config_kvi" variable will be non-NULL only when we are feeding
78 * cached config from a configset into a callback.
80 * They cannot be non-NULL at the same time. If they are both NULL, then
81 * we aren't parsing anything (and depending on the function looking at
82 * the variables, it's either a bug for it to be called in the first
83 * place, or it's a function which can be reused for non-config
84 * purposes, and should fall back to some sane behavior).
86 struct config_source
*source
;
87 struct key_value_info
*config_kvi
;
89 * The "scope" of the current config source being parsed (repo, global,
90 * etc). Like "source", this is only set when parsing a config source.
91 * It's not part of "source" because it transcends a single file (i.e.,
92 * a file included from .git/config is still in "repo" scope).
94 * When iterating through a configset, the equivalent value is
95 * "config_kvi.scope" (see above).
97 enum config_scope parsing_scope
;
100 * Where possible, prefer to accept "struct config_reader" as an arg than to use
101 * "the_reader". "the_reader" should only be used if that is infeasible, e.g. in
104 static struct config_reader the_reader
;
106 static inline void config_reader_push_source(struct config_reader
*reader
,
107 struct config_source
*top
)
109 if (reader
->config_kvi
)
110 BUG("source should not be set while iterating a config set");
111 top
->prev
= reader
->source
;
112 reader
->source
= top
;
115 static inline struct config_source
*config_reader_pop_source(struct config_reader
*reader
)
117 struct config_source
*ret
;
119 BUG("tried to pop config source, but we weren't reading config");
120 ret
= reader
->source
;
121 reader
->source
= reader
->source
->prev
;
125 static inline void config_reader_set_kvi(struct config_reader
*reader
,
126 struct key_value_info
*kvi
)
128 if (kvi
&& (reader
->source
|| reader
->parsing_scope
))
129 BUG("kvi should not be set while parsing a config source");
130 reader
->config_kvi
= kvi
;
133 static inline void config_reader_set_scope(struct config_reader
*reader
,
134 enum config_scope scope
)
136 if (scope
&& reader
->config_kvi
)
137 BUG("scope should only be set when iterating through a config source");
138 reader
->parsing_scope
= scope
;
141 static int pack_compression_seen
;
142 static int zlib_compression_seen
;
145 * Config that comes from trusted scopes, namely:
146 * - CONFIG_SCOPE_SYSTEM (e.g. /etc/gitconfig)
147 * - CONFIG_SCOPE_GLOBAL (e.g. $HOME/.gitconfig, $XDG_CONFIG_HOME/git)
148 * - CONFIG_SCOPE_COMMAND (e.g. "-c" option, environment variables)
150 * This is declared here for code cleanliness, but unlike the other
151 * static variables, this does not hold config parser state.
153 static struct config_set protected_config
;
155 static int config_file_fgetc(struct config_source
*conf
)
157 return getc_unlocked(conf
->u
.file
);
160 static int config_file_ungetc(int c
, struct config_source
*conf
)
162 return ungetc(c
, conf
->u
.file
);
165 static long config_file_ftell(struct config_source
*conf
)
167 return ftell(conf
->u
.file
);
171 static int config_buf_fgetc(struct config_source
*conf
)
173 if (conf
->u
.buf
.pos
< conf
->u
.buf
.len
)
174 return conf
->u
.buf
.buf
[conf
->u
.buf
.pos
++];
179 static int config_buf_ungetc(int c
, struct config_source
*conf
)
181 if (conf
->u
.buf
.pos
> 0) {
183 if (conf
->u
.buf
.buf
[conf
->u
.buf
.pos
] != c
)
184 BUG("config_buf can only ungetc the same character");
191 static long config_buf_ftell(struct config_source
*conf
)
193 return conf
->u
.buf
.pos
;
196 struct config_include_data
{
200 const struct config_options
*opts
;
201 struct git_config_source
*config_source
;
202 struct config_reader
*config_reader
;
205 * All remote URLs discovered when reading all config files.
207 struct string_list
*remote_urls
;
209 #define CONFIG_INCLUDE_INIT { 0 }
211 static int git_config_include(const char *var
, const char *value
, void *data
);
213 #define MAX_INCLUDE_DEPTH 10
214 static const char include_depth_advice
[] = N_(
215 "exceeded maximum include depth (%d) while including\n"
219 "This might be due to circular includes.");
220 static int handle_path_include(struct config_source
*cs
, const char *path
,
221 struct config_include_data
*inc
)
224 struct strbuf buf
= STRBUF_INIT
;
228 return config_error_nonbool("include.path");
230 expanded
= interpolate_path(path
, 0);
232 return error(_("could not expand include path '%s'"), path
);
236 * Use an absolute path as-is, but interpret relative paths
237 * based on the including config file.
239 if (!is_absolute_path(path
)) {
242 if (!cs
|| !cs
->path
) {
243 ret
= error(_("relative config includes must come from files"));
247 slash
= find_last_dir_sep(cs
->path
);
249 strbuf_add(&buf
, cs
->path
, slash
- cs
->path
+ 1);
250 strbuf_addstr(&buf
, path
);
254 if (!access_or_die(path
, R_OK
, 0)) {
255 if (++inc
->depth
> MAX_INCLUDE_DEPTH
)
256 die(_(include_depth_advice
), MAX_INCLUDE_DEPTH
, path
,
258 cs
->name
? cs
->name
:
260 ret
= git_config_from_file(git_config_include
, path
, inc
);
264 strbuf_release(&buf
);
269 static void add_trailing_starstar_for_dir(struct strbuf
*pat
)
271 if (pat
->len
&& is_dir_sep(pat
->buf
[pat
->len
- 1]))
272 strbuf_addstr(pat
, "**");
275 static int prepare_include_condition_pattern(struct config_source
*cs
,
278 struct strbuf path
= STRBUF_INIT
;
282 expanded
= interpolate_path(pat
->buf
, 1);
285 strbuf_addstr(pat
, expanded
);
289 if (pat
->buf
[0] == '.' && is_dir_sep(pat
->buf
[1])) {
292 if (!cs
|| !cs
->path
)
293 return error(_("relative config include "
294 "conditionals must come from files"));
296 strbuf_realpath(&path
, cs
->path
, 1);
297 slash
= find_last_dir_sep(path
.buf
);
299 BUG("how is this possible?");
300 strbuf_splice(pat
, 0, 1, path
.buf
, slash
- path
.buf
);
301 prefix
= slash
- path
.buf
+ 1 /* slash */;
302 } else if (!is_absolute_path(pat
->buf
))
303 strbuf_insertstr(pat
, 0, "**/");
305 add_trailing_starstar_for_dir(pat
);
307 strbuf_release(&path
);
311 static int include_by_gitdir(struct config_source
*cs
,
312 const struct config_options
*opts
,
313 const char *cond
, size_t cond_len
, int icase
)
315 struct strbuf text
= STRBUF_INIT
;
316 struct strbuf pattern
= STRBUF_INIT
;
319 int already_tried_absolute
= 0;
322 git_dir
= opts
->git_dir
;
326 strbuf_realpath(&text
, git_dir
, 1);
327 strbuf_add(&pattern
, cond
, cond_len
);
328 prefix
= prepare_include_condition_pattern(cs
, &pattern
);
336 * perform literal matching on the prefix part so that
337 * any wildcard character in it can't create side effects.
339 if (text
.len
< prefix
)
341 if (!icase
&& strncmp(pattern
.buf
, text
.buf
, prefix
))
343 if (icase
&& strncasecmp(pattern
.buf
, text
.buf
, prefix
))
347 ret
= !wildmatch(pattern
.buf
+ prefix
, text
.buf
+ prefix
,
348 WM_PATHNAME
| (icase
? WM_CASEFOLD
: 0));
350 if (!ret
&& !already_tried_absolute
) {
352 * We've tried e.g. matching gitdir:~/work, but if
353 * ~/work is a symlink to /mnt/storage/work
354 * strbuf_realpath() will expand it, so the rule won't
355 * match. Let's match against a
356 * strbuf_add_absolute_path() version of the path,
357 * which'll do the right thing
360 strbuf_add_absolute_path(&text
, git_dir
);
361 already_tried_absolute
= 1;
365 strbuf_release(&pattern
);
366 strbuf_release(&text
);
370 static int include_by_branch(const char *cond
, size_t cond_len
)
374 struct strbuf pattern
= STRBUF_INIT
;
375 const char *refname
= !the_repository
->gitdir
?
376 NULL
: resolve_ref_unsafe("HEAD", 0, NULL
, &flags
);
377 const char *shortname
;
379 if (!refname
|| !(flags
& REF_ISSYMREF
) ||
380 !skip_prefix(refname
, "refs/heads/", &shortname
))
383 strbuf_add(&pattern
, cond
, cond_len
);
384 add_trailing_starstar_for_dir(&pattern
);
385 ret
= !wildmatch(pattern
.buf
, shortname
, WM_PATHNAME
);
386 strbuf_release(&pattern
);
390 static int add_remote_url(const char *var
, const char *value
, void *data
)
392 struct string_list
*remote_urls
= data
;
393 const char *remote_name
;
394 size_t remote_name_len
;
397 if (!parse_config_key(var
, "remote", &remote_name
, &remote_name_len
,
401 string_list_append(remote_urls
, value
);
405 static void populate_remote_urls(struct config_include_data
*inc
)
407 struct config_options opts
;
409 enum config_scope store_scope
= inc
->config_reader
->parsing_scope
;
412 opts
.unconditional_remote_url
= 1;
414 config_reader_set_scope(inc
->config_reader
, 0);
416 inc
->remote_urls
= xmalloc(sizeof(*inc
->remote_urls
));
417 string_list_init_dup(inc
->remote_urls
);
418 config_with_options(add_remote_url
, inc
->remote_urls
, inc
->config_source
, &opts
);
420 config_reader_set_scope(inc
->config_reader
, store_scope
);
423 static int forbid_remote_url(const char *var
, const char *value UNUSED
,
426 const char *remote_name
;
427 size_t remote_name_len
;
430 if (!parse_config_key(var
, "remote", &remote_name
, &remote_name_len
,
434 die(_("remote URLs cannot be configured in file directly or indirectly included by includeIf.hasconfig:remote.*.url"));
438 static int at_least_one_url_matches_glob(const char *glob
, int glob_len
,
439 struct string_list
*remote_urls
)
441 struct strbuf pattern
= STRBUF_INIT
;
442 struct string_list_item
*url_item
;
445 strbuf_add(&pattern
, glob
, glob_len
);
446 for_each_string_list_item(url_item
, remote_urls
) {
447 if (!wildmatch(pattern
.buf
, url_item
->string
, WM_PATHNAME
)) {
452 strbuf_release(&pattern
);
456 static int include_by_remote_url(struct config_include_data
*inc
,
457 const char *cond
, size_t cond_len
)
459 if (inc
->opts
->unconditional_remote_url
)
461 if (!inc
->remote_urls
)
462 populate_remote_urls(inc
);
463 return at_least_one_url_matches_glob(cond
, cond_len
,
467 static int include_condition_is_true(struct config_source
*cs
,
468 struct config_include_data
*inc
,
469 const char *cond
, size_t cond_len
)
471 const struct config_options
*opts
= inc
->opts
;
473 if (skip_prefix_mem(cond
, cond_len
, "gitdir:", &cond
, &cond_len
))
474 return include_by_gitdir(cs
, opts
, cond
, cond_len
, 0);
475 else if (skip_prefix_mem(cond
, cond_len
, "gitdir/i:", &cond
, &cond_len
))
476 return include_by_gitdir(cs
, opts
, cond
, cond_len
, 1);
477 else if (skip_prefix_mem(cond
, cond_len
, "onbranch:", &cond
, &cond_len
))
478 return include_by_branch(cond
, cond_len
);
479 else if (skip_prefix_mem(cond
, cond_len
, "hasconfig:remote.*.url:", &cond
,
481 return include_by_remote_url(inc
, cond
, cond_len
);
483 /* unknown conditionals are always false */
487 static int git_config_include(const char *var
, const char *value
, void *data
)
489 struct config_include_data
*inc
= data
;
490 struct config_source
*cs
= inc
->config_reader
->source
;
491 const char *cond
, *key
;
496 * Pass along all values, including "include" directives; this makes it
497 * possible to query information on the includes themselves.
499 ret
= inc
->fn(var
, value
, inc
->data
);
503 if (!strcmp(var
, "include.path"))
504 ret
= handle_path_include(cs
, value
, inc
);
506 if (!parse_config_key(var
, "includeif", &cond
, &cond_len
, &key
) &&
507 cond
&& include_condition_is_true(cs
, inc
, cond
, cond_len
) &&
508 !strcmp(key
, "path")) {
509 config_fn_t old_fn
= inc
->fn
;
511 if (inc
->opts
->unconditional_remote_url
)
512 inc
->fn
= forbid_remote_url
;
513 ret
= handle_path_include(cs
, value
, inc
);
520 static void git_config_push_split_parameter(const char *key
, const char *value
)
522 struct strbuf env
= STRBUF_INIT
;
523 const char *old
= getenv(CONFIG_DATA_ENVIRONMENT
);
525 strbuf_addstr(&env
, old
);
526 strbuf_addch(&env
, ' ');
528 sq_quote_buf(&env
, key
);
529 strbuf_addch(&env
, '=');
531 sq_quote_buf(&env
, value
);
532 setenv(CONFIG_DATA_ENVIRONMENT
, env
.buf
, 1);
533 strbuf_release(&env
);
536 void git_config_push_parameter(const char *text
)
543 * section.subsection=with=equals.key=value
545 * we cannot tell if it means:
547 * [section "subsection=with=equals"]
553 * subsection = with=equals.key=value
555 * We parse left-to-right for the first "=", meaning we'll prefer to
556 * keep the value intact over the subsection. This is historical, but
557 * also sensible since values are more likely to contain odd or
558 * untrusted input than a section name.
560 * A missing equals is explicitly allowed (as a bool-only entry).
562 value
= strchr(text
, '=');
564 char *key
= xmemdupz(text
, value
- text
);
565 git_config_push_split_parameter(key
, value
+ 1);
568 git_config_push_split_parameter(text
, NULL
);
572 void git_config_push_env(const char *spec
)
575 const char *env_name
;
576 const char *env_value
;
578 env_name
= strrchr(spec
, '=');
580 die(_("invalid config format: %s"), spec
);
581 key
= xmemdupz(spec
, env_name
- spec
);
584 die(_("missing environment variable name for configuration '%.*s'"),
585 (int)(env_name
- spec
- 1), spec
);
587 env_value
= getenv(env_name
);
589 die(_("missing environment variable '%s' for configuration '%.*s'"),
590 env_name
, (int)(env_name
- spec
- 1), spec
);
592 git_config_push_split_parameter(key
, env_value
);
596 static inline int iskeychar(int c
)
598 return isalnum(c
) || c
== '-';
602 * Auxiliary function to sanity-check and split the key into the section
603 * identifier and variable name.
605 * Returns 0 on success, -1 when there is an invalid character in the key and
606 * -2 if there is no section name in the key.
608 * store_key - pointer to char* which will hold a copy of the key with
609 * lowercase section and variable name
610 * baselen - pointer to size_t which will hold the length of the
611 * section + subsection part, can be NULL
613 int git_config_parse_key(const char *key
, char **store_key
, size_t *baselen_
)
617 const char *last_dot
= strrchr(key
, '.');
620 * Since "key" actually contains the section name and the real
621 * key name separated by a dot, we have to know where the dot is.
624 if (last_dot
== NULL
|| last_dot
== key
) {
625 error(_("key does not contain a section: %s"), key
);
626 return -CONFIG_NO_SECTION_OR_NAME
;
630 error(_("key does not contain variable name: %s"), key
);
631 return -CONFIG_NO_SECTION_OR_NAME
;
634 baselen
= last_dot
- key
;
639 * Validate the key and while at it, lower case it for matching.
641 *store_key
= xmallocz(strlen(key
));
644 for (i
= 0; key
[i
]; i
++) {
645 unsigned char c
= key
[i
];
648 /* Leave the extended basename untouched.. */
649 if (!dot
|| i
> baselen
) {
651 (i
== baselen
+ 1 && !isalpha(c
))) {
652 error(_("invalid key: %s"), key
);
656 } else if (c
== '\n') {
657 error(_("invalid key (newline): %s"), key
);
666 FREE_AND_NULL(*store_key
);
667 return -CONFIG_INVALID_KEY
;
670 static int config_parse_pair(const char *key
, const char *value
,
671 config_fn_t fn
, void *data
)
673 char *canonical_name
;
677 return error(_("empty config key"));
678 if (git_config_parse_key(key
, &canonical_name
, NULL
))
681 ret
= (fn(canonical_name
, value
, data
) < 0) ? -1 : 0;
682 free(canonical_name
);
686 int git_config_parse_parameter(const char *text
,
687 config_fn_t fn
, void *data
)
690 struct strbuf
**pair
;
693 pair
= strbuf_split_str(text
, '=', 2);
695 return error(_("bogus config parameter: %s"), text
);
697 if (pair
[0]->len
&& pair
[0]->buf
[pair
[0]->len
- 1] == '=') {
698 strbuf_setlen(pair
[0], pair
[0]->len
- 1);
699 value
= pair
[1] ? pair
[1]->buf
: "";
704 strbuf_trim(pair
[0]);
706 strbuf_list_free(pair
);
707 return error(_("bogus config parameter: %s"), text
);
710 ret
= config_parse_pair(pair
[0]->buf
, value
, fn
, data
);
711 strbuf_list_free(pair
);
715 static int parse_config_env_list(char *env
, config_fn_t fn
, void *data
)
718 while (cur
&& *cur
) {
719 const char *key
= sq_dequote_step(cur
, &cur
);
721 return error(_("bogus format in %s"),
722 CONFIG_DATA_ENVIRONMENT
);
724 if (!cur
|| isspace(*cur
)) {
725 /* old-style 'key=value' */
726 if (git_config_parse_parameter(key
, fn
, data
) < 0)
729 else if (*cur
== '=') {
730 /* new-style 'key'='value' */
736 value
= sq_dequote_step(cur
, &cur
);
737 if (!value
|| (cur
&& !isspace(*cur
))) {
738 return error(_("bogus format in %s"),
739 CONFIG_DATA_ENVIRONMENT
);
741 } else if (!*cur
|| isspace(*cur
)) {
742 /* implicit bool: 'key'= */
745 return error(_("bogus format in %s"),
746 CONFIG_DATA_ENVIRONMENT
);
749 if (config_parse_pair(key
, value
, fn
, data
) < 0)
754 return error(_("bogus format in %s"),
755 CONFIG_DATA_ENVIRONMENT
);
759 while (isspace(*cur
))
766 int git_config_from_parameters(config_fn_t fn
, void *data
)
769 struct strbuf envvar
= STRBUF_INIT
;
770 struct strvec to_free
= STRVEC_INIT
;
773 struct config_source source
= CONFIG_SOURCE_INIT
;
775 source
.origin_type
= CONFIG_ORIGIN_CMDLINE
;
776 config_reader_push_source(&the_reader
, &source
);
778 env
= getenv(CONFIG_COUNT_ENVIRONMENT
);
784 count
= strtoul(env
, &endp
, 10);
786 ret
= error(_("bogus count in %s"), CONFIG_COUNT_ENVIRONMENT
);
789 if (count
> INT_MAX
) {
790 ret
= error(_("too many entries in %s"), CONFIG_COUNT_ENVIRONMENT
);
794 for (i
= 0; i
< count
; i
++) {
795 const char *key
, *value
;
797 strbuf_addf(&envvar
, "GIT_CONFIG_KEY_%d", i
);
798 key
= getenv_safe(&to_free
, envvar
.buf
);
800 ret
= error(_("missing config key %s"), envvar
.buf
);
803 strbuf_reset(&envvar
);
805 strbuf_addf(&envvar
, "GIT_CONFIG_VALUE_%d", i
);
806 value
= getenv_safe(&to_free
, envvar
.buf
);
808 ret
= error(_("missing config value %s"), envvar
.buf
);
811 strbuf_reset(&envvar
);
813 if (config_parse_pair(key
, value
, fn
, data
) < 0) {
820 env
= getenv(CONFIG_DATA_ENVIRONMENT
);
822 /* sq_dequote will write over it */
824 if (parse_config_env_list(envw
, fn
, data
) < 0) {
831 strbuf_release(&envvar
);
832 strvec_clear(&to_free
);
834 config_reader_pop_source(&the_reader
);
838 static int get_next_char(struct config_source
*cs
)
840 int c
= cs
->do_fgetc(cs
);
843 /* DOS like systems */
844 c
= cs
->do_fgetc(cs
);
847 cs
->do_ungetc(c
, cs
);
852 if (c
!= EOF
&& ++cs
->total_len
> INT_MAX
) {
854 * This is an absurdly long config file; refuse to parse
855 * further in order to protect downstream code from integer
856 * overflows. Note that we can't return an error specifically,
857 * but we can mark EOF and put trash in the return value,
858 * which will trigger a parse error.
874 static char *parse_value(struct config_source
*cs
)
876 int quote
= 0, comment
= 0, space
= 0;
878 strbuf_reset(&cs
->value
);
880 int c
= get_next_char(cs
);
886 return cs
->value
.buf
;
890 if (isspace(c
) && !quote
) {
896 if (c
== ';' || c
== '#') {
901 for (; space
; space
--)
902 strbuf_addch(&cs
->value
, ' ');
904 c
= get_next_char(cs
);
917 /* Some characters escape as themselves */
920 /* Reject unknown escape sequences */
924 strbuf_addch(&cs
->value
, c
);
931 strbuf_addch(&cs
->value
, c
);
935 static int get_value(struct config_source
*cs
, config_fn_t fn
, void *data
,
942 /* Get the full name */
944 c
= get_next_char(cs
);
949 strbuf_addch(name
, tolower(c
));
952 while (c
== ' ' || c
== '\t')
953 c
= get_next_char(cs
);
959 value
= parse_value(cs
);
964 * We already consumed the \n, but we need linenr to point to
965 * the line we just parsed during the call to fn to get
966 * accurate line number in error messages.
969 ret
= fn(name
->buf
, value
, data
);
975 static int get_extended_base_var(struct config_source
*cs
, struct strbuf
*name
,
978 cs
->subsection_case_sensitive
= 0;
981 goto error_incomplete_line
;
982 c
= get_next_char(cs
);
983 } while (isspace(c
));
985 /* We require the format to be '[base "extension"]' */
988 strbuf_addch(name
, '.');
991 int c
= get_next_char(cs
);
993 goto error_incomplete_line
;
997 c
= get_next_char(cs
);
999 goto error_incomplete_line
;
1001 strbuf_addch(name
, c
);
1005 if (get_next_char(cs
) != ']')
1008 error_incomplete_line
:
1013 static int get_base_var(struct config_source
*cs
, struct strbuf
*name
)
1015 cs
->subsection_case_sensitive
= 1;
1017 int c
= get_next_char(cs
);
1023 return get_extended_base_var(cs
, name
, c
);
1024 if (!iskeychar(c
) && c
!= '.')
1026 strbuf_addch(name
, tolower(c
));
1030 struct parse_event_data
{
1031 enum config_event_t previous_type
;
1032 size_t previous_offset
;
1033 const struct config_options
*opts
;
1036 static int do_event(struct config_source
*cs
, enum config_event_t type
,
1037 struct parse_event_data
*data
)
1041 if (!data
->opts
|| !data
->opts
->event_fn
)
1044 if (type
== CONFIG_EVENT_WHITESPACE
&&
1045 data
->previous_type
== type
)
1048 offset
= cs
->do_ftell(cs
);
1050 * At EOF, the parser always "inserts" an extra '\n', therefore
1051 * the end offset of the event is the current file position, otherwise
1052 * we will already have advanced to the next event.
1054 if (type
!= CONFIG_EVENT_EOF
)
1057 if (data
->previous_type
!= CONFIG_EVENT_EOF
&&
1058 data
->opts
->event_fn(data
->previous_type
, data
->previous_offset
,
1059 offset
, data
->opts
->event_fn_data
) < 0)
1062 data
->previous_type
= type
;
1063 data
->previous_offset
= offset
;
1068 static int git_parse_source(struct config_source
*cs
, config_fn_t fn
,
1069 void *data
, const struct config_options
*opts
)
1073 struct strbuf
*var
= &cs
->var
;
1074 int error_return
= 0;
1075 char *error_msg
= NULL
;
1077 /* U+FEFF Byte Order Mark in UTF8 */
1078 const char *bomptr
= utf8_bom
;
1080 /* For the parser event callback */
1081 struct parse_event_data event_data
= {
1082 CONFIG_EVENT_EOF
, 0, opts
1088 c
= get_next_char(cs
);
1089 if (bomptr
&& *bomptr
) {
1090 /* We are at the file beginning; skip UTF8-encoded BOM
1091 * if present. Sane editors won't put this in on their
1092 * own, but e.g. Windows Notepad will do it happily. */
1093 if (c
== (*bomptr
& 0377)) {
1097 /* Do not tolerate partial BOM. */
1098 if (bomptr
!= utf8_bom
)
1100 /* No BOM at file beginning. Cool. */
1106 if (do_event(cs
, CONFIG_EVENT_EOF
, &event_data
) < 0)
1110 if (do_event(cs
, CONFIG_EVENT_WHITESPACE
, &event_data
) < 0)
1118 if (do_event(cs
, CONFIG_EVENT_WHITESPACE
, &event_data
) < 0)
1122 if (c
== '#' || c
== ';') {
1123 if (do_event(cs
, CONFIG_EVENT_COMMENT
, &event_data
) < 0)
1129 if (do_event(cs
, CONFIG_EVENT_SECTION
, &event_data
) < 0)
1132 /* Reset prior to determining a new stem */
1134 if (get_base_var(cs
, var
) < 0 || var
->len
< 1)
1136 strbuf_addch(var
, '.');
1143 if (do_event(cs
, CONFIG_EVENT_ENTRY
, &event_data
) < 0)
1147 * Truncate the var name back to the section header
1148 * stem prior to grabbing the suffix part of the name
1151 strbuf_setlen(var
, baselen
);
1152 strbuf_addch(var
, tolower(c
));
1153 if (get_value(cs
, fn
, data
, var
) < 0)
1157 if (do_event(cs
, CONFIG_EVENT_ERROR
, &event_data
) < 0)
1160 switch (cs
->origin_type
) {
1161 case CONFIG_ORIGIN_BLOB
:
1162 error_msg
= xstrfmt(_("bad config line %d in blob %s"),
1163 cs
->linenr
, cs
->name
);
1165 case CONFIG_ORIGIN_FILE
:
1166 error_msg
= xstrfmt(_("bad config line %d in file %s"),
1167 cs
->linenr
, cs
->name
);
1169 case CONFIG_ORIGIN_STDIN
:
1170 error_msg
= xstrfmt(_("bad config line %d in standard input"),
1173 case CONFIG_ORIGIN_SUBMODULE_BLOB
:
1174 error_msg
= xstrfmt(_("bad config line %d in submodule-blob %s"),
1175 cs
->linenr
, cs
->name
);
1177 case CONFIG_ORIGIN_CMDLINE
:
1178 error_msg
= xstrfmt(_("bad config line %d in command line %s"),
1179 cs
->linenr
, cs
->name
);
1182 error_msg
= xstrfmt(_("bad config line %d in %s"),
1183 cs
->linenr
, cs
->name
);
1186 switch (opts
&& opts
->error_action
?
1187 opts
->error_action
:
1188 cs
->default_error_action
) {
1189 case CONFIG_ERROR_DIE
:
1190 die("%s", error_msg
);
1192 case CONFIG_ERROR_ERROR
:
1193 error_return
= error("%s", error_msg
);
1195 case CONFIG_ERROR_SILENT
:
1198 case CONFIG_ERROR_UNSET
:
1199 BUG("config error action unset");
1203 return error_return
;
1206 static uintmax_t get_unit_factor(const char *end
)
1210 else if (!strcasecmp(end
, "k"))
1212 else if (!strcasecmp(end
, "m"))
1214 else if (!strcasecmp(end
, "g"))
1215 return 1024 * 1024 * 1024;
1219 static int git_parse_signed(const char *value
, intmax_t *ret
, intmax_t max
)
1221 if (value
&& *value
) {
1227 BUG("max must be a positive integer");
1230 val
= strtoimax(value
, &end
, 0);
1231 if (errno
== ERANGE
)
1237 factor
= get_unit_factor(end
);
1242 if ((val
< 0 && -max
/ factor
> val
) ||
1243 (val
> 0 && max
/ factor
< val
)) {
1255 static int git_parse_unsigned(const char *value
, uintmax_t *ret
, uintmax_t max
)
1257 if (value
&& *value
) {
1262 /* negative values would be accepted by strtoumax */
1263 if (strchr(value
, '-')) {
1268 val
= strtoumax(value
, &end
, 0);
1269 if (errno
== ERANGE
)
1275 factor
= get_unit_factor(end
);
1280 if (unsigned_mult_overflows(factor
, val
) ||
1281 factor
* val
> max
) {
1293 int git_parse_int(const char *value
, int *ret
)
1296 if (!git_parse_signed(value
, &tmp
, maximum_signed_value_of_type(int)))
1302 static int git_parse_int64(const char *value
, int64_t *ret
)
1305 if (!git_parse_signed(value
, &tmp
, maximum_signed_value_of_type(int64_t)))
1311 int git_parse_ulong(const char *value
, unsigned long *ret
)
1314 if (!git_parse_unsigned(value
, &tmp
, maximum_unsigned_value_of_type(long)))
1320 int git_parse_ssize_t(const char *value
, ssize_t
*ret
)
1323 if (!git_parse_signed(value
, &tmp
, maximum_signed_value_of_type(ssize_t
)))
1329 static int reader_config_name(struct config_reader
*reader
, const char **out
);
1330 static int reader_origin_type(struct config_reader
*reader
,
1331 enum config_origin_type
*type
);
1333 static void die_bad_number(struct config_reader
*reader
, const char *name
,
1336 const char *error_type
= (errno
== ERANGE
) ?
1337 N_("out of range") : N_("invalid unit");
1338 const char *bad_numeric
= N_("bad numeric config value '%s' for '%s': %s");
1339 const char *config_name
= NULL
;
1340 enum config_origin_type config_origin
= CONFIG_ORIGIN_UNKNOWN
;
1345 /* Ignoring the return value is okay since we handle missing values. */
1346 reader_config_name(reader
, &config_name
);
1347 reader_origin_type(reader
, &config_origin
);
1350 die(_(bad_numeric
), value
, name
, _(error_type
));
1352 switch (config_origin
) {
1353 case CONFIG_ORIGIN_BLOB
:
1354 die(_("bad numeric config value '%s' for '%s' in blob %s: %s"),
1355 value
, name
, config_name
, _(error_type
));
1356 case CONFIG_ORIGIN_FILE
:
1357 die(_("bad numeric config value '%s' for '%s' in file %s: %s"),
1358 value
, name
, config_name
, _(error_type
));
1359 case CONFIG_ORIGIN_STDIN
:
1360 die(_("bad numeric config value '%s' for '%s' in standard input: %s"),
1361 value
, name
, _(error_type
));
1362 case CONFIG_ORIGIN_SUBMODULE_BLOB
:
1363 die(_("bad numeric config value '%s' for '%s' in submodule-blob %s: %s"),
1364 value
, name
, config_name
, _(error_type
));
1365 case CONFIG_ORIGIN_CMDLINE
:
1366 die(_("bad numeric config value '%s' for '%s' in command line %s: %s"),
1367 value
, name
, config_name
, _(error_type
));
1369 die(_("bad numeric config value '%s' for '%s' in %s: %s"),
1370 value
, name
, config_name
, _(error_type
));
1374 int git_config_int(const char *name
, const char *value
)
1377 if (!git_parse_int(value
, &ret
))
1378 die_bad_number(&the_reader
, name
, value
);
1382 int64_t git_config_int64(const char *name
, const char *value
)
1385 if (!git_parse_int64(value
, &ret
))
1386 die_bad_number(&the_reader
, name
, value
);
1390 unsigned long git_config_ulong(const char *name
, const char *value
)
1393 if (!git_parse_ulong(value
, &ret
))
1394 die_bad_number(&the_reader
, name
, value
);
1398 ssize_t
git_config_ssize_t(const char *name
, const char *value
)
1401 if (!git_parse_ssize_t(value
, &ret
))
1402 die_bad_number(&the_reader
, name
, value
);
1406 static int git_parse_maybe_bool_text(const char *value
)
1412 if (!strcasecmp(value
, "true")
1413 || !strcasecmp(value
, "yes")
1414 || !strcasecmp(value
, "on"))
1416 if (!strcasecmp(value
, "false")
1417 || !strcasecmp(value
, "no")
1418 || !strcasecmp(value
, "off"))
1423 static const struct fsync_component_name
{
1425 enum fsync_component component_bits
;
1426 } fsync_component_names
[] = {
1427 { "loose-object", FSYNC_COMPONENT_LOOSE_OBJECT
},
1428 { "pack", FSYNC_COMPONENT_PACK
},
1429 { "pack-metadata", FSYNC_COMPONENT_PACK_METADATA
},
1430 { "commit-graph", FSYNC_COMPONENT_COMMIT_GRAPH
},
1431 { "index", FSYNC_COMPONENT_INDEX
},
1432 { "objects", FSYNC_COMPONENTS_OBJECTS
},
1433 { "reference", FSYNC_COMPONENT_REFERENCE
},
1434 { "derived-metadata", FSYNC_COMPONENTS_DERIVED_METADATA
},
1435 { "committed", FSYNC_COMPONENTS_COMMITTED
},
1436 { "added", FSYNC_COMPONENTS_ADDED
},
1437 { "all", FSYNC_COMPONENTS_ALL
},
1440 static enum fsync_component
parse_fsync_components(const char *var
, const char *string
)
1442 enum fsync_component current
= FSYNC_COMPONENTS_PLATFORM_DEFAULT
;
1443 enum fsync_component positive
= 0, negative
= 0;
1452 string
= string
+ strspn(string
, ", \t\n\r");
1453 ep
= strchrnul(string
, ',');
1455 if (!strcmp(string
, "none")) {
1456 current
= FSYNC_COMPONENT_NONE
;
1460 if (*string
== '-') {
1465 warning(_("invalid value for variable %s"), var
);
1471 for (i
= 0; i
< ARRAY_SIZE(fsync_component_names
); ++i
) {
1472 const struct fsync_component_name
*n
= &fsync_component_names
[i
];
1474 if (strncmp(n
->name
, string
, len
))
1479 negative
|= n
->component_bits
;
1481 positive
|= n
->component_bits
;
1485 char *component
= xstrndup(string
, len
);
1486 warning(_("ignoring unknown core.fsync component '%s'"), component
);
1494 return (current
& ~negative
) | positive
;
1497 int git_parse_maybe_bool(const char *value
)
1499 int v
= git_parse_maybe_bool_text(value
);
1502 if (git_parse_int(value
, &v
))
1507 int git_config_bool_or_int(const char *name
, const char *value
, int *is_bool
)
1509 int v
= git_parse_maybe_bool_text(value
);
1515 return git_config_int(name
, value
);
1518 int git_config_bool(const char *name
, const char *value
)
1520 int v
= git_parse_maybe_bool(value
);
1522 die(_("bad boolean config value '%s' for '%s'"), value
, name
);
1526 int git_config_string(const char **dest
, const char *var
, const char *value
)
1529 return config_error_nonbool(var
);
1530 *dest
= xstrdup(value
);
1534 int git_config_pathname(const char **dest
, const char *var
, const char *value
)
1537 return config_error_nonbool(var
);
1538 *dest
= interpolate_path(value
, 0);
1540 die(_("failed to expand user dir in: '%s'"), value
);
1544 int git_config_expiry_date(timestamp_t
*timestamp
, const char *var
, const char *value
)
1547 return config_error_nonbool(var
);
1548 if (parse_expiry_date(value
, timestamp
))
1549 return error(_("'%s' for '%s' is not a valid timestamp"),
1554 int git_config_color(char *dest
, const char *var
, const char *value
)
1557 return config_error_nonbool(var
);
1558 if (color_parse(value
, dest
) < 0)
1563 static int git_default_core_config(const char *var
, const char *value
, void *cb
)
1565 /* This needs a better name */
1566 if (!strcmp(var
, "core.filemode")) {
1567 trust_executable_bit
= git_config_bool(var
, value
);
1570 if (!strcmp(var
, "core.trustctime")) {
1571 trust_ctime
= git_config_bool(var
, value
);
1574 if (!strcmp(var
, "core.checkstat")) {
1575 if (!strcasecmp(value
, "default"))
1577 else if (!strcasecmp(value
, "minimal"))
1581 if (!strcmp(var
, "core.quotepath")) {
1582 quote_path_fully
= git_config_bool(var
, value
);
1586 if (!strcmp(var
, "core.symlinks")) {
1587 has_symlinks
= git_config_bool(var
, value
);
1591 if (!strcmp(var
, "core.ignorecase")) {
1592 ignore_case
= git_config_bool(var
, value
);
1596 if (!strcmp(var
, "core.attributesfile"))
1597 return git_config_pathname(&git_attributes_file
, var
, value
);
1599 if (!strcmp(var
, "core.hookspath")) {
1600 if (current_config_scope() == CONFIG_SCOPE_LOCAL
&&
1601 git_env_bool("GIT_CLONE_PROTECTION_ACTIVE", 0))
1602 die(_("active `core.hooksPath` found in the local "
1603 "repository config:\n\t%s\nFor security "
1604 "reasons, this is disallowed by default.\nIf "
1605 "this is intentional and the hook should "
1606 "actually be run, please\nrun the command "
1608 "`GIT_CLONE_PROTECTION_ACTIVE=false`"),
1610 return git_config_pathname(&git_hooks_path
, var
, value
);
1613 if (!strcmp(var
, "core.bare")) {
1614 is_bare_repository_cfg
= git_config_bool(var
, value
);
1618 if (!strcmp(var
, "core.ignorestat")) {
1619 assume_unchanged
= git_config_bool(var
, value
);
1623 if (!strcmp(var
, "core.prefersymlinkrefs")) {
1624 prefer_symlink_refs
= git_config_bool(var
, value
);
1628 if (!strcmp(var
, "core.logallrefupdates")) {
1629 if (value
&& !strcasecmp(value
, "always"))
1630 log_all_ref_updates
= LOG_REFS_ALWAYS
;
1631 else if (git_config_bool(var
, value
))
1632 log_all_ref_updates
= LOG_REFS_NORMAL
;
1634 log_all_ref_updates
= LOG_REFS_NONE
;
1638 if (!strcmp(var
, "core.warnambiguousrefs")) {
1639 warn_ambiguous_refs
= git_config_bool(var
, value
);
1643 if (!strcmp(var
, "core.abbrev")) {
1645 return config_error_nonbool(var
);
1646 if (!strcasecmp(value
, "auto"))
1647 default_abbrev
= -1;
1648 else if (!git_parse_maybe_bool_text(value
))
1649 default_abbrev
= the_hash_algo
->hexsz
;
1651 int abbrev
= git_config_int(var
, value
);
1652 if (abbrev
< minimum_abbrev
|| abbrev
> the_hash_algo
->hexsz
)
1653 return error(_("abbrev length out of range: %d"), abbrev
);
1654 default_abbrev
= abbrev
;
1659 if (!strcmp(var
, "core.disambiguate"))
1660 return set_disambiguate_hint_config(var
, value
);
1662 if (!strcmp(var
, "core.loosecompression")) {
1663 int level
= git_config_int(var
, value
);
1665 level
= Z_DEFAULT_COMPRESSION
;
1666 else if (level
< 0 || level
> Z_BEST_COMPRESSION
)
1667 die(_("bad zlib compression level %d"), level
);
1668 zlib_compression_level
= level
;
1669 zlib_compression_seen
= 1;
1673 if (!strcmp(var
, "core.compression")) {
1674 int level
= git_config_int(var
, value
);
1676 level
= Z_DEFAULT_COMPRESSION
;
1677 else if (level
< 0 || level
> Z_BEST_COMPRESSION
)
1678 die(_("bad zlib compression level %d"), level
);
1679 if (!zlib_compression_seen
)
1680 zlib_compression_level
= level
;
1681 if (!pack_compression_seen
)
1682 pack_compression_level
= level
;
1686 if (!strcmp(var
, "core.packedgitwindowsize")) {
1687 int pgsz_x2
= getpagesize() * 2;
1688 packed_git_window_size
= git_config_ulong(var
, value
);
1690 /* This value must be multiple of (pagesize * 2) */
1691 packed_git_window_size
/= pgsz_x2
;
1692 if (packed_git_window_size
< 1)
1693 packed_git_window_size
= 1;
1694 packed_git_window_size
*= pgsz_x2
;
1698 if (!strcmp(var
, "core.bigfilethreshold")) {
1699 big_file_threshold
= git_config_ulong(var
, value
);
1703 if (!strcmp(var
, "core.packedgitlimit")) {
1704 packed_git_limit
= git_config_ulong(var
, value
);
1708 if (!strcmp(var
, "core.deltabasecachelimit")) {
1709 delta_base_cache_limit
= git_config_ulong(var
, value
);
1713 if (!strcmp(var
, "core.autocrlf")) {
1714 if (value
&& !strcasecmp(value
, "input")) {
1715 auto_crlf
= AUTO_CRLF_INPUT
;
1718 auto_crlf
= git_config_bool(var
, value
);
1722 if (!strcmp(var
, "core.safecrlf")) {
1724 if (value
&& !strcasecmp(value
, "warn")) {
1725 global_conv_flags_eol
= CONV_EOL_RNDTRP_WARN
;
1728 eol_rndtrp_die
= git_config_bool(var
, value
);
1729 global_conv_flags_eol
= eol_rndtrp_die
?
1730 CONV_EOL_RNDTRP_DIE
: 0;
1734 if (!strcmp(var
, "core.eol")) {
1735 if (value
&& !strcasecmp(value
, "lf"))
1737 else if (value
&& !strcasecmp(value
, "crlf"))
1738 core_eol
= EOL_CRLF
;
1739 else if (value
&& !strcasecmp(value
, "native"))
1740 core_eol
= EOL_NATIVE
;
1742 core_eol
= EOL_UNSET
;
1746 if (!strcmp(var
, "core.checkroundtripencoding")) {
1747 check_roundtrip_encoding
= xstrdup(value
);
1751 if (!strcmp(var
, "core.notesref")) {
1752 notes_ref_name
= xstrdup(value
);
1756 if (!strcmp(var
, "core.editor"))
1757 return git_config_string(&editor_program
, var
, value
);
1759 if (!strcmp(var
, "core.commentchar")) {
1761 return config_error_nonbool(var
);
1762 else if (!strcasecmp(value
, "auto"))
1763 auto_comment_line_char
= 1;
1764 else if (value
[0] && !value
[1]) {
1765 comment_line_char
= value
[0];
1766 auto_comment_line_char
= 0;
1768 return error(_("core.commentChar should only be one ASCII character"));
1772 if (!strcmp(var
, "core.askpass"))
1773 return git_config_string(&askpass_program
, var
, value
);
1775 if (!strcmp(var
, "core.excludesfile"))
1776 return git_config_pathname(&excludes_file
, var
, value
);
1778 if (!strcmp(var
, "core.whitespace")) {
1780 return config_error_nonbool(var
);
1781 whitespace_rule_cfg
= parse_whitespace_rule(value
);
1785 if (!strcmp(var
, "core.fsync")) {
1787 return config_error_nonbool(var
);
1788 fsync_components
= parse_fsync_components(var
, value
);
1792 if (!strcmp(var
, "core.fsyncmethod")) {
1794 return config_error_nonbool(var
);
1795 if (!strcmp(value
, "fsync"))
1796 fsync_method
= FSYNC_METHOD_FSYNC
;
1797 else if (!strcmp(value
, "writeout-only"))
1798 fsync_method
= FSYNC_METHOD_WRITEOUT_ONLY
;
1799 else if (!strcmp(value
, "batch"))
1800 fsync_method
= FSYNC_METHOD_BATCH
;
1802 warning(_("ignoring unknown core.fsyncMethod value '%s'"), value
);
1806 if (!strcmp(var
, "core.fsyncobjectfiles")) {
1807 if (fsync_object_files
< 0)
1808 warning(_("core.fsyncObjectFiles is deprecated; use core.fsync instead"));
1809 fsync_object_files
= git_config_bool(var
, value
);
1813 if (!strcmp(var
, "core.preloadindex")) {
1814 core_preload_index
= git_config_bool(var
, value
);
1818 if (!strcmp(var
, "core.createobject")) {
1819 if (!strcmp(value
, "rename"))
1820 object_creation_mode
= OBJECT_CREATION_USES_RENAMES
;
1821 else if (!strcmp(value
, "link"))
1822 object_creation_mode
= OBJECT_CREATION_USES_HARDLINKS
;
1824 die(_("invalid mode for object creation: %s"), value
);
1828 if (!strcmp(var
, "core.sparsecheckout")) {
1829 core_apply_sparse_checkout
= git_config_bool(var
, value
);
1833 if (!strcmp(var
, "core.sparsecheckoutcone")) {
1834 core_sparse_checkout_cone
= git_config_bool(var
, value
);
1838 if (!strcmp(var
, "core.precomposeunicode")) {
1839 precomposed_unicode
= git_config_bool(var
, value
);
1843 if (!strcmp(var
, "core.protecthfs")) {
1844 protect_hfs
= git_config_bool(var
, value
);
1848 if (!strcmp(var
, "core.protectntfs")) {
1849 protect_ntfs
= git_config_bool(var
, value
);
1853 if (!strcmp(var
, "core.usereplacerefs")) {
1854 read_replace_refs
= git_config_bool(var
, value
);
1858 /* Add other config variables here and to Documentation/config.txt. */
1859 return platform_core_config(var
, value
, cb
);
1862 static int git_default_sparse_config(const char *var
, const char *value
)
1864 if (!strcmp(var
, "sparse.expectfilesoutsideofpatterns")) {
1865 sparse_expect_files_outside_of_patterns
= git_config_bool(var
, value
);
1869 /* Add other config variables here and to Documentation/config/sparse.txt. */
1873 static int git_default_i18n_config(const char *var
, const char *value
)
1875 if (!strcmp(var
, "i18n.commitencoding"))
1876 return git_config_string(&git_commit_encoding
, var
, value
);
1878 if (!strcmp(var
, "i18n.logoutputencoding"))
1879 return git_config_string(&git_log_output_encoding
, var
, value
);
1881 /* Add other config variables here and to Documentation/config.txt. */
1885 static int git_default_branch_config(const char *var
, const char *value
)
1887 if (!strcmp(var
, "branch.autosetupmerge")) {
1888 if (value
&& !strcmp(value
, "always")) {
1889 git_branch_track
= BRANCH_TRACK_ALWAYS
;
1891 } else if (value
&& !strcmp(value
, "inherit")) {
1892 git_branch_track
= BRANCH_TRACK_INHERIT
;
1894 } else if (value
&& !strcmp(value
, "simple")) {
1895 git_branch_track
= BRANCH_TRACK_SIMPLE
;
1898 git_branch_track
= git_config_bool(var
, value
);
1901 if (!strcmp(var
, "branch.autosetuprebase")) {
1903 return config_error_nonbool(var
);
1904 else if (!strcmp(value
, "never"))
1905 autorebase
= AUTOREBASE_NEVER
;
1906 else if (!strcmp(value
, "local"))
1907 autorebase
= AUTOREBASE_LOCAL
;
1908 else if (!strcmp(value
, "remote"))
1909 autorebase
= AUTOREBASE_REMOTE
;
1910 else if (!strcmp(value
, "always"))
1911 autorebase
= AUTOREBASE_ALWAYS
;
1913 return error(_("malformed value for %s"), var
);
1917 /* Add other config variables here and to Documentation/config.txt. */
1921 static int git_default_push_config(const char *var
, const char *value
)
1923 if (!strcmp(var
, "push.default")) {
1925 return config_error_nonbool(var
);
1926 else if (!strcmp(value
, "nothing"))
1927 push_default
= PUSH_DEFAULT_NOTHING
;
1928 else if (!strcmp(value
, "matching"))
1929 push_default
= PUSH_DEFAULT_MATCHING
;
1930 else if (!strcmp(value
, "simple"))
1931 push_default
= PUSH_DEFAULT_SIMPLE
;
1932 else if (!strcmp(value
, "upstream"))
1933 push_default
= PUSH_DEFAULT_UPSTREAM
;
1934 else if (!strcmp(value
, "tracking")) /* deprecated */
1935 push_default
= PUSH_DEFAULT_UPSTREAM
;
1936 else if (!strcmp(value
, "current"))
1937 push_default
= PUSH_DEFAULT_CURRENT
;
1939 error(_("malformed value for %s: %s"), var
, value
);
1940 return error(_("must be one of nothing, matching, simple, "
1941 "upstream or current"));
1946 /* Add other config variables here and to Documentation/config.txt. */
1950 static int git_default_mailmap_config(const char *var
, const char *value
)
1952 if (!strcmp(var
, "mailmap.file"))
1953 return git_config_pathname(&git_mailmap_file
, var
, value
);
1954 if (!strcmp(var
, "mailmap.blob"))
1955 return git_config_string(&git_mailmap_blob
, var
, value
);
1957 /* Add other config variables here and to Documentation/config.txt. */
1961 int git_default_config(const char *var
, const char *value
, void *cb
)
1963 if (starts_with(var
, "core."))
1964 return git_default_core_config(var
, value
, cb
);
1966 if (starts_with(var
, "user.") ||
1967 starts_with(var
, "author.") ||
1968 starts_with(var
, "committer."))
1969 return git_ident_config(var
, value
, cb
);
1971 if (starts_with(var
, "i18n."))
1972 return git_default_i18n_config(var
, value
);
1974 if (starts_with(var
, "branch."))
1975 return git_default_branch_config(var
, value
);
1977 if (starts_with(var
, "push."))
1978 return git_default_push_config(var
, value
);
1980 if (starts_with(var
, "mailmap."))
1981 return git_default_mailmap_config(var
, value
);
1983 if (starts_with(var
, "advice.") || starts_with(var
, "color.advice"))
1984 return git_default_advice_config(var
, value
);
1986 if (!strcmp(var
, "pager.color") || !strcmp(var
, "color.pager")) {
1987 pager_use_color
= git_config_bool(var
,value
);
1991 if (!strcmp(var
, "pack.packsizelimit")) {
1992 pack_size_limit_cfg
= git_config_ulong(var
, value
);
1996 if (!strcmp(var
, "pack.compression")) {
1997 int level
= git_config_int(var
, value
);
1999 level
= Z_DEFAULT_COMPRESSION
;
2000 else if (level
< 0 || level
> Z_BEST_COMPRESSION
)
2001 die(_("bad pack compression level %d"), level
);
2002 pack_compression_level
= level
;
2003 pack_compression_seen
= 1;
2007 if (starts_with(var
, "sparse."))
2008 return git_default_sparse_config(var
, value
);
2010 /* Add other config variables here and to Documentation/config.txt. */
2015 * All source specific fields in the union, die_on_error, name and the callbacks
2016 * fgetc, ungetc, ftell of top need to be initialized before calling
2019 static int do_config_from(struct config_reader
*reader
,
2020 struct config_source
*top
, config_fn_t fn
, void *data
,
2021 const struct config_options
*opts
)
2025 /* push config-file parsing state stack */
2029 strbuf_init(&top
->value
, 1024);
2030 strbuf_init(&top
->var
, 1024);
2031 config_reader_push_source(reader
, top
);
2033 ret
= git_parse_source(top
, fn
, data
, opts
);
2035 /* pop config-file parsing state stack */
2036 strbuf_release(&top
->value
);
2037 strbuf_release(&top
->var
);
2038 config_reader_pop_source(reader
);
2043 static int do_config_from_file(struct config_reader
*reader
,
2045 const enum config_origin_type origin_type
,
2046 const char *name
, const char *path
, FILE *f
,
2047 void *data
, const struct config_options
*opts
)
2049 struct config_source top
= CONFIG_SOURCE_INIT
;
2053 top
.origin_type
= origin_type
;
2056 top
.default_error_action
= CONFIG_ERROR_DIE
;
2057 top
.do_fgetc
= config_file_fgetc
;
2058 top
.do_ungetc
= config_file_ungetc
;
2059 top
.do_ftell
= config_file_ftell
;
2062 ret
= do_config_from(reader
, &top
, fn
, data
, opts
);
2067 static int git_config_from_stdin(config_fn_t fn
, void *data
)
2069 return do_config_from_file(&the_reader
, fn
, CONFIG_ORIGIN_STDIN
, "",
2070 NULL
, stdin
, data
, NULL
);
2073 int git_config_from_file_with_options(config_fn_t fn
, const char *filename
,
2075 const struct config_options
*opts
)
2081 BUG("filename cannot be NULL");
2082 f
= fopen_or_warn(filename
, "r");
2084 ret
= do_config_from_file(&the_reader
, fn
, CONFIG_ORIGIN_FILE
,
2085 filename
, filename
, f
, data
, opts
);
2091 int git_config_from_file(config_fn_t fn
, const char *filename
, void *data
)
2093 return git_config_from_file_with_options(fn
, filename
, data
, NULL
);
2096 int git_config_from_mem(config_fn_t fn
,
2097 const enum config_origin_type origin_type
,
2098 const char *name
, const char *buf
, size_t len
,
2099 void *data
, const struct config_options
*opts
)
2101 struct config_source top
= CONFIG_SOURCE_INIT
;
2103 top
.u
.buf
.buf
= buf
;
2104 top
.u
.buf
.len
= len
;
2106 top
.origin_type
= origin_type
;
2109 top
.default_error_action
= CONFIG_ERROR_ERROR
;
2110 top
.do_fgetc
= config_buf_fgetc
;
2111 top
.do_ungetc
= config_buf_ungetc
;
2112 top
.do_ftell
= config_buf_ftell
;
2114 return do_config_from(&the_reader
, &top
, fn
, data
, opts
);
2117 int git_config_from_blob_oid(config_fn_t fn
,
2119 struct repository
*repo
,
2120 const struct object_id
*oid
,
2123 enum object_type type
;
2128 buf
= repo_read_object_file(repo
, oid
, &type
, &size
);
2130 return error(_("unable to load config blob object '%s'"), name
);
2131 if (type
!= OBJ_BLOB
) {
2133 return error(_("reference '%s' does not point to a blob"), name
);
2136 ret
= git_config_from_mem(fn
, CONFIG_ORIGIN_BLOB
, name
, buf
, size
,
2143 static int git_config_from_blob_ref(config_fn_t fn
,
2144 struct repository
*repo
,
2148 struct object_id oid
;
2150 if (repo_get_oid(repo
, name
, &oid
) < 0)
2151 return error(_("unable to resolve config blob '%s'"), name
);
2152 return git_config_from_blob_oid(fn
, name
, repo
, &oid
, data
);
2155 char *git_system_config(void)
2157 char *system_config
= xstrdup_or_null(getenv("GIT_CONFIG_SYSTEM"));
2159 system_config
= system_path(ETC_GITCONFIG
);
2160 normalize_path_copy(system_config
, system_config
);
2161 return system_config
;
2164 void git_global_config(char **user_out
, char **xdg_out
)
2166 char *user_config
= xstrdup_or_null(getenv("GIT_CONFIG_GLOBAL"));
2167 char *xdg_config
= NULL
;
2170 user_config
= interpolate_path("~/.gitconfig", 0);
2171 xdg_config
= xdg_config_home("config");
2174 *user_out
= user_config
;
2175 *xdg_out
= xdg_config
;
2179 * Parse environment variable 'k' as a boolean (in various
2180 * possible spellings); if missing, use the default value 'def'.
2182 int git_env_bool(const char *k
, int def
)
2184 const char *v
= getenv(k
);
2185 return v
? git_config_bool(k
, v
) : def
;
2189 * Parse environment variable 'k' as ulong with possibly a unit
2190 * suffix; if missing, use the default value 'val'.
2192 unsigned long git_env_ulong(const char *k
, unsigned long val
)
2194 const char *v
= getenv(k
);
2195 if (v
&& !git_parse_ulong(v
, &val
))
2196 die(_("failed to parse %s"), k
);
2200 int git_config_system(void)
2202 return !git_env_bool("GIT_CONFIG_NOSYSTEM", 0);
2205 static int do_git_config_sequence(struct config_reader
*reader
,
2206 const struct config_options
*opts
,
2207 config_fn_t fn
, void *data
)
2210 char *system_config
= git_system_config();
2211 char *xdg_config
= NULL
;
2212 char *user_config
= NULL
;
2214 enum config_scope prev_parsing_scope
= reader
->parsing_scope
;
2216 if (opts
->commondir
)
2217 repo_config
= mkpathdup("%s/config", opts
->commondir
);
2218 else if (opts
->git_dir
)
2219 BUG("git_dir without commondir");
2223 config_reader_set_scope(reader
, CONFIG_SCOPE_SYSTEM
);
2224 if (git_config_system() && system_config
&&
2225 !access_or_die(system_config
, R_OK
,
2226 opts
->system_gently
? ACCESS_EACCES_OK
: 0))
2227 ret
+= git_config_from_file(fn
, system_config
, data
);
2229 config_reader_set_scope(reader
, CONFIG_SCOPE_GLOBAL
);
2230 git_global_config(&user_config
, &xdg_config
);
2232 if (xdg_config
&& !access_or_die(xdg_config
, R_OK
, ACCESS_EACCES_OK
))
2233 ret
+= git_config_from_file(fn
, xdg_config
, data
);
2235 if (user_config
&& !access_or_die(user_config
, R_OK
, ACCESS_EACCES_OK
))
2236 ret
+= git_config_from_file(fn
, user_config
, data
);
2238 config_reader_set_scope(reader
, CONFIG_SCOPE_LOCAL
);
2239 if (!opts
->ignore_repo
&& repo_config
&&
2240 !access_or_die(repo_config
, R_OK
, 0))
2241 ret
+= git_config_from_file(fn
, repo_config
, data
);
2243 config_reader_set_scope(reader
, CONFIG_SCOPE_WORKTREE
);
2244 if (!opts
->ignore_worktree
&& repository_format_worktree_config
) {
2245 char *path
= git_pathdup("config.worktree");
2246 if (!access_or_die(path
, R_OK
, 0))
2247 ret
+= git_config_from_file(fn
, path
, data
);
2251 config_reader_set_scope(reader
, CONFIG_SCOPE_COMMAND
);
2252 if (!opts
->ignore_cmdline
&& git_config_from_parameters(fn
, data
) < 0)
2253 die(_("unable to parse command-line config"));
2255 config_reader_set_scope(reader
, prev_parsing_scope
);
2256 free(system_config
);
2263 int config_with_options(config_fn_t fn
, void *data
,
2264 struct git_config_source
*config_source
,
2265 const struct config_options
*opts
)
2267 struct config_include_data inc
= CONFIG_INCLUDE_INIT
;
2268 enum config_scope prev_scope
= the_reader
.parsing_scope
;
2271 if (opts
->respect_includes
) {
2275 inc
.config_source
= config_source
;
2276 inc
.config_reader
= &the_reader
;
2277 fn
= git_config_include
;
2282 config_reader_set_scope(&the_reader
, config_source
->scope
);
2285 * If we have a specific filename, use it. Otherwise, follow the
2286 * regular lookup sequence.
2288 if (config_source
&& config_source
->use_stdin
) {
2289 ret
= git_config_from_stdin(fn
, data
);
2290 } else if (config_source
&& config_source
->file
) {
2291 ret
= git_config_from_file(fn
, config_source
->file
, data
);
2292 } else if (config_source
&& config_source
->blob
) {
2293 struct repository
*repo
= config_source
->repo
?
2294 config_source
->repo
: the_repository
;
2295 ret
= git_config_from_blob_ref(fn
, repo
, config_source
->blob
,
2298 ret
= do_git_config_sequence(&the_reader
, opts
, fn
, data
);
2301 if (inc
.remote_urls
) {
2302 string_list_clear(inc
.remote_urls
, 0);
2303 FREE_AND_NULL(inc
.remote_urls
);
2305 config_reader_set_scope(&the_reader
, prev_scope
);
2309 static void configset_iter(struct config_reader
*reader
, struct config_set
*set
,
2310 config_fn_t fn
, void *data
)
2313 struct string_list
*values
;
2314 struct config_set_element
*entry
;
2315 struct configset_list
*list
= &set
->list
;
2317 for (i
= 0; i
< list
->nr
; i
++) {
2318 entry
= list
->items
[i
].e
;
2319 value_index
= list
->items
[i
].value_index
;
2320 values
= &entry
->value_list
;
2322 config_reader_set_kvi(reader
, values
->items
[value_index
].util
);
2324 if (fn(entry
->key
, values
->items
[value_index
].string
, data
) < 0)
2325 git_die_config_linenr(entry
->key
,
2326 reader
->config_kvi
->filename
,
2327 reader
->config_kvi
->linenr
);
2329 config_reader_set_kvi(reader
, NULL
);
2333 void read_early_config(config_fn_t cb
, void *data
)
2335 struct config_options opts
= {0};
2336 struct strbuf commondir
= STRBUF_INIT
;
2337 struct strbuf gitdir
= STRBUF_INIT
;
2339 opts
.respect_includes
= 1;
2341 if (have_git_dir()) {
2342 opts
.commondir
= get_git_common_dir();
2343 opts
.git_dir
= get_git_dir();
2345 * When setup_git_directory() was not yet asked to discover the
2346 * GIT_DIR, we ask discover_git_directory() to figure out whether there
2347 * is any repository config we should use (but unlike
2348 * setup_git_directory_gently(), no global state is changed, most
2349 * notably, the current working directory is still the same after the
2352 } else if (!discover_git_directory(&commondir
, &gitdir
)) {
2353 opts
.commondir
= commondir
.buf
;
2354 opts
.git_dir
= gitdir
.buf
;
2357 config_with_options(cb
, data
, NULL
, &opts
);
2359 strbuf_release(&commondir
);
2360 strbuf_release(&gitdir
);
2364 * Read config but only enumerate system and global settings.
2365 * Omit any repo-local, worktree-local, or command-line settings.
2367 void read_very_early_config(config_fn_t cb
, void *data
)
2369 struct config_options opts
= { 0 };
2371 opts
.respect_includes
= 1;
2372 opts
.ignore_repo
= 1;
2373 opts
.ignore_worktree
= 1;
2374 opts
.ignore_cmdline
= 1;
2375 opts
.system_gently
= 1;
2377 config_with_options(cb
, data
, NULL
, &opts
);
2381 static int configset_find_element(struct config_set
*set
, const char *key
,
2382 struct config_set_element
**dest
)
2384 struct config_set_element k
;
2385 struct config_set_element
*found_entry
;
2386 char *normalized_key
;
2390 * `key` may come from the user, so normalize it before using it
2391 * for querying entries from the hashmap.
2393 ret
= git_config_parse_key(key
, &normalized_key
, NULL
);
2397 hashmap_entry_init(&k
.ent
, strhash(normalized_key
));
2398 k
.key
= normalized_key
;
2399 found_entry
= hashmap_get_entry(&set
->config_hash
, &k
, ent
, NULL
);
2400 free(normalized_key
);
2401 *dest
= found_entry
;
2405 static int configset_add_value(struct config_reader
*reader
,
2406 struct config_set
*set
, const char *key
,
2409 struct config_set_element
*e
;
2410 struct string_list_item
*si
;
2411 struct configset_list_item
*l_item
;
2412 struct key_value_info
*kv_info
= xmalloc(sizeof(*kv_info
));
2415 ret
= configset_find_element(set
, key
, &e
);
2419 * Since the keys are being fed by git_config*() callback mechanism, they
2420 * are already normalized. So simply add them without any further munging.
2423 e
= xmalloc(sizeof(*e
));
2424 hashmap_entry_init(&e
->ent
, strhash(key
));
2425 e
->key
= xstrdup(key
);
2426 string_list_init_dup(&e
->value_list
);
2427 hashmap_add(&set
->config_hash
, &e
->ent
);
2429 si
= string_list_append_nodup(&e
->value_list
, xstrdup_or_null(value
));
2431 ALLOC_GROW(set
->list
.items
, set
->list
.nr
+ 1, set
->list
.alloc
);
2432 l_item
= &set
->list
.items
[set
->list
.nr
++];
2434 l_item
->value_index
= e
->value_list
.nr
- 1;
2436 if (!reader
->source
)
2437 BUG("configset_add_value has no source");
2438 if (reader
->source
->name
) {
2439 kv_info
->filename
= strintern(reader
->source
->name
);
2440 kv_info
->linenr
= reader
->source
->linenr
;
2441 kv_info
->origin_type
= reader
->source
->origin_type
;
2443 /* for values read from `git_config_from_parameters()` */
2444 kv_info
->filename
= NULL
;
2445 kv_info
->linenr
= -1;
2446 kv_info
->origin_type
= CONFIG_ORIGIN_CMDLINE
;
2448 kv_info
->scope
= reader
->parsing_scope
;
2454 static int config_set_element_cmp(const void *cmp_data UNUSED
,
2455 const struct hashmap_entry
*eptr
,
2456 const struct hashmap_entry
*entry_or_key
,
2457 const void *keydata UNUSED
)
2459 const struct config_set_element
*e1
, *e2
;
2461 e1
= container_of(eptr
, const struct config_set_element
, ent
);
2462 e2
= container_of(entry_or_key
, const struct config_set_element
, ent
);
2464 return strcmp(e1
->key
, e2
->key
);
2467 void git_configset_init(struct config_set
*set
)
2469 hashmap_init(&set
->config_hash
, config_set_element_cmp
, NULL
, 0);
2470 set
->hash_initialized
= 1;
2472 set
->list
.alloc
= 0;
2473 set
->list
.items
= NULL
;
2476 void git_configset_clear(struct config_set
*set
)
2478 struct config_set_element
*entry
;
2479 struct hashmap_iter iter
;
2480 if (!set
->hash_initialized
)
2483 hashmap_for_each_entry(&set
->config_hash
, &iter
, entry
,
2484 ent
/* member name */) {
2486 string_list_clear(&entry
->value_list
, 1);
2488 hashmap_clear_and_free(&set
->config_hash
, struct config_set_element
, ent
);
2489 set
->hash_initialized
= 0;
2490 free(set
->list
.items
);
2492 set
->list
.alloc
= 0;
2493 set
->list
.items
= NULL
;
2496 struct configset_add_data
{
2497 struct config_set
*config_set
;
2498 struct config_reader
*config_reader
;
2500 #define CONFIGSET_ADD_INIT { 0 }
2502 static int config_set_callback(const char *key
, const char *value
, void *cb
)
2504 struct configset_add_data
*data
= cb
;
2505 configset_add_value(data
->config_reader
, data
->config_set
, key
, value
);
2509 int git_configset_add_file(struct config_set
*set
, const char *filename
)
2511 struct configset_add_data data
= CONFIGSET_ADD_INIT
;
2512 data
.config_reader
= &the_reader
;
2513 data
.config_set
= set
;
2514 return git_config_from_file(config_set_callback
, filename
, &data
);
2517 int git_configset_get_value(struct config_set
*set
, const char *key
, const char **value
)
2519 const struct string_list
*values
= NULL
;
2523 * Follows "last one wins" semantic, i.e., if there are multiple matches for the
2524 * queried key in the files of the configset, the value returned will be the last
2525 * value in the value list for that key.
2527 if ((ret
= git_configset_get_value_multi(set
, key
, &values
)))
2530 assert(values
->nr
> 0);
2531 *value
= values
->items
[values
->nr
- 1].string
;
2535 int git_configset_get_value_multi(struct config_set
*set
, const char *key
,
2536 const struct string_list
**dest
)
2538 struct config_set_element
*e
;
2541 if ((ret
= configset_find_element(set
, key
, &e
)))
2545 *dest
= &e
->value_list
;
2550 static int check_multi_string(struct string_list_item
*item
, void *util
)
2552 return item
->string
? 0 : config_error_nonbool(util
);
2555 int git_configset_get_string_multi(struct config_set
*cs
, const char *key
,
2556 const struct string_list
**dest
)
2560 if ((ret
= git_configset_get_value_multi(cs
, key
, dest
)))
2562 if ((ret
= for_each_string_list((struct string_list
*)*dest
,
2563 check_multi_string
, (void *)key
)))
2569 int git_configset_get(struct config_set
*set
, const char *key
)
2571 struct config_set_element
*e
;
2574 if ((ret
= configset_find_element(set
, key
, &e
)))
2581 int git_configset_get_string(struct config_set
*set
, const char *key
, char **dest
)
2584 if (!git_configset_get_value(set
, key
, &value
))
2585 return git_config_string((const char **)dest
, key
, value
);
2590 static int git_configset_get_string_tmp(struct config_set
*set
, const char *key
,
2594 if (!git_configset_get_value(set
, key
, &value
)) {
2596 return config_error_nonbool(key
);
2604 int git_configset_get_int(struct config_set
*set
, const char *key
, int *dest
)
2607 if (!git_configset_get_value(set
, key
, &value
)) {
2608 *dest
= git_config_int(key
, value
);
2614 int git_configset_get_ulong(struct config_set
*set
, const char *key
, unsigned long *dest
)
2617 if (!git_configset_get_value(set
, key
, &value
)) {
2618 *dest
= git_config_ulong(key
, value
);
2624 int git_configset_get_bool(struct config_set
*set
, const char *key
, int *dest
)
2627 if (!git_configset_get_value(set
, key
, &value
)) {
2628 *dest
= git_config_bool(key
, value
);
2634 int git_configset_get_bool_or_int(struct config_set
*set
, const char *key
,
2635 int *is_bool
, int *dest
)
2638 if (!git_configset_get_value(set
, key
, &value
)) {
2639 *dest
= git_config_bool_or_int(key
, value
, is_bool
);
2645 int git_configset_get_maybe_bool(struct config_set
*set
, const char *key
, int *dest
)
2648 if (!git_configset_get_value(set
, key
, &value
)) {
2649 *dest
= git_parse_maybe_bool(value
);
2657 int git_configset_get_pathname(struct config_set
*set
, const char *key
, const char **dest
)
2660 if (!git_configset_get_value(set
, key
, &value
))
2661 return git_config_pathname(dest
, key
, value
);
2666 /* Functions use to read configuration from a repository */
2667 static void repo_read_config(struct repository
*repo
)
2669 struct config_options opts
= { 0 };
2670 struct configset_add_data data
= CONFIGSET_ADD_INIT
;
2672 opts
.respect_includes
= 1;
2673 opts
.commondir
= repo
->commondir
;
2674 opts
.git_dir
= repo
->gitdir
;
2677 CALLOC_ARRAY(repo
->config
, 1);
2679 git_configset_clear(repo
->config
);
2681 git_configset_init(repo
->config
);
2682 data
.config_set
= repo
->config
;
2683 data
.config_reader
= &the_reader
;
2685 if (config_with_options(config_set_callback
, &data
, NULL
, &opts
) < 0)
2687 * config_with_options() normally returns only
2688 * zero, as most errors are fatal, and
2689 * non-fatal potential errors are guarded by "if"
2690 * statements that are entered only when no error is
2693 * If we ever encounter a non-fatal error, it means
2694 * something went really wrong and we should stop
2697 die(_("unknown error occurred while reading the configuration files"));
2700 static void git_config_check_init(struct repository
*repo
)
2702 if (repo
->config
&& repo
->config
->hash_initialized
)
2704 repo_read_config(repo
);
2707 static void repo_config_clear(struct repository
*repo
)
2709 if (!repo
->config
|| !repo
->config
->hash_initialized
)
2711 git_configset_clear(repo
->config
);
2714 void repo_config(struct repository
*repo
, config_fn_t fn
, void *data
)
2716 git_config_check_init(repo
);
2717 configset_iter(&the_reader
, repo
->config
, fn
, data
);
2720 int repo_config_get(struct repository
*repo
, const char *key
)
2722 git_config_check_init(repo
);
2723 return git_configset_get(repo
->config
, key
);
2726 int repo_config_get_value(struct repository
*repo
,
2727 const char *key
, const char **value
)
2729 git_config_check_init(repo
);
2730 return git_configset_get_value(repo
->config
, key
, value
);
2733 int repo_config_get_value_multi(struct repository
*repo
, const char *key
,
2734 const struct string_list
**dest
)
2736 git_config_check_init(repo
);
2737 return git_configset_get_value_multi(repo
->config
, key
, dest
);
2740 int repo_config_get_string_multi(struct repository
*repo
, const char *key
,
2741 const struct string_list
**dest
)
2743 git_config_check_init(repo
);
2744 return git_configset_get_string_multi(repo
->config
, key
, dest
);
2747 int repo_config_get_string(struct repository
*repo
,
2748 const char *key
, char **dest
)
2751 git_config_check_init(repo
);
2752 ret
= git_configset_get_string(repo
->config
, key
, dest
);
2754 git_die_config(key
, NULL
);
2758 int repo_config_get_string_tmp(struct repository
*repo
,
2759 const char *key
, const char **dest
)
2762 git_config_check_init(repo
);
2763 ret
= git_configset_get_string_tmp(repo
->config
, key
, dest
);
2765 git_die_config(key
, NULL
);
2769 int repo_config_get_int(struct repository
*repo
,
2770 const char *key
, int *dest
)
2772 git_config_check_init(repo
);
2773 return git_configset_get_int(repo
->config
, key
, dest
);
2776 int repo_config_get_ulong(struct repository
*repo
,
2777 const char *key
, unsigned long *dest
)
2779 git_config_check_init(repo
);
2780 return git_configset_get_ulong(repo
->config
, key
, dest
);
2783 int repo_config_get_bool(struct repository
*repo
,
2784 const char *key
, int *dest
)
2786 git_config_check_init(repo
);
2787 return git_configset_get_bool(repo
->config
, key
, dest
);
2790 int repo_config_get_bool_or_int(struct repository
*repo
,
2791 const char *key
, int *is_bool
, int *dest
)
2793 git_config_check_init(repo
);
2794 return git_configset_get_bool_or_int(repo
->config
, key
, is_bool
, dest
);
2797 int repo_config_get_maybe_bool(struct repository
*repo
,
2798 const char *key
, int *dest
)
2800 git_config_check_init(repo
);
2801 return git_configset_get_maybe_bool(repo
->config
, key
, dest
);
2804 int repo_config_get_pathname(struct repository
*repo
,
2805 const char *key
, const char **dest
)
2808 git_config_check_init(repo
);
2809 ret
= git_configset_get_pathname(repo
->config
, key
, dest
);
2811 git_die_config(key
, NULL
);
2815 /* Read values into protected_config. */
2816 static void read_protected_config(void)
2818 struct config_options opts
= {
2819 .respect_includes
= 1,
2821 .ignore_worktree
= 1,
2824 struct configset_add_data data
= CONFIGSET_ADD_INIT
;
2826 git_configset_init(&protected_config
);
2827 data
.config_set
= &protected_config
;
2828 data
.config_reader
= &the_reader
;
2829 config_with_options(config_set_callback
, &data
, NULL
, &opts
);
2832 void git_protected_config(config_fn_t fn
, void *data
)
2834 if (!protected_config
.hash_initialized
)
2835 read_protected_config();
2836 configset_iter(&the_reader
, &protected_config
, fn
, data
);
2839 /* Functions used historically to read configuration from 'the_repository' */
2840 void git_config(config_fn_t fn
, void *data
)
2842 repo_config(the_repository
, fn
, data
);
2845 void git_config_clear(void)
2847 repo_config_clear(the_repository
);
2850 int git_config_get(const char *key
)
2852 return repo_config_get(the_repository
, key
);
2855 int git_config_get_value(const char *key
, const char **value
)
2857 return repo_config_get_value(the_repository
, key
, value
);
2860 int git_config_get_value_multi(const char *key
, const struct string_list
**dest
)
2862 return repo_config_get_value_multi(the_repository
, key
, dest
);
2865 int git_config_get_string_multi(const char *key
,
2866 const struct string_list
**dest
)
2868 return repo_config_get_string_multi(the_repository
, key
, dest
);
2871 int git_config_get_string(const char *key
, char **dest
)
2873 return repo_config_get_string(the_repository
, key
, dest
);
2876 int git_config_get_string_tmp(const char *key
, const char **dest
)
2878 return repo_config_get_string_tmp(the_repository
, key
, dest
);
2881 int git_config_get_int(const char *key
, int *dest
)
2883 return repo_config_get_int(the_repository
, key
, dest
);
2886 int git_config_get_ulong(const char *key
, unsigned long *dest
)
2888 return repo_config_get_ulong(the_repository
, key
, dest
);
2891 int git_config_get_bool(const char *key
, int *dest
)
2893 return repo_config_get_bool(the_repository
, key
, dest
);
2896 int git_config_get_bool_or_int(const char *key
, int *is_bool
, int *dest
)
2898 return repo_config_get_bool_or_int(the_repository
, key
, is_bool
, dest
);
2901 int git_config_get_maybe_bool(const char *key
, int *dest
)
2903 return repo_config_get_maybe_bool(the_repository
, key
, dest
);
2906 int git_config_get_pathname(const char *key
, const char **dest
)
2908 return repo_config_get_pathname(the_repository
, key
, dest
);
2911 int git_config_get_expiry(const char *key
, const char **output
)
2913 int ret
= git_config_get_string(key
, (char **)output
);
2916 if (strcmp(*output
, "now")) {
2917 timestamp_t now
= approxidate("now");
2918 if (approxidate(*output
) >= now
)
2919 git_die_config(key
, _("Invalid %s: '%s'"), key
, *output
);
2924 int git_config_get_expiry_in_days(const char *key
, timestamp_t
*expiry
, timestamp_t now
)
2926 const char *expiry_string
;
2930 if (git_config_get_string_tmp(key
, &expiry_string
))
2931 return 1; /* no such thing */
2933 if (git_parse_signed(expiry_string
, &days
, maximum_signed_value_of_type(int))) {
2934 const int scale
= 86400;
2935 *expiry
= now
- days
* scale
;
2939 if (!parse_expiry_date(expiry_string
, &when
)) {
2943 return -1; /* thing exists but cannot be parsed */
2946 int git_config_get_split_index(void)
2950 if (!git_config_get_maybe_bool("core.splitindex", &val
))
2953 return -1; /* default value */
2956 int git_config_get_max_percent_split_change(void)
2960 if (!git_config_get_int("splitindex.maxpercentchange", &val
)) {
2961 if (0 <= val
&& val
<= 100)
2964 return error(_("splitIndex.maxPercentChange value '%d' "
2965 "should be between 0 and 100"), val
);
2968 return -1; /* default value */
2971 int git_config_get_index_threads(int *dest
)
2975 val
= git_env_ulong("GIT_TEST_INDEX_THREADS", 0);
2981 if (!git_config_get_bool_or_int("index.threads", &is_bool
, &val
)) {
2983 *dest
= val
? 0 : 1;
2993 void git_die_config_linenr(const char *key
, const char *filename
, int linenr
)
2996 die(_("unable to parse '%s' from command-line config"), key
);
2998 die(_("bad config variable '%s' in file '%s' at line %d"),
2999 key
, filename
, linenr
);
3002 NORETURN
__attribute__((format(printf
, 2, 3)))
3003 void git_die_config(const char *key
, const char *err
, ...)
3005 const struct string_list
*values
;
3006 struct key_value_info
*kv_info
;
3007 report_fn error_fn
= get_error_routine();
3011 va_start(params
, err
);
3012 error_fn(err
, params
);
3015 if (git_config_get_value_multi(key
, &values
))
3016 BUG("for key '%s' we must have a value to report on", key
);
3017 kv_info
= values
->items
[values
->nr
- 1].util
;
3018 git_die_config_linenr(key
, kv_info
->filename
, kv_info
->linenr
);
3022 * Find all the stuff for git_config_set() below.
3025 struct config_store_data
{
3026 struct config_reader
*config_reader
;
3030 const char *fixed_value
;
3031 regex_t
*value_pattern
;
3035 enum config_event_t type
;
3036 int is_keys_section
;
3038 unsigned int parsed_nr
, parsed_alloc
, *seen
, seen_nr
, seen_alloc
;
3039 unsigned int key_seen
:1, section_seen
:1, is_keys_section
:1;
3041 #define CONFIG_STORE_INIT { 0 }
3043 static void config_store_data_clear(struct config_store_data
*store
)
3046 if (store
->value_pattern
!= NULL
&&
3047 store
->value_pattern
!= CONFIG_REGEX_NONE
) {
3048 regfree(store
->value_pattern
);
3049 free(store
->value_pattern
);
3051 free(store
->parsed
);
3053 memset(store
, 0, sizeof(*store
));
3056 static int matches(const char *key
, const char *value
,
3057 const struct config_store_data
*store
)
3059 if (strcmp(key
, store
->key
))
3060 return 0; /* not ours */
3061 if (store
->fixed_value
)
3062 return !strcmp(store
->fixed_value
, value
);
3063 if (!store
->value_pattern
)
3064 return 1; /* always matches */
3065 if (store
->value_pattern
== CONFIG_REGEX_NONE
)
3066 return 0; /* never matches */
3068 return store
->do_not_match
^
3069 (value
&& !regexec(store
->value_pattern
, value
, 0, NULL
, 0));
3072 static int store_aux_event(enum config_event_t type
,
3073 size_t begin
, size_t end
, void *data
)
3075 struct config_store_data
*store
= data
;
3076 struct config_source
*cs
= store
->config_reader
->source
;
3078 ALLOC_GROW(store
->parsed
, store
->parsed_nr
+ 1, store
->parsed_alloc
);
3079 store
->parsed
[store
->parsed_nr
].begin
= begin
;
3080 store
->parsed
[store
->parsed_nr
].end
= end
;
3081 store
->parsed
[store
->parsed_nr
].type
= type
;
3083 if (type
== CONFIG_EVENT_SECTION
) {
3084 int (*cmpfn
)(const char *, const char *, size_t);
3086 if (cs
->var
.len
< 2 || cs
->var
.buf
[cs
->var
.len
- 1] != '.')
3087 return error(_("invalid section name '%s'"), cs
->var
.buf
);
3089 if (cs
->subsection_case_sensitive
)
3090 cmpfn
= strncasecmp
;
3094 /* Is this the section we were looking for? */
3095 store
->is_keys_section
=
3096 store
->parsed
[store
->parsed_nr
].is_keys_section
=
3097 cs
->var
.len
- 1 == store
->baselen
&&
3098 !cmpfn(cs
->var
.buf
, store
->key
, store
->baselen
);
3099 if (store
->is_keys_section
) {
3100 store
->section_seen
= 1;
3101 ALLOC_GROW(store
->seen
, store
->seen_nr
+ 1,
3103 store
->seen
[store
->seen_nr
] = store
->parsed_nr
;
3112 static int store_aux(const char *key
, const char *value
, void *cb
)
3114 struct config_store_data
*store
= cb
;
3116 if (store
->key_seen
) {
3117 if (matches(key
, value
, store
)) {
3118 if (store
->seen_nr
== 1 && store
->multi_replace
== 0) {
3119 warning(_("%s has multiple values"), key
);
3122 ALLOC_GROW(store
->seen
, store
->seen_nr
+ 1,
3125 store
->seen
[store
->seen_nr
] = store
->parsed_nr
;
3128 } else if (store
->is_keys_section
) {
3130 * Do not increment matches yet: this may not be a match, but we
3131 * are in the desired section.
3133 ALLOC_GROW(store
->seen
, store
->seen_nr
+ 1, store
->seen_alloc
);
3134 store
->seen
[store
->seen_nr
] = store
->parsed_nr
;
3135 store
->section_seen
= 1;
3137 if (matches(key
, value
, store
)) {
3139 store
->key_seen
= 1;
3146 static int write_error(const char *filename
)
3148 error(_("failed to write new configuration file %s"), filename
);
3150 /* Same error code as "failed to rename". */
3154 static struct strbuf
store_create_section(const char *key
,
3155 const struct config_store_data
*store
)
3159 struct strbuf sb
= STRBUF_INIT
;
3161 dot
= memchr(key
, '.', store
->baselen
);
3163 strbuf_addf(&sb
, "[%.*s \"", (int)(dot
- key
), key
);
3164 for (i
= dot
- key
+ 1; i
< store
->baselen
; i
++) {
3165 if (key
[i
] == '"' || key
[i
] == '\\')
3166 strbuf_addch(&sb
, '\\');
3167 strbuf_addch(&sb
, key
[i
]);
3169 strbuf_addstr(&sb
, "\"]\n");
3171 strbuf_addch(&sb
, '[');
3172 strbuf_add(&sb
, key
, store
->baselen
);
3173 strbuf_addstr(&sb
, "]\n");
3179 static ssize_t
write_section(int fd
, const char *key
,
3180 const struct config_store_data
*store
)
3182 struct strbuf sb
= store_create_section(key
, store
);
3185 ret
= write_in_full(fd
, sb
.buf
, sb
.len
);
3186 strbuf_release(&sb
);
3191 static ssize_t
write_pair(int fd
, const char *key
, const char *value
,
3192 const struct config_store_data
*store
)
3196 const char *quote
= "";
3197 struct strbuf sb
= STRBUF_INIT
;
3200 * Check to see if the value needs to be surrounded with a dq pair.
3201 * Note that problematic characters are always backslash-quoted; this
3202 * check is about not losing leading or trailing SP and strings that
3203 * follow beginning-of-comment characters (i.e. ';' and '#') by the
3204 * configuration parser.
3206 if (value
[0] == ' ')
3208 for (i
= 0; value
[i
]; i
++)
3209 if (value
[i
] == ';' || value
[i
] == '#')
3211 if (i
&& value
[i
- 1] == ' ')
3214 strbuf_addf(&sb
, "\t%s = %s", key
+ store
->baselen
+ 1, quote
);
3216 for (i
= 0; value
[i
]; i
++)
3219 strbuf_addstr(&sb
, "\\n");
3222 strbuf_addstr(&sb
, "\\t");
3226 strbuf_addch(&sb
, '\\');
3229 strbuf_addch(&sb
, value
[i
]);
3232 strbuf_addf(&sb
, "%s\n", quote
);
3234 ret
= write_in_full(fd
, sb
.buf
, sb
.len
);
3235 strbuf_release(&sb
);
3241 * If we are about to unset the last key(s) in a section, and if there are
3242 * no comments surrounding (or included in) the section, we will want to
3243 * extend begin/end to remove the entire section.
3245 * Note: the parameter `seen_ptr` points to the index into the store.seen
3246 * array. * This index may be incremented if a section has more than one
3247 * entry (which all are to be removed).
3249 static void maybe_remove_section(struct config_store_data
*store
,
3250 size_t *begin_offset
, size_t *end_offset
,
3254 int i
, seen
, section_seen
= 0;
3257 * First, ensure that this is the first key, and that there are no
3258 * comments before the entry nor before the section header.
3261 for (i
= store
->seen
[seen
]; i
> 0; i
--) {
3262 enum config_event_t type
= store
->parsed
[i
- 1].type
;
3264 if (type
== CONFIG_EVENT_COMMENT
)
3265 /* There is a comment before this entry or section */
3267 if (type
== CONFIG_EVENT_ENTRY
) {
3269 /* This is not the section's first entry. */
3271 /* We encountered no comment before the section. */
3274 if (type
== CONFIG_EVENT_SECTION
) {
3275 if (!store
->parsed
[i
- 1].is_keys_section
)
3280 begin
= store
->parsed
[i
].begin
;
3283 * Next, make sure that we are removing the last key(s) in the section,
3284 * and that there are no comments that are possibly about the current
3287 for (i
= store
->seen
[seen
] + 1; i
< store
->parsed_nr
; i
++) {
3288 enum config_event_t type
= store
->parsed
[i
].type
;
3290 if (type
== CONFIG_EVENT_COMMENT
)
3292 if (type
== CONFIG_EVENT_SECTION
) {
3293 if (store
->parsed
[i
].is_keys_section
)
3297 if (type
== CONFIG_EVENT_ENTRY
) {
3298 if (++seen
< store
->seen_nr
&&
3299 i
== store
->seen
[seen
])
3300 /* We want to remove this entry, too */
3302 /* There is another entry in this section. */
3308 * We are really removing the last entry/entries from this section, and
3309 * there are no enclosed or surrounding comments. Remove the entire,
3310 * now-empty section.
3313 *begin_offset
= begin
;
3314 if (i
< store
->parsed_nr
)
3315 *end_offset
= store
->parsed
[i
].begin
;
3317 *end_offset
= store
->parsed
[store
->parsed_nr
- 1].end
;
3320 int git_config_set_in_file_gently(const char *config_filename
,
3321 const char *key
, const char *value
)
3323 return git_config_set_multivar_in_file_gently(config_filename
, key
, value
, NULL
, 0);
3326 void git_config_set_in_file(const char *config_filename
,
3327 const char *key
, const char *value
)
3329 git_config_set_multivar_in_file(config_filename
, key
, value
, NULL
, 0);
3332 int git_config_set_gently(const char *key
, const char *value
)
3334 return git_config_set_multivar_gently(key
, value
, NULL
, 0);
3337 int repo_config_set_worktree_gently(struct repository
*r
,
3338 const char *key
, const char *value
)
3340 /* Only use worktree-specific config if it is already enabled. */
3341 if (repository_format_worktree_config
) {
3342 char *file
= repo_git_path(r
, "config.worktree");
3343 int ret
= git_config_set_multivar_in_file_gently(
3344 file
, key
, value
, NULL
, 0);
3348 return repo_config_set_multivar_gently(r
, key
, value
, NULL
, 0);
3351 void git_config_set(const char *key
, const char *value
)
3353 git_config_set_multivar(key
, value
, NULL
, 0);
3355 trace2_cmd_set_config(key
, value
);
3359 * If value==NULL, unset in (remove from) config,
3360 * if value_pattern!=NULL, disregard key/value pairs where value does not match.
3361 * if value_pattern==CONFIG_REGEX_NONE, do not match any existing values
3362 * (only add a new one)
3363 * if flags contains the CONFIG_FLAGS_MULTI_REPLACE flag, all matching
3364 * key/values are removed before a single new pair is written. If the
3365 * flag is not present, then replace only the first match.
3367 * Returns 0 on success.
3369 * This function does this:
3371 * - it locks the config file by creating ".git/config.lock"
3373 * - it then parses the config using store_aux() as validator to find
3374 * the position on the key/value pair to replace. If it is to be unset,
3375 * it must be found exactly once.
3377 * - the config file is mmap()ed and the part before the match (if any) is
3378 * written to the lock file, then the changed part and the rest.
3380 * - the config file is removed and the lock file rename()d to it.
3383 int git_config_set_multivar_in_file_gently(const char *config_filename
,
3384 const char *key
, const char *value
,
3385 const char *value_pattern
,
3388 int fd
= -1, in_fd
= -1;
3390 struct lock_file lock
= LOCK_INIT
;
3391 char *filename_buf
= NULL
;
3392 char *contents
= NULL
;
3394 struct config_store_data store
= CONFIG_STORE_INIT
;
3396 store
.config_reader
= &the_reader
;
3398 /* parse-key returns negative; flip the sign to feed exit(3) */
3399 ret
= 0 - git_config_parse_key(key
, &store
.key
, &store
.baselen
);
3403 store
.multi_replace
= (flags
& CONFIG_FLAGS_MULTI_REPLACE
) != 0;
3405 if (!config_filename
)
3406 config_filename
= filename_buf
= git_pathdup("config");
3409 * The lock serves a purpose in addition to locking: the new
3410 * contents of .git/config will be written into it.
3412 fd
= hold_lock_file_for_update(&lock
, config_filename
, 0);
3414 error_errno(_("could not lock config file %s"), config_filename
);
3415 ret
= CONFIG_NO_LOCK
;
3420 * If .git/config does not exist yet, write a minimal version.
3422 in_fd
= open(config_filename
, O_RDONLY
);
3424 if ( ENOENT
!= errno
) {
3425 error_errno(_("opening %s"), config_filename
);
3426 ret
= CONFIG_INVALID_FILE
; /* same as "invalid config file" */
3429 /* if nothing to unset, error out */
3431 ret
= CONFIG_NOTHING_SET
;
3436 store
.key
= xstrdup(key
);
3437 if (write_section(fd
, key
, &store
) < 0 ||
3438 write_pair(fd
, key
, value
, &store
) < 0)
3442 size_t copy_begin
, copy_end
;
3443 int i
, new_line
= 0;
3444 struct config_options opts
;
3447 store
.value_pattern
= NULL
;
3448 else if (value_pattern
== CONFIG_REGEX_NONE
)
3449 store
.value_pattern
= CONFIG_REGEX_NONE
;
3450 else if (flags
& CONFIG_FLAGS_FIXED_VALUE
)
3451 store
.fixed_value
= value_pattern
;
3453 if (value_pattern
[0] == '!') {
3454 store
.do_not_match
= 1;
3457 store
.do_not_match
= 0;
3459 store
.value_pattern
= (regex_t
*)xmalloc(sizeof(regex_t
));
3460 if (regcomp(store
.value_pattern
, value_pattern
,
3462 error(_("invalid pattern: %s"), value_pattern
);
3463 FREE_AND_NULL(store
.value_pattern
);
3464 ret
= CONFIG_INVALID_PATTERN
;
3469 ALLOC_GROW(store
.parsed
, 1, store
.parsed_alloc
);
3470 store
.parsed
[0].end
= 0;
3472 memset(&opts
, 0, sizeof(opts
));
3473 opts
.event_fn
= store_aux_event
;
3474 opts
.event_fn_data
= &store
;
3477 * After this, store.parsed will contain offsets of all the
3478 * parsed elements, and store.seen will contain a list of
3479 * matches, as indices into store.parsed.
3481 * As a side effect, we make sure to transform only a valid
3482 * existing config file.
3484 if (git_config_from_file_with_options(store_aux
,
3487 error(_("invalid config file %s"), config_filename
);
3488 ret
= CONFIG_INVALID_FILE
;
3492 /* if nothing to unset, or too many matches, error out */
3493 if ((store
.seen_nr
== 0 && value
== NULL
) ||
3494 (store
.seen_nr
> 1 && !store
.multi_replace
)) {
3495 ret
= CONFIG_NOTHING_SET
;
3499 if (fstat(in_fd
, &st
) == -1) {
3500 error_errno(_("fstat on %s failed"), config_filename
);
3501 ret
= CONFIG_INVALID_FILE
;
3505 contents_sz
= xsize_t(st
.st_size
);
3506 contents
= xmmap_gently(NULL
, contents_sz
, PROT_READ
,
3507 MAP_PRIVATE
, in_fd
, 0);
3508 if (contents
== MAP_FAILED
) {
3509 if (errno
== ENODEV
&& S_ISDIR(st
.st_mode
))
3511 error_errno(_("unable to mmap '%s'%s"),
3512 config_filename
, mmap_os_err());
3513 ret
= CONFIG_INVALID_FILE
;
3520 if (chmod(get_lock_file_path(&lock
), st
.st_mode
& 07777) < 0) {
3521 error_errno(_("chmod on %s failed"), get_lock_file_path(&lock
));
3522 ret
= CONFIG_NO_WRITE
;
3526 if (store
.seen_nr
== 0) {
3527 if (!store
.seen_alloc
) {
3528 /* Did not see key nor section */
3529 ALLOC_GROW(store
.seen
, 1, store
.seen_alloc
);
3530 store
.seen
[0] = store
.parsed_nr
3531 - !!store
.parsed_nr
;
3536 for (i
= 0, copy_begin
= 0; i
< store
.seen_nr
; i
++) {
3538 int j
= store
.seen
[i
];
3541 if (!store
.key_seen
) {
3542 copy_end
= store
.parsed
[j
].end
;
3543 /* include '\n' when copying section header */
3544 if (copy_end
> 0 && copy_end
< contents_sz
&&
3545 contents
[copy_end
- 1] != '\n' &&
3546 contents
[copy_end
] == '\n')
3548 replace_end
= copy_end
;
3550 replace_end
= store
.parsed
[j
].end
;
3551 copy_end
= store
.parsed
[j
].begin
;
3553 maybe_remove_section(&store
,
3557 * Swallow preceding white-space on the same
3560 while (copy_end
> 0 ) {
3561 char c
= contents
[copy_end
- 1];
3563 if (isspace(c
) && c
!= '\n')
3570 if (copy_end
> 0 && contents
[copy_end
-1] != '\n')
3573 /* write the first part of the config */
3574 if (copy_end
> copy_begin
) {
3575 if (write_in_full(fd
, contents
+ copy_begin
,
3576 copy_end
- copy_begin
) < 0)
3579 write_str_in_full(fd
, "\n") < 0)
3582 copy_begin
= replace_end
;
3585 /* write the pair (value == NULL means unset) */
3587 if (!store
.section_seen
) {
3588 if (write_section(fd
, key
, &store
) < 0)
3591 if (write_pair(fd
, key
, value
, &store
) < 0)
3595 /* write the rest of the config */
3596 if (copy_begin
< contents_sz
)
3597 if (write_in_full(fd
, contents
+ copy_begin
,
3598 contents_sz
- copy_begin
) < 0)
3601 munmap(contents
, contents_sz
);
3605 if (commit_lock_file(&lock
) < 0) {
3606 error_errno(_("could not write config file %s"), config_filename
);
3607 ret
= CONFIG_NO_WRITE
;
3613 /* Invalidate the config cache */
3617 rollback_lock_file(&lock
);
3620 munmap(contents
, contents_sz
);
3623 config_store_data_clear(&store
);
3627 ret
= write_error(get_lock_file_path(&lock
));
3632 void git_config_set_multivar_in_file(const char *config_filename
,
3633 const char *key
, const char *value
,
3634 const char *value_pattern
, unsigned flags
)
3636 if (!git_config_set_multivar_in_file_gently(config_filename
, key
, value
,
3637 value_pattern
, flags
))
3640 die(_("could not set '%s' to '%s'"), key
, value
);
3642 die(_("could not unset '%s'"), key
);
3645 int git_config_set_multivar_gently(const char *key
, const char *value
,
3646 const char *value_pattern
, unsigned flags
)
3648 return repo_config_set_multivar_gently(the_repository
, key
, value
,
3649 value_pattern
, flags
);
3652 int repo_config_set_multivar_gently(struct repository
*r
, const char *key
,
3654 const char *value_pattern
, unsigned flags
)
3656 char *file
= repo_git_path(r
, "config");
3657 int res
= git_config_set_multivar_in_file_gently(file
,
3665 void git_config_set_multivar(const char *key
, const char *value
,
3666 const char *value_pattern
, unsigned flags
)
3668 git_config_set_multivar_in_file(git_path("config"),
3669 key
, value
, value_pattern
,
3673 static size_t section_name_match (const char *buf
, const char *name
)
3675 size_t i
= 0, j
= 0;
3679 for (i
= 1; buf
[i
] && buf
[i
] != ']'; i
++) {
3680 if (!dot
&& isspace(buf
[i
])) {
3682 if (name
[j
++] != '.')
3684 for (i
++; isspace(buf
[i
]); i
++)
3690 if (buf
[i
] == '\\' && dot
)
3692 else if (buf
[i
] == '"' && dot
) {
3693 for (i
++; isspace(buf
[i
]); i
++)
3697 if (buf
[i
] != name
[j
++])
3700 if (buf
[i
] == ']' && name
[j
] == 0) {
3702 * We match, now just find the right length offset by
3703 * gobbling up any whitespace after it, as well
3706 for (; buf
[i
] && isspace(buf
[i
]); i
++)
3713 static int section_name_is_ok(const char *name
)
3715 /* Empty section names are bogus. */
3720 * Before a dot, we must be alphanumeric or dash. After the first dot,
3721 * anything goes, so we can stop checking.
3723 for (; *name
&& *name
!= '.'; name
++)
3724 if (*name
!= '-' && !isalnum(*name
))
3729 #define GIT_CONFIG_MAX_LINE_LEN (512 * 1024)
3731 /* if new_name == NULL, the section is removed instead */
3732 static int git_config_copy_or_rename_section_in_file(const char *config_filename
,
3733 const char *old_name
,
3734 const char *new_name
, int copy
)
3736 int ret
= 0, remove
= 0;
3737 char *filename_buf
= NULL
;
3738 struct lock_file lock
= LOCK_INIT
;
3740 struct strbuf buf
= STRBUF_INIT
;
3741 FILE *config_file
= NULL
;
3743 struct strbuf copystr
= STRBUF_INIT
;
3744 struct config_store_data store
;
3745 uint32_t line_nr
= 0;
3747 memset(&store
, 0, sizeof(store
));
3749 if (new_name
&& !section_name_is_ok(new_name
)) {
3750 ret
= error(_("invalid section name: %s"), new_name
);
3751 goto out_no_rollback
;
3754 if (!config_filename
)
3755 config_filename
= filename_buf
= git_pathdup("config");
3757 out_fd
= hold_lock_file_for_update(&lock
, config_filename
, 0);
3759 ret
= error(_("could not lock config file %s"), config_filename
);
3763 if (!(config_file
= fopen(config_filename
, "rb"))) {
3764 ret
= warn_on_fopen_errors(config_filename
);
3767 /* no config file means nothing to rename, no error */
3768 goto commit_and_out
;
3771 if (fstat(fileno(config_file
), &st
) == -1) {
3772 ret
= error_errno(_("fstat on %s failed"), config_filename
);
3776 if (chmod(get_lock_file_path(&lock
), st
.st_mode
& 07777) < 0) {
3777 ret
= error_errno(_("chmod on %s failed"),
3778 get_lock_file_path(&lock
));
3782 while (!strbuf_getwholeline(&buf
, config_file
, '\n')) {
3785 char *output
= buf
.buf
;
3789 if (buf
.len
>= GIT_CONFIG_MAX_LINE_LEN
) {
3790 ret
= error(_("refusing to work with overly long line "
3791 "in '%s' on line %"PRIuMAX
),
3792 config_filename
, (uintmax_t)line_nr
);
3796 for (i
= 0; buf
.buf
[i
] && isspace(buf
.buf
[i
]); i
++)
3798 if (buf
.buf
[i
] == '[') {
3799 /* it's a section */
3804 * When encountering a new section under -c we
3805 * need to flush out any section we're already
3806 * coping and begin anew. There might be
3807 * multiple [branch "$name"] sections.
3809 if (copystr
.len
> 0) {
3810 if (write_in_full(out_fd
, copystr
.buf
, copystr
.len
) < 0) {
3811 ret
= write_error(get_lock_file_path(&lock
));
3814 strbuf_reset(©str
);
3817 offset
= section_name_match(&buf
.buf
[i
], old_name
);
3824 store
.baselen
= strlen(new_name
);
3826 if (write_section(out_fd
, new_name
, &store
) < 0) {
3827 ret
= write_error(get_lock_file_path(&lock
));
3831 * We wrote out the new section, with
3832 * a newline, now skip the old
3835 output
+= offset
+ i
;
3836 if (strlen(output
) > 0) {
3838 * More content means there's
3839 * a declaration to put on the
3840 * next line; indent with a
3847 copystr
= store_create_section(new_name
, &store
);
3854 length
= strlen(output
);
3856 if (!is_section
&& copystr
.len
> 0) {
3857 strbuf_add(©str
, output
, length
);
3860 if (write_in_full(out_fd
, output
, length
) < 0) {
3861 ret
= write_error(get_lock_file_path(&lock
));
3867 * Copy a trailing section at the end of the config, won't be
3868 * flushed by the usual "flush because we have a new section
3869 * logic in the loop above.
3871 if (copystr
.len
> 0) {
3872 if (write_in_full(out_fd
, copystr
.buf
, copystr
.len
) < 0) {
3873 ret
= write_error(get_lock_file_path(&lock
));
3876 strbuf_reset(©str
);
3879 fclose(config_file
);
3882 if (commit_lock_file(&lock
) < 0)
3883 ret
= error_errno(_("could not write config file %s"),
3887 fclose(config_file
);
3888 rollback_lock_file(&lock
);
3891 config_store_data_clear(&store
);
3892 strbuf_release(&buf
);
3896 int git_config_rename_section_in_file(const char *config_filename
,
3897 const char *old_name
, const char *new_name
)
3899 return git_config_copy_or_rename_section_in_file(config_filename
,
3900 old_name
, new_name
, 0);
3903 int git_config_rename_section(const char *old_name
, const char *new_name
)
3905 return git_config_rename_section_in_file(NULL
, old_name
, new_name
);
3908 int git_config_copy_section_in_file(const char *config_filename
,
3909 const char *old_name
, const char *new_name
)
3911 return git_config_copy_or_rename_section_in_file(config_filename
,
3912 old_name
, new_name
, 1);
3915 int git_config_copy_section(const char *old_name
, const char *new_name
)
3917 return git_config_copy_section_in_file(NULL
, old_name
, new_name
);
3921 * Call this to report error for your variable that should not
3922 * get a boolean value (i.e. "[my] var" means "true").
3924 #undef config_error_nonbool
3925 int config_error_nonbool(const char *var
)
3927 return error(_("missing value for '%s'"), var
);
3930 int parse_config_key(const char *var
,
3931 const char *section
,
3932 const char **subsection
, size_t *subsection_len
,
3937 /* Does it start with "section." ? */
3938 if (!skip_prefix(var
, section
, &var
) || *var
!= '.')
3942 * Find the key; we don't know yet if we have a subsection, but we must
3943 * parse backwards from the end, since the subsection may have dots in
3946 dot
= strrchr(var
, '.');
3949 /* Did we have a subsection at all? */
3953 *subsection_len
= 0;
3959 *subsection
= var
+ 1;
3960 *subsection_len
= dot
- *subsection
;
3966 static int reader_origin_type(struct config_reader
*reader
,
3967 enum config_origin_type
*type
)
3969 if (the_reader
.config_kvi
)
3970 *type
= reader
->config_kvi
->origin_type
;
3971 else if(the_reader
.source
)
3972 *type
= reader
->source
->origin_type
;
3978 const char *current_config_origin_type(void)
3980 enum config_origin_type type
= CONFIG_ORIGIN_UNKNOWN
;
3982 if (reader_origin_type(&the_reader
, &type
))
3983 BUG("current_config_origin_type called outside config callback");
3986 case CONFIG_ORIGIN_BLOB
:
3988 case CONFIG_ORIGIN_FILE
:
3990 case CONFIG_ORIGIN_STDIN
:
3991 return "standard input";
3992 case CONFIG_ORIGIN_SUBMODULE_BLOB
:
3993 return "submodule-blob";
3994 case CONFIG_ORIGIN_CMDLINE
:
3995 return "command line";
3997 BUG("unknown config origin type");
4001 const char *config_scope_name(enum config_scope scope
)
4004 case CONFIG_SCOPE_SYSTEM
:
4006 case CONFIG_SCOPE_GLOBAL
:
4008 case CONFIG_SCOPE_LOCAL
:
4010 case CONFIG_SCOPE_WORKTREE
:
4012 case CONFIG_SCOPE_COMMAND
:
4014 case CONFIG_SCOPE_SUBMODULE
:
4021 static int reader_config_name(struct config_reader
*reader
, const char **out
)
4023 if (the_reader
.config_kvi
)
4024 *out
= reader
->config_kvi
->filename
;
4025 else if (the_reader
.source
)
4026 *out
= reader
->source
->name
;
4032 const char *current_config_name(void)
4035 if (reader_config_name(&the_reader
, &name
))
4036 BUG("current_config_name called outside config callback");
4037 return name
? name
: "";
4040 enum config_scope
current_config_scope(void)
4042 if (the_reader
.config_kvi
)
4043 return the_reader
.config_kvi
->scope
;
4045 return the_reader
.parsing_scope
;
4048 int current_config_line(void)
4050 if (the_reader
.config_kvi
)
4051 return the_reader
.config_kvi
->linenr
;
4053 return the_reader
.source
->linenr
;
4056 int lookup_config(const char **mapping
, int nr_mapping
, const char *var
)
4060 for (i
= 0; i
< nr_mapping
; i
++) {
4061 const char *name
= mapping
[i
];
4063 if (name
&& !strcasecmp(var
, name
))