5 #include "string-list.h"
9 * The config API gives callers a way to access Git configuration files
10 * (and files which have the same syntax).
15 * Config files are parsed linearly, and each variable found is passed to a
16 * caller-provided callback function. The callback function is responsible
17 * for any actions to be taken on the config option, and is free to ignore
18 * some options. It is not uncommon for the configuration to be parsed
19 * several times during the run of a Git program, with different callbacks
20 * picking out different variables useful to themselves.
25 /* git_config_parse_key() returns these negated: */
26 #define CONFIG_INVALID_KEY 1
27 #define CONFIG_NO_SECTION_OR_NAME 2
28 /* git_config_set_gently(), git_config_set_multivar_gently() return the above or these: */
29 #define CONFIG_NO_LOCK -1
30 #define CONFIG_INVALID_FILE 3
31 #define CONFIG_NO_WRITE 4
32 #define CONFIG_NOTHING_SET 5
33 #define CONFIG_INVALID_PATTERN 6
34 #define CONFIG_GENERIC_ERROR 7
36 #define CONFIG_REGEX_NONE ((void *)1)
38 struct git_config_source
{
39 unsigned int use_stdin
:1;
44 enum config_origin_type
{
48 CONFIG_ORIGIN_SUBMODULE_BLOB
,
55 CONFIG_EVENT_WHITESPACE
,
62 * The parser event function (if not NULL) is called with the event type and
63 * the begin/end offsets of the parsed elements.
65 * Note: for CONFIG_EVENT_ENTRY (i.e. config variables), the trailing newline
66 * character is considered part of the element.
68 typedef int (*config_parser_event_fn_t
)(enum config_event_t type
,
69 size_t begin_offset
, size_t end_offset
,
72 struct config_options
{
73 unsigned int respect_includes
: 1;
74 unsigned int ignore_repo
: 1;
75 unsigned int ignore_worktree
: 1;
76 unsigned int ignore_cmdline
: 1;
77 unsigned int system_gently
: 1;
78 const char *commondir
;
80 config_parser_event_fn_t event_fn
;
82 enum config_error_action
{
83 CONFIG_ERROR_UNSET
= 0, /* use source-specific default */
84 CONFIG_ERROR_DIE
, /* die() on error */
85 CONFIG_ERROR_ERROR
, /* error() on error, return -1 */
86 CONFIG_ERROR_SILENT
, /* return -1 */
91 * A config callback function takes three parameters:
93 * - the name of the parsed variable. This is in canonical "flat" form: the
94 * section, subsection, and variable segments will be separated by dots,
95 * and the section and variable segments will be all lowercase. E.g.,
96 * `core.ignorecase`, `diff.SomeType.textconv`.
98 * - the value of the found variable, as a string. If the variable had no
99 * value specified, the value will be NULL (typically this means it
100 * should be interpreted as boolean true).
102 * - a void pointer passed in by the caller of the config API; this can
103 * contain callback-specific data
105 * A config callback should return 0 for success, or -1 if the variable
106 * could not be parsed properly.
108 typedef int (*config_fn_t
)(const char *, const char *, void *);
110 int git_default_config(const char *, const char *, void *);
113 * Read a specific file in git-config format.
114 * This function takes the same callback and data parameters as `git_config`.
116 int git_config_from_file(config_fn_t fn
, const char *, void *);
118 int git_config_from_file_with_options(config_fn_t fn
, const char *,
120 const struct config_options
*);
121 int git_config_from_mem(config_fn_t fn
,
122 const enum config_origin_type
,
124 const char *buf
, size_t len
,
125 void *data
, const struct config_options
*opts
);
126 int git_config_from_blob_oid(config_fn_t fn
, const char *name
,
127 const struct object_id
*oid
, void *data
);
128 void git_config_push_parameter(const char *text
);
129 int git_config_from_parameters(config_fn_t fn
, void *data
);
130 void read_early_config(config_fn_t cb
, void *data
);
131 void read_very_early_config(config_fn_t cb
, void *data
);
134 * Most programs will simply want to look up variables in all config files
135 * that Git knows about, using the normal precedence rules. To do this,
136 * call `git_config` with a callback function and void data pointer.
138 * `git_config` will read all config sources in order of increasing
139 * priority. Thus a callback should typically overwrite previously-seen
140 * entries with new ones (e.g., if both the user-wide `~/.gitconfig` and
141 * repo-specific `.git/config` contain `color.ui`, the config machinery
142 * will first feed the user-wide one to the callback, and then the
143 * repo-specific one; by overwriting, the higher-priority repo-specific
144 * value is left at the end).
146 void git_config(config_fn_t fn
, void *);
149 * Lets the caller examine config while adjusting some of the default
150 * behavior of `git_config`. It should almost never be used by "regular"
151 * Git code that is looking up configuration variables.
152 * It is intended for advanced callers like `git-config`, which are
153 * intentionally tweaking the normal config-lookup process.
154 * It takes two extra parameters:
157 * If this parameter is non-NULL, it specifies the source to parse for
158 * configuration, rather than looking in the usual files. See `struct
159 * git_config_source` in `config.h` for details. Regular `git_config` defaults
163 * Specify options to adjust the behavior of parsing config files. See `struct
164 * config_options` in `config.h` for details. As an example: regular `git_config`
165 * sets `opts.respect_includes` to `1` by default.
167 int config_with_options(config_fn_t fn
, void *,
168 struct git_config_source
*config_source
,
169 const struct config_options
*opts
);
172 * Value Parsing Helpers
173 * ---------------------
175 * The following helper functions aid in parsing string values
178 int git_parse_ssize_t(const char *, ssize_t
*);
179 int git_parse_ulong(const char *, unsigned long *);
182 * Same as `git_config_bool`, except that it returns -1 on error rather
185 int git_parse_maybe_bool(const char *);
188 * Parse the string to an integer, including unit factors. Dies on error;
189 * otherwise, returns the parsed result.
191 int git_config_int(const char *, const char *);
193 int64_t git_config_int64(const char *, const char *);
196 * Identical to `git_config_int`, but for unsigned longs.
198 unsigned long git_config_ulong(const char *, const char *);
200 ssize_t
git_config_ssize_t(const char *, const char *);
203 * Same as `git_config_bool`, except that integers are returned as-is, and
204 * an `is_bool` flag is unset.
206 int git_config_bool_or_int(const char *, const char *, int *);
209 * Parse a string into a boolean value, respecting keywords like "true" and
210 * "false". Integer values are converted into true/false values (when they
211 * are non-zero or zero, respectively). Other values cause a die(). If
212 * parsing is successful, the return value is the result.
214 int git_config_bool(const char *, const char *);
217 * Allocates and copies the value string into the `dest` parameter; if no
218 * string is given, prints an error message and returns -1.
220 int git_config_string(const char **, const char *, const char *);
223 * Similar to `git_config_string`, but expands `~` or `~user` into the
224 * user's home directory when found at the beginning of the path.
226 int git_config_pathname(const char **, const char *, const char *);
228 int git_config_expiry_date(timestamp_t
*, const char *, const char *);
229 int git_config_color(char *, const char *, const char *);
230 int git_config_set_in_file_gently(const char *, const char *, const char *);
233 * write config values to a specific config file, takes a key/value pair as
236 void git_config_set_in_file(const char *, const char *, const char *);
238 int git_config_set_gently(const char *, const char *);
241 * write config values to `.git/config`, takes a key/value pair as parameter.
243 void git_config_set(const char *, const char *);
245 int git_config_parse_key(const char *, char **, int *);
246 int git_config_key_is_valid(const char *key
);
247 int git_config_set_multivar_gently(const char *, const char *, const char *, int);
248 void git_config_set_multivar(const char *, const char *, const char *, int);
249 int git_config_set_multivar_in_file_gently(const char *, const char *, const char *, const char *, int);
252 * takes four parameters:
254 * - the name of the file, as a string, to which key/value pairs will be written.
256 * - the name of key, as a string. This is in canonical "flat" form: the section,
257 * subsection, and variable segments will be separated by dots, and the section
258 * and variable segments will be all lowercase.
259 * E.g., `core.ignorecase`, `diff.SomeType.textconv`.
261 * - the value of the variable, as a string. If value is equal to NULL, it will
262 * remove the matching key from the config file.
264 * - the value regex, as a string. It will disregard key/value pairs where value
267 * - a multi_replace value, as an int. If value is equal to zero, nothing or only
268 * one matching key/value is replaced, else all matching key/values (regardless
269 * how many) are removed, before the new pair is written.
271 * It returns 0 on success.
273 void git_config_set_multivar_in_file(const char *, const char *, const char *, const char *, int);
276 * rename or remove sections in the config file
277 * parameters `old_name` and `new_name`
278 * If NULL is passed through `new_name` parameter,
279 * the section will be removed from the config file.
281 int git_config_rename_section(const char *, const char *);
283 int git_config_rename_section_in_file(const char *, const char *, const char *);
284 int git_config_copy_section(const char *, const char *);
285 int git_config_copy_section_in_file(const char *, const char *, const char *);
286 const char *git_etc_gitconfig(void);
287 int git_env_bool(const char *, int);
288 unsigned long git_env_ulong(const char *, unsigned long);
289 int git_config_system(void);
290 int config_error_nonbool(const char *);
291 #if defined(__GNUC__)
292 #define config_error_nonbool(s) (config_error_nonbool(s), const_error())
295 int git_config_parse_parameter(const char *, config_fn_t fn
, void *data
);
298 CONFIG_SCOPE_UNKNOWN
= 0,
302 CONFIG_SCOPE_WORKTREE
,
303 CONFIG_SCOPE_CMDLINE
,
305 const char *config_scope_name(enum config_scope scope
);
307 enum config_scope
current_config_scope(void);
308 const char *current_config_origin_type(void);
309 const char *current_config_name(void);
315 * By default, the config parser does not respect include directives.
316 * However, a caller can use the special `git_config_include` wrapper
317 * callback to support them. To do so, you simply wrap your "real" callback
318 * function and data pointer in a `struct config_include_data`, and pass
319 * the wrapper to the regular config-reading functions. For example:
321 * -------------------------------------------
322 * int read_file_with_include(const char *file, config_fn_t fn, void *data)
324 * struct config_include_data inc = CONFIG_INCLUDE_INIT;
327 * return git_config_from_file(git_config_include, file, &inc);
329 * -------------------------------------------
331 * `git_config` respects includes automatically. The lower-level
332 * `git_config_from_file` does not.
335 struct config_include_data
{
339 const struct config_options
*opts
;
341 #define CONFIG_INCLUDE_INIT { 0 }
342 int git_config_include(const char *name
, const char *value
, void *data
);
345 * Match and parse a config key of the form:
347 * section.(subsection.)?key
349 * (i.e., what gets handed to a config_fn_t). The caller provides the section;
350 * we return -1 if it does not match, 0 otherwise. The subsection and key
351 * out-parameters are filled by the function (and *subsection is NULL if it is
354 * If the subsection pointer-to-pointer passed in is NULL, returns 0 only if
355 * there is no subsection at all.
357 int parse_config_key(const char *var
,
359 const char **subsection
, int *subsection_len
,
366 * A `config_set` can be used to construct an in-memory cache for
367 * config-like files that the caller specifies (i.e., files like `.gitmodules`,
368 * `~/.gitconfig` etc.). For example,
370 * ----------------------------------------
371 * struct config_set gm_config;
372 * git_configset_init(&gm_config);
374 * //we add config files to the config_set
375 * git_configset_add_file(&gm_config, ".gitmodules");
376 * git_configset_add_file(&gm_config, ".gitmodules_alt");
378 * if (!git_configset_get_bool(gm_config, "submodule.frotz.ignore", &b)) {
382 * when we are done with the configset:
383 * git_configset_clear(&gm_config);
384 * ----------------------------------------
386 * Configset API provides functions for the above mentioned work flow
389 struct config_set_element
{
390 struct hashmap_entry ent
;
392 struct string_list value_list
;
395 struct configset_list_item
{
396 struct config_set_element
*e
;
401 * the contents of the list are ordered according to their
402 * position in the config files and order of parsing the files.
403 * (i.e. key-value pair at the last position of .git/config will
404 * be at the last item of the list)
406 struct configset_list
{
407 struct configset_list_item
*items
;
408 unsigned int nr
, alloc
;
412 struct hashmap config_hash
;
413 int hash_initialized
;
414 struct configset_list list
;
418 * Initializes the config_set `cs`.
420 void git_configset_init(struct config_set
*cs
);
423 * Parses the file and adds the variable-value pairs to the `config_set`,
424 * dies if there is an error in parsing the file. Returns 0 on success, or
425 * -1 if the file does not exist or is inaccessible. The user has to decide
426 * if he wants to free the incomplete configset or continue using it when
427 * the function returns -1.
429 int git_configset_add_file(struct config_set
*cs
, const char *filename
);
432 * Finds and returns the value list, sorted in order of increasing priority
433 * for the configuration variable `key` and config set `cs`. When the
434 * configuration variable `key` is not found, returns NULL. The caller
435 * should not free or modify the returned pointer, as it is owned by the cache.
437 const struct string_list
*git_configset_get_value_multi(struct config_set
*cs
, const char *key
);
440 * Clears `config_set` structure, removes all saved variable-value pairs.
442 void git_configset_clear(struct config_set
*cs
);
445 * These functions return 1 if not found, and 0 if found, leaving the found
446 * value in the 'dest' pointer.
450 * Finds the highest-priority value for the configuration variable `key`
451 * and config set `cs`, stores the pointer to it in `value` and returns 0.
452 * When the configuration variable `key` is not found, returns 1 without
453 * touching `value`. The caller should not free or modify `value`, as it
454 * is owned by the cache.
456 int git_configset_get_value(struct config_set
*cs
, const char *key
, const char **dest
);
458 int git_configset_get_string_const(struct config_set
*cs
, const char *key
, const char **dest
);
459 int git_configset_get_string(struct config_set
*cs
, const char *key
, char **dest
);
460 int git_configset_get_int(struct config_set
*cs
, const char *key
, int *dest
);
461 int git_configset_get_ulong(struct config_set
*cs
, const char *key
, unsigned long *dest
);
462 int git_configset_get_bool(struct config_set
*cs
, const char *key
, int *dest
);
463 int git_configset_get_bool_or_int(struct config_set
*cs
, const char *key
, int *is_bool
, int *dest
);
464 int git_configset_get_maybe_bool(struct config_set
*cs
, const char *key
, int *dest
);
465 int git_configset_get_pathname(struct config_set
*cs
, const char *key
, const char **dest
);
467 /* Functions for reading a repository's config */
469 void repo_config(struct repository
*repo
, config_fn_t fn
, void *data
);
470 int repo_config_get_value(struct repository
*repo
,
471 const char *key
, const char **value
);
472 const struct string_list
*repo_config_get_value_multi(struct repository
*repo
,
474 int repo_config_get_string_const(struct repository
*repo
,
475 const char *key
, const char **dest
);
476 int repo_config_get_string(struct repository
*repo
,
477 const char *key
, char **dest
);
478 int repo_config_get_int(struct repository
*repo
,
479 const char *key
, int *dest
);
480 int repo_config_get_ulong(struct repository
*repo
,
481 const char *key
, unsigned long *dest
);
482 int repo_config_get_bool(struct repository
*repo
,
483 const char *key
, int *dest
);
484 int repo_config_get_bool_or_int(struct repository
*repo
,
485 const char *key
, int *is_bool
, int *dest
);
486 int repo_config_get_maybe_bool(struct repository
*repo
,
487 const char *key
, int *dest
);
488 int repo_config_get_pathname(struct repository
*repo
,
489 const char *key
, const char **dest
);
492 * Querying For Specific Variables
493 * -------------------------------
495 * For programs wanting to query for specific variables in a non-callback
496 * manner, the config API provides two functions `git_config_get_value`
497 * and `git_config_get_value_multi`. They both read values from an internal
498 * cache generated previously from reading the config files.
502 * Finds the highest-priority value for the configuration variable `key`,
503 * stores the pointer to it in `value` and returns 0. When the
504 * configuration variable `key` is not found, returns 1 without touching
505 * `value`. The caller should not free or modify `value`, as it is owned
508 int git_config_get_value(const char *key
, const char **value
);
511 * Finds and returns the value list, sorted in order of increasing priority
512 * for the configuration variable `key`. When the configuration variable
513 * `key` is not found, returns NULL. The caller should not free or modify
514 * the returned pointer, as it is owned by the cache.
516 const struct string_list
*git_config_get_value_multi(const char *key
);
519 * Resets and invalidates the config cache.
521 void git_config_clear(void);
524 * Allocates and copies the retrieved string into the `dest` parameter for
525 * the configuration variable `key`; if NULL string is given, prints an
526 * error message and returns -1. When the configuration variable `key` is
527 * not found, returns 1 without touching `dest`.
529 int git_config_get_string_const(const char *key
, const char **dest
);
532 * Similar to `git_config_get_string_const`, except that retrieved value
533 * copied into the `dest` parameter is a mutable string.
535 int git_config_get_string(const char *key
, char **dest
);
538 * Finds and parses the value to an integer for the configuration variable
539 * `key`. Dies on error; otherwise, stores the value of the parsed integer in
540 * `dest` and returns 0. When the configuration variable `key` is not found,
541 * returns 1 without touching `dest`.
543 int git_config_get_int(const char *key
, int *dest
);
546 * Similar to `git_config_get_int` but for unsigned longs.
548 int git_config_get_ulong(const char *key
, unsigned long *dest
);
551 * Finds and parses the value into a boolean value, for the configuration
552 * variable `key` respecting keywords like "true" and "false". Integer
553 * values are converted into true/false values (when they are non-zero or
554 * zero, respectively). Other values cause a die(). If parsing is successful,
555 * stores the value of the parsed result in `dest` and returns 0. When the
556 * configuration variable `key` is not found, returns 1 without touching
559 int git_config_get_bool(const char *key
, int *dest
);
562 * Similar to `git_config_get_bool`, except that integers are copied as-is,
563 * and `is_bool` flag is unset.
565 int git_config_get_bool_or_int(const char *key
, int *is_bool
, int *dest
);
568 * Similar to `git_config_get_bool`, except that it returns -1 on error
571 int git_config_get_maybe_bool(const char *key
, int *dest
);
574 * Similar to `git_config_get_string`, but expands `~` or `~user` into
575 * the user's home directory when found at the beginning of the path.
577 int git_config_get_pathname(const char *key
, const char **dest
);
579 int git_config_get_index_threads(int *dest
);
580 int git_config_get_untracked_cache(void);
581 int git_config_get_split_index(void);
582 int git_config_get_max_percent_split_change(void);
583 int git_config_get_fsmonitor(void);
585 /* This dies if the configured or default date is in the future */
586 int git_config_get_expiry(const char *key
, const char **output
);
588 /* parse either "this many days" integer, or "5.days.ago" approxidate */
589 int git_config_get_expiry_in_days(const char *key
, timestamp_t
*, timestamp_t now
);
591 struct key_value_info
{
592 const char *filename
;
594 enum config_origin_type origin_type
;
595 enum config_scope scope
;
599 * First prints the error message specified by the caller in `err` and then
600 * dies printing the line number and the file name of the highest priority
601 * value for the configuration variable `key`.
603 NORETURN
void git_die_config(const char *key
, const char *err
, ...) __attribute__((format(printf
, 2, 3)));
606 * Helper function which formats the die error message according to the
607 * parameters entered. Used by `git_die_config()`. It can be used by callers
608 * handling `git_config_get_value_multi()` to print the correct error message
609 * for the desired value.
611 NORETURN
void git_die_config_linenr(const char *key
, const char *filename
, int linenr
);
613 #define LOOKUP_CONFIG(mapping, var) \
614 lookup_config(mapping, ARRAY_SIZE(mapping), var)
615 int lookup_config(const char **mapping
, int nr_mapping
, const char *var
);
617 #endif /* CONFIG_H */