2006-08-02 21:51:59 +00:00
|
|
|
#include "builtin.h"
|
2005-11-17 21:44:55 +00:00
|
|
|
#include "cache.h"
|
2017-06-14 18:07:36 +00:00
|
|
|
#include "config.h"
|
2007-11-28 06:41:05 +00:00
|
|
|
#include "color.h"
|
2009-02-21 00:49:25 +00:00
|
|
|
#include "parse-options.h"
|
2013-07-31 18:14:59 +00:00
|
|
|
#include "urlmatch.h"
|
2016-02-19 09:16:02 +00:00
|
|
|
#include "quote.h"
|
2018-10-21 14:02:28 +00:00
|
|
|
#include "worktree.h"
|
2005-11-17 21:44:55 +00:00
|
|
|
|
2009-02-21 00:49:25 +00:00
|
|
|
static const char *const builtin_config_usage[] = {
|
2015-01-13 07:44:47 +00:00
|
|
|
N_("git config [<options>]"),
|
2009-02-21 00:49:25 +00:00
|
|
|
NULL
|
|
|
|
};
|
2005-11-20 05:52:22 +00:00
|
|
|
|
2006-08-15 17:23:48 +00:00
|
|
|
static char *key;
|
|
|
|
static regex_t *key_regexp;
|
|
|
|
static regex_t *regexp;
|
|
|
|
static int show_keys;
|
2015-08-10 09:46:06 +00:00
|
|
|
static int omit_values;
|
2006-08-15 17:23:48 +00:00
|
|
|
static int use_key_regexp;
|
|
|
|
static int do_all;
|
|
|
|
static int do_not_match;
|
2007-06-25 14:03:55 +00:00
|
|
|
static char delim = '=';
|
|
|
|
static char key_delim = ' ';
|
|
|
|
static char term = '\n';
|
2005-11-20 05:52:22 +00:00
|
|
|
|
2010-08-04 01:59:23 +00:00
|
|
|
static int use_global_config, use_system_config, use_local_config;
|
2018-10-21 14:02:28 +00:00
|
|
|
static int use_worktree_config;
|
2014-02-18 22:58:54 +00:00
|
|
|
static struct git_config_source given_config_source;
|
builtin/config.c: treat type specifiers singularly
Internally, we represent `git config`'s type specifiers as a bitset
using OPT_BIT. 'bool' is 1<<0, 'int' is 1<<1, and so on. This technique
allows for the representation of multiple type specifiers in the `int
types` field, but this multi-representation is left unused.
In fact, `git config` will not accept multiple type specifiers at a
time, as indicated by:
$ git config --int --bool some.section
error: only one type at a time.
This patch uses `OPT_SET_INT` to prefer the _last_ mentioned type
specifier, so that the above command would instead be valid, and a
synonym of:
$ git config --bool some.section
This change is motivated by two urges: (1) it does not make sense to
represent a singular type specifier internally as a bitset, only to
complain when there are multiple bits in the set. `OPT_SET_INT` is more
well-suited to this task than `OPT_BIT` is. (2) a future patch will
introduce `--type=<type>`, and we would like not to complain in the
following situation:
$ git config --int --type=int
Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 22:46:54 +00:00
|
|
|
static int actions, type;
|
builtin/config: introduce `--default`
For some use cases, callers of the `git-config(1)` builtin would like to
fallback to default values when the variable asked for does not exist.
In addition, users would like to use existing type specifiers to ensure
that values are parsed correctly when they do exist in the
configuration.
For example, to fetch a value without a type specifier and fallback to
`$fallback`, the following is required:
$ git config core.foo || echo "$fallback"
This is fine for most values, but can be tricky for difficult-to-express
`$fallback`'s, like ANSI color codes.
This motivates `--get-color`, which is a one-off exception to the normal
type specifier rules wherein a user specifies both the configuration
variable and an optional fallback. Both are formatted according to their
type specifier, which eases the burden on the user to ensure that values
are correctly formatted.
This commit (and those following it in this series) aim to eventually
replace `--get-color` with a consistent alternative. By introducing
`--default`, we allow the `--get-color` action to be promoted to a
`--type=color` type specifier, retaining the "fallback" behavior via the
`--default` flag introduced in this commit.
For example, we aim to replace:
$ git config --get-color variable [default] [...]
with:
$ git config --default default --type=color variable [...]
Values filled by `--default` behave exactly as if they were present in
the affected configuration file; they will be parsed by type specifiers
without the knowledge that they are not themselves present in the
configuration.
Specifically, this means that the following will work:
$ git config --int --default 1M does.not.exist
1048576
In subsequent commits, we will offer `--type=color`, which (in
conjunction with `--default`) will be sufficient to replace
`--get-color`.
Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-10 00:18:26 +00:00
|
|
|
static char *default_value;
|
2020-01-24 00:21:01 +00:00
|
|
|
static int end_nul;
|
2017-04-17 10:10:00 +00:00
|
|
|
static int respect_includes_opt = -1;
|
|
|
|
static struct config_options config_options;
|
2016-02-19 09:16:02 +00:00
|
|
|
static int show_origin;
|
2020-02-10 00:30:59 +00:00
|
|
|
static int show_scope;
|
2009-02-21 00:49:25 +00:00
|
|
|
|
|
|
|
#define ACTION_GET (1<<0)
|
|
|
|
#define ACTION_GET_ALL (1<<1)
|
|
|
|
#define ACTION_GET_REGEXP (1<<2)
|
|
|
|
#define ACTION_REPLACE_ALL (1<<3)
|
|
|
|
#define ACTION_ADD (1<<4)
|
|
|
|
#define ACTION_UNSET (1<<5)
|
|
|
|
#define ACTION_UNSET_ALL (1<<6)
|
|
|
|
#define ACTION_RENAME_SECTION (1<<7)
|
|
|
|
#define ACTION_REMOVE_SECTION (1<<8)
|
|
|
|
#define ACTION_LIST (1<<9)
|
|
|
|
#define ACTION_EDIT (1<<10)
|
|
|
|
#define ACTION_SET (1<<11)
|
|
|
|
#define ACTION_SET_ALL (1<<12)
|
|
|
|
#define ACTION_GET_COLOR (1<<13)
|
|
|
|
#define ACTION_GET_COLORBOOL (1<<14)
|
2013-07-31 18:14:59 +00:00
|
|
|
#define ACTION_GET_URLMATCH (1<<15)
|
2009-02-21 00:49:25 +00:00
|
|
|
|
2018-02-21 18:51:43 +00:00
|
|
|
/*
|
|
|
|
* The actions "ACTION_LIST | ACTION_GET_*" which may produce more than
|
|
|
|
* one line of output and which should therefore be paged.
|
|
|
|
*/
|
|
|
|
#define PAGING_ACTIONS (ACTION_LIST | ACTION_GET_ALL | \
|
|
|
|
ACTION_GET_REGEXP | ACTION_GET_URLMATCH)
|
|
|
|
|
builtin/config.c: treat type specifiers singularly
Internally, we represent `git config`'s type specifiers as a bitset
using OPT_BIT. 'bool' is 1<<0, 'int' is 1<<1, and so on. This technique
allows for the representation of multiple type specifiers in the `int
types` field, but this multi-representation is left unused.
In fact, `git config` will not accept multiple type specifiers at a
time, as indicated by:
$ git config --int --bool some.section
error: only one type at a time.
This patch uses `OPT_SET_INT` to prefer the _last_ mentioned type
specifier, so that the above command would instead be valid, and a
synonym of:
$ git config --bool some.section
This change is motivated by two urges: (1) it does not make sense to
represent a singular type specifier internally as a bitset, only to
complain when there are multiple bits in the set. `OPT_SET_INT` is more
well-suited to this task than `OPT_BIT` is. (2) a future patch will
introduce `--type=<type>`, and we would like not to complain in the
following situation:
$ git config --int --type=int
Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 22:46:54 +00:00
|
|
|
#define TYPE_BOOL 1
|
|
|
|
#define TYPE_INT 2
|
|
|
|
#define TYPE_BOOL_OR_INT 3
|
|
|
|
#define TYPE_PATH 4
|
|
|
|
#define TYPE_EXPIRY_DATE 5
|
2018-04-10 00:18:31 +00:00
|
|
|
#define TYPE_COLOR 6
|
2009-02-21 00:49:27 +00:00
|
|
|
|
builtin/config.c: support `--type=<type>` as preferred alias for `--<type>`
`git config` has long allowed the ability for callers to provide a 'type
specifier', which instructs `git config` to (1) ensure that incoming
values can be interpreted as that type, and (2) that outgoing values are
canonicalized under that type.
In another series, we propose to extend this functionality with
`--type=color` and `--default` to replace `--get-color`.
However, we traditionally use `--color` to mean "colorize this output",
instead of "this value should be treated as a color".
Currently, `git config` does not support this kind of colorization, but
we should be careful to avoid squatting on this option too soon, so that
`git config` can support `--color` (in the traditional sense) in the
future, if that is desired.
In this patch, we support `--type=<int|bool|bool-or-int|...>` in
addition to `--int`, `--bool`, and etc. This allows the aforementioned
upcoming patch to support querying a color value with a default via
`--type=color --default=...`, without squandering `--color`.
We retain the historic behavior of complaining when multiple,
legacy-style `--<type>` flags are given, as well as extend this to
conflicting new-style `--type=<type>` flags. `--int --type=int` (and its
commutative pair) does not complain, but `--bool --type=int` (and its
commutative pair) does.
Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-18 21:43:35 +00:00
|
|
|
#define OPT_CALLBACK_VALUE(s, l, v, h, i) \
|
|
|
|
{ OPTION_CALLBACK, (s), (l), (v), NULL, (h), PARSE_OPT_NOARG | \
|
|
|
|
PARSE_OPT_NONEG, option_parse_type, (i) }
|
|
|
|
|
2018-07-05 18:34:45 +00:00
|
|
|
static NORETURN void usage_builtin_config(void);
|
builtin/config.c: support `--type=<type>` as preferred alias for `--<type>`
`git config` has long allowed the ability for callers to provide a 'type
specifier', which instructs `git config` to (1) ensure that incoming
values can be interpreted as that type, and (2) that outgoing values are
canonicalized under that type.
In another series, we propose to extend this functionality with
`--type=color` and `--default` to replace `--get-color`.
However, we traditionally use `--color` to mean "colorize this output",
instead of "this value should be treated as a color".
Currently, `git config` does not support this kind of colorization, but
we should be careful to avoid squatting on this option too soon, so that
`git config` can support `--color` (in the traditional sense) in the
future, if that is desired.
In this patch, we support `--type=<int|bool|bool-or-int|...>` in
addition to `--int`, `--bool`, and etc. This allows the aforementioned
upcoming patch to support querying a color value with a default via
`--type=color --default=...`, without squandering `--color`.
We retain the historic behavior of complaining when multiple,
legacy-style `--<type>` flags are given, as well as extend this to
conflicting new-style `--type=<type>` flags. `--int --type=int` (and its
commutative pair) does not complain, but `--bool --type=int` (and its
commutative pair) does.
Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-18 21:43:35 +00:00
|
|
|
|
|
|
|
static int option_parse_type(const struct option *opt, const char *arg,
|
|
|
|
int unset)
|
|
|
|
{
|
|
|
|
int new_type, *to_type;
|
|
|
|
|
|
|
|
if (unset) {
|
|
|
|
*((int *) opt->value) = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* To support '--<type>' style flags, begin with new_type equal to
|
|
|
|
* opt->defval.
|
|
|
|
*/
|
|
|
|
new_type = opt->defval;
|
|
|
|
if (!new_type) {
|
|
|
|
if (!strcmp(arg, "bool"))
|
|
|
|
new_type = TYPE_BOOL;
|
|
|
|
else if (!strcmp(arg, "int"))
|
|
|
|
new_type = TYPE_INT;
|
|
|
|
else if (!strcmp(arg, "bool-or-int"))
|
|
|
|
new_type = TYPE_BOOL_OR_INT;
|
|
|
|
else if (!strcmp(arg, "path"))
|
|
|
|
new_type = TYPE_PATH;
|
|
|
|
else if (!strcmp(arg, "expiry-date"))
|
|
|
|
new_type = TYPE_EXPIRY_DATE;
|
2018-04-10 00:18:31 +00:00
|
|
|
else if (!strcmp(arg, "color"))
|
|
|
|
new_type = TYPE_COLOR;
|
builtin/config.c: support `--type=<type>` as preferred alias for `--<type>`
`git config` has long allowed the ability for callers to provide a 'type
specifier', which instructs `git config` to (1) ensure that incoming
values can be interpreted as that type, and (2) that outgoing values are
canonicalized under that type.
In another series, we propose to extend this functionality with
`--type=color` and `--default` to replace `--get-color`.
However, we traditionally use `--color` to mean "colorize this output",
instead of "this value should be treated as a color".
Currently, `git config` does not support this kind of colorization, but
we should be careful to avoid squatting on this option too soon, so that
`git config` can support `--color` (in the traditional sense) in the
future, if that is desired.
In this patch, we support `--type=<int|bool|bool-or-int|...>` in
addition to `--int`, `--bool`, and etc. This allows the aforementioned
upcoming patch to support querying a color value with a default via
`--type=color --default=...`, without squandering `--color`.
We retain the historic behavior of complaining when multiple,
legacy-style `--<type>` flags are given, as well as extend this to
conflicting new-style `--type=<type>` flags. `--int --type=int` (and its
commutative pair) does not complain, but `--bool --type=int` (and its
commutative pair) does.
Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-18 21:43:35 +00:00
|
|
|
else
|
|
|
|
die(_("unrecognized --type argument, %s"), arg);
|
|
|
|
}
|
|
|
|
|
|
|
|
to_type = opt->value;
|
|
|
|
if (*to_type && *to_type != new_type) {
|
|
|
|
/*
|
|
|
|
* Complain when there is a new type not equal to the old type.
|
|
|
|
* This allows for combinations like '--int --type=int' and
|
|
|
|
* '--type=int --type=int', but disallows ones like '--type=bool
|
|
|
|
* --int' and '--type=bool
|
|
|
|
* --type=int'.
|
|
|
|
*/
|
2018-07-21 07:49:22 +00:00
|
|
|
error(_("only one type at a time"));
|
2018-07-05 18:34:45 +00:00
|
|
|
usage_builtin_config();
|
builtin/config.c: support `--type=<type>` as preferred alias for `--<type>`
`git config` has long allowed the ability for callers to provide a 'type
specifier', which instructs `git config` to (1) ensure that incoming
values can be interpreted as that type, and (2) that outgoing values are
canonicalized under that type.
In another series, we propose to extend this functionality with
`--type=color` and `--default` to replace `--get-color`.
However, we traditionally use `--color` to mean "colorize this output",
instead of "this value should be treated as a color".
Currently, `git config` does not support this kind of colorization, but
we should be careful to avoid squatting on this option too soon, so that
`git config` can support `--color` (in the traditional sense) in the
future, if that is desired.
In this patch, we support `--type=<int|bool|bool-or-int|...>` in
addition to `--int`, `--bool`, and etc. This allows the aforementioned
upcoming patch to support querying a color value with a default via
`--type=color --default=...`, without squandering `--color`.
We retain the historic behavior of complaining when multiple,
legacy-style `--<type>` flags are given, as well as extend this to
conflicting new-style `--type=<type>` flags. `--int --type=int` (and its
commutative pair) does not complain, but `--bool --type=int` (and its
commutative pair) does.
Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-18 21:43:35 +00:00
|
|
|
}
|
|
|
|
*to_type = new_type;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-02-21 00:49:25 +00:00
|
|
|
static struct option builtin_config_options[] = {
|
2012-08-20 12:32:05 +00:00
|
|
|
OPT_GROUP(N_("Config file location")),
|
2013-08-03 11:51:24 +00:00
|
|
|
OPT_BOOL(0, "global", &use_global_config, N_("use global config file")),
|
|
|
|
OPT_BOOL(0, "system", &use_system_config, N_("use system config file")),
|
|
|
|
OPT_BOOL(0, "local", &use_local_config, N_("use repository config file")),
|
2018-10-21 14:02:28 +00:00
|
|
|
OPT_BOOL(0, "worktree", &use_worktree_config, N_("use per-worktree config file")),
|
2014-02-18 22:58:54 +00:00
|
|
|
OPT_STRING('f', "file", &given_config_source.file, N_("file"), N_("use given config file")),
|
|
|
|
OPT_STRING(0, "blob", &given_config_source.blob, N_("blob-id"), N_("read config from given blob object")),
|
2012-08-20 12:32:05 +00:00
|
|
|
OPT_GROUP(N_("Action")),
|
|
|
|
OPT_BIT(0, "get", &actions, N_("get value: name [value-regex]"), ACTION_GET),
|
|
|
|
OPT_BIT(0, "get-all", &actions, N_("get all values: key [value-regex]"), ACTION_GET_ALL),
|
|
|
|
OPT_BIT(0, "get-regexp", &actions, N_("get values for regexp: name-regex [value-regex]"), ACTION_GET_REGEXP),
|
2013-07-31 18:14:59 +00:00
|
|
|
OPT_BIT(0, "get-urlmatch", &actions, N_("get value specific for the URL: section[.var] URL"), ACTION_GET_URLMATCH),
|
2012-08-20 12:32:05 +00:00
|
|
|
OPT_BIT(0, "replace-all", &actions, N_("replace all matching variables: name value [value_regex]"), ACTION_REPLACE_ALL),
|
2012-08-20 12:32:55 +00:00
|
|
|
OPT_BIT(0, "add", &actions, N_("add a new variable: name value"), ACTION_ADD),
|
|
|
|
OPT_BIT(0, "unset", &actions, N_("remove a variable: name [value-regex]"), ACTION_UNSET),
|
|
|
|
OPT_BIT(0, "unset-all", &actions, N_("remove all matches: name [value-regex]"), ACTION_UNSET_ALL),
|
2012-08-20 12:32:05 +00:00
|
|
|
OPT_BIT(0, "rename-section", &actions, N_("rename section: old-name new-name"), ACTION_RENAME_SECTION),
|
|
|
|
OPT_BIT(0, "remove-section", &actions, N_("remove a section: name"), ACTION_REMOVE_SECTION),
|
|
|
|
OPT_BIT('l', "list", &actions, N_("list all"), ACTION_LIST),
|
2012-08-20 12:32:55 +00:00
|
|
|
OPT_BIT('e', "edit", &actions, N_("open an editor"), ACTION_EDIT),
|
config: fix parsing of "git config --get-color some.key -1"
Most of git-config's command line options use OPT_BIT to
choose an action, and then parse the non-option arguments
in a context-dependent way. However, --get-color and
--get-colorbool are unlike the rest of the options, in that
they are OPT_STRING, taking the option name as a parameter.
This generally works, because we then use the presence of
those strings to set an action bit anyway. But it does mean
that the option-parser will continue looking for options
even after the key (because it is not a non-option; it is an
argument to an option). And running:
git config --get-color some.key -1
(to use "-1" as the default color spec) will barf, claiming
that "-1" is not an option. Instead, we should treat
--get-color and --get-colorbool as action bits, just like
--add, --get, and all the other actions, and then check that
the non-option arguments we got are sane. This fixes the
weirdness above, and makes those two options like all the
others.
This "fixes" a test in t4026, which checked that feeding
"-2" as a color should fail (it does fail, but prior to this
patch, because parseopt barfed, not because we actually ever
tried to parse the color).
This also catches other errors, like:
git config --get-color some.key black blue
which previously silently ignored "blue" (and now will
complain that you gave too many arguments).
There are some possible regressions, though. We now disallow
these, which currently do what you would expect:
# specifying other options after the action
git config --get-color some.key --file whatever
# using long-arg syntax
git config --get-color=some.key
However, we have never advertised these in the
documentation, and in fact they did not work in some older
versions of git. The behavior was apparently switched as an
accidental side effect of d64ec16 (git config: reorganize to
use parseopt, 2009-02-21).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-20 15:15:51 +00:00
|
|
|
OPT_BIT(0, "get-color", &actions, N_("find the color configured: slot [default]"), ACTION_GET_COLOR),
|
|
|
|
OPT_BIT(0, "get-colorbool", &actions, N_("find the color setting: slot [stdout-is-tty]"), ACTION_GET_COLORBOOL),
|
2012-08-20 12:32:05 +00:00
|
|
|
OPT_GROUP(N_("Type")),
|
builtin/config.c: support `--type=<type>` as preferred alias for `--<type>`
`git config` has long allowed the ability for callers to provide a 'type
specifier', which instructs `git config` to (1) ensure that incoming
values can be interpreted as that type, and (2) that outgoing values are
canonicalized under that type.
In another series, we propose to extend this functionality with
`--type=color` and `--default` to replace `--get-color`.
However, we traditionally use `--color` to mean "colorize this output",
instead of "this value should be treated as a color".
Currently, `git config` does not support this kind of colorization, but
we should be careful to avoid squatting on this option too soon, so that
`git config` can support `--color` (in the traditional sense) in the
future, if that is desired.
In this patch, we support `--type=<int|bool|bool-or-int|...>` in
addition to `--int`, `--bool`, and etc. This allows the aforementioned
upcoming patch to support querying a color value with a default via
`--type=color --default=...`, without squandering `--color`.
We retain the historic behavior of complaining when multiple,
legacy-style `--<type>` flags are given, as well as extend this to
conflicting new-style `--type=<type>` flags. `--int --type=int` (and its
commutative pair) does not complain, but `--bool --type=int` (and its
commutative pair) does.
Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-18 21:43:35 +00:00
|
|
|
OPT_CALLBACK('t', "type", &type, "", N_("value is given this type"), option_parse_type),
|
|
|
|
OPT_CALLBACK_VALUE(0, "bool", &type, N_("value is \"true\" or \"false\""), TYPE_BOOL),
|
|
|
|
OPT_CALLBACK_VALUE(0, "int", &type, N_("value is decimal number"), TYPE_INT),
|
|
|
|
OPT_CALLBACK_VALUE(0, "bool-or-int", &type, N_("value is --bool or --int"), TYPE_BOOL_OR_INT),
|
|
|
|
OPT_CALLBACK_VALUE(0, "path", &type, N_("value is a path (file or directory name)"), TYPE_PATH),
|
|
|
|
OPT_CALLBACK_VALUE(0, "expiry-date", &type, N_("value is an expiry date"), TYPE_EXPIRY_DATE),
|
2012-08-20 12:32:05 +00:00
|
|
|
OPT_GROUP(N_("Other")),
|
2020-01-24 00:21:01 +00:00
|
|
|
OPT_BOOL('z', "null", &end_nul, N_("terminate values with NUL byte")),
|
2015-08-10 09:46:06 +00:00
|
|
|
OPT_BOOL(0, "name-only", &omit_values, N_("show variable names only")),
|
2017-04-17 10:10:00 +00:00
|
|
|
OPT_BOOL(0, "includes", &respect_includes_opt, N_("respect include directives on lookup")),
|
2016-02-19 09:16:02 +00:00
|
|
|
OPT_BOOL(0, "show-origin", &show_origin, N_("show origin of config (file, standard input, blob, command line)")),
|
2020-02-10 00:30:59 +00:00
|
|
|
OPT_BOOL(0, "show-scope", &show_scope, N_("show scope of config (worktree, local, global, system, command)")),
|
builtin/config: introduce `--default`
For some use cases, callers of the `git-config(1)` builtin would like to
fallback to default values when the variable asked for does not exist.
In addition, users would like to use existing type specifiers to ensure
that values are parsed correctly when they do exist in the
configuration.
For example, to fetch a value without a type specifier and fallback to
`$fallback`, the following is required:
$ git config core.foo || echo "$fallback"
This is fine for most values, but can be tricky for difficult-to-express
`$fallback`'s, like ANSI color codes.
This motivates `--get-color`, which is a one-off exception to the normal
type specifier rules wherein a user specifies both the configuration
variable and an optional fallback. Both are formatted according to their
type specifier, which eases the burden on the user to ensure that values
are correctly formatted.
This commit (and those following it in this series) aim to eventually
replace `--get-color` with a consistent alternative. By introducing
`--default`, we allow the `--get-color` action to be promoted to a
`--type=color` type specifier, retaining the "fallback" behavior via the
`--default` flag introduced in this commit.
For example, we aim to replace:
$ git config --get-color variable [default] [...]
with:
$ git config --default default --type=color variable [...]
Values filled by `--default` behave exactly as if they were present in
the affected configuration file; they will be parsed by type specifiers
without the knowledge that they are not themselves present in the
configuration.
Specifically, this means that the following will work:
$ git config --int --default 1M does.not.exist
1048576
In subsequent commits, we will offer `--type=color`, which (in
conjunction with `--default`) will be sufficient to replace
`--get-color`.
Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-10 00:18:26 +00:00
|
|
|
OPT_STRING(0, "default", &default_value, N_("value"), N_("with --get, use default value when missing entry")),
|
2009-02-21 00:49:25 +00:00
|
|
|
OPT_END(),
|
|
|
|
};
|
|
|
|
|
2018-07-05 18:34:45 +00:00
|
|
|
static NORETURN void usage_builtin_config(void)
|
|
|
|
{
|
|
|
|
usage_with_options(builtin_config_usage, builtin_config_options);
|
|
|
|
}
|
|
|
|
|
2018-12-09 10:25:21 +00:00
|
|
|
static void check_argc(int argc, int min, int max)
|
|
|
|
{
|
2009-02-21 00:49:25 +00:00
|
|
|
if (argc >= min && argc <= max)
|
|
|
|
return;
|
2018-07-21 07:49:19 +00:00
|
|
|
if (min == max)
|
2018-07-21 07:49:22 +00:00
|
|
|
error(_("wrong number of arguments, should be %d"), min);
|
2018-07-21 07:49:19 +00:00
|
|
|
else
|
2018-07-21 07:49:22 +00:00
|
|
|
error(_("wrong number of arguments, should be from %d to %d"),
|
2018-07-21 07:49:19 +00:00
|
|
|
min, max);
|
2018-07-05 18:34:45 +00:00
|
|
|
usage_builtin_config();
|
2009-02-21 00:49:25 +00:00
|
|
|
}
|
|
|
|
|
2016-02-19 09:16:02 +00:00
|
|
|
static void show_config_origin(struct strbuf *buf)
|
|
|
|
{
|
2020-01-24 00:21:01 +00:00
|
|
|
const char term = end_nul ? '\0' : '\t';
|
2016-02-19 09:16:02 +00:00
|
|
|
|
|
|
|
strbuf_addstr(buf, current_config_origin_type());
|
|
|
|
strbuf_addch(buf, ':');
|
2020-01-24 00:21:01 +00:00
|
|
|
if (end_nul)
|
2016-02-19 09:16:02 +00:00
|
|
|
strbuf_addstr(buf, current_config_name());
|
|
|
|
else
|
|
|
|
quote_c_style(current_config_name(), buf, NULL, 0);
|
|
|
|
strbuf_addch(buf, term);
|
|
|
|
}
|
|
|
|
|
2020-02-10 00:30:59 +00:00
|
|
|
static void show_config_scope(struct strbuf *buf)
|
|
|
|
{
|
|
|
|
const char term = end_nul ? '\0' : '\t';
|
|
|
|
const char *scope = config_scope_name(current_config_scope());
|
|
|
|
|
|
|
|
strbuf_addstr(buf, N_(scope));
|
|
|
|
strbuf_addch(buf, term);
|
|
|
|
}
|
|
|
|
|
2008-05-14 17:46:53 +00:00
|
|
|
static int show_all_config(const char *key_, const char *value_, void *cb)
|
2006-04-24 22:59:25 +00:00
|
|
|
{
|
2020-02-10 00:30:59 +00:00
|
|
|
if (show_origin || show_scope) {
|
2016-02-19 09:16:02 +00:00
|
|
|
struct strbuf buf = STRBUF_INIT;
|
2020-02-10 00:30:59 +00:00
|
|
|
if (show_scope)
|
|
|
|
show_config_scope(&buf);
|
|
|
|
if (show_origin)
|
|
|
|
show_config_origin(&buf);
|
2016-02-19 09:16:02 +00:00
|
|
|
/* Use fwrite as "buf" can contain \0's if "end_null" is set. */
|
|
|
|
fwrite(buf.buf, 1, buf.len, stdout);
|
|
|
|
strbuf_release(&buf);
|
|
|
|
}
|
2015-08-10 09:46:06 +00:00
|
|
|
if (!omit_values && value_)
|
2007-06-25 14:03:55 +00:00
|
|
|
printf("%s%c%s%c", key_, delim, value_, term);
|
2006-04-24 22:59:25 +00:00
|
|
|
else
|
2007-06-25 14:03:55 +00:00
|
|
|
printf("%s%c", key_, term);
|
2006-04-24 22:59:25 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-10-23 19:51:50 +00:00
|
|
|
struct strbuf_list {
|
|
|
|
struct strbuf *items;
|
|
|
|
int nr;
|
|
|
|
int alloc;
|
|
|
|
};
|
|
|
|
|
2013-07-29 21:23:16 +00:00
|
|
|
static int format_config(struct strbuf *buf, const char *key_, const char *value_)
|
2005-11-20 05:52:22 +00:00
|
|
|
{
|
2020-02-10 00:30:59 +00:00
|
|
|
if (show_scope)
|
|
|
|
show_config_scope(buf);
|
2016-02-19 09:16:02 +00:00
|
|
|
if (show_origin)
|
|
|
|
show_config_origin(buf);
|
2015-08-20 14:14:22 +00:00
|
|
|
if (show_keys)
|
2012-10-23 19:51:50 +00:00
|
|
|
strbuf_addstr(buf, key_);
|
2015-08-20 14:14:22 +00:00
|
|
|
if (!omit_values) {
|
2015-08-20 14:47:34 +00:00
|
|
|
if (show_keys)
|
|
|
|
strbuf_addch(buf, key_delim);
|
2015-08-20 14:14:22 +00:00
|
|
|
|
builtin/config.c: treat type specifiers singularly
Internally, we represent `git config`'s type specifiers as a bitset
using OPT_BIT. 'bool' is 1<<0, 'int' is 1<<1, and so on. This technique
allows for the representation of multiple type specifiers in the `int
types` field, but this multi-representation is left unused.
In fact, `git config` will not accept multiple type specifiers at a
time, as indicated by:
$ git config --int --bool some.section
error: only one type at a time.
This patch uses `OPT_SET_INT` to prefer the _last_ mentioned type
specifier, so that the above command would instead be valid, and a
synonym of:
$ git config --bool some.section
This change is motivated by two urges: (1) it does not make sense to
represent a singular type specifier internally as a bitset, only to
complain when there are multiple bits in the set. `OPT_SET_INT` is more
well-suited to this task than `OPT_BIT` is. (2) a future patch will
introduce `--type=<type>`, and we would like not to complain in the
following situation:
$ git config --int --type=int
Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 22:46:54 +00:00
|
|
|
if (type == TYPE_INT)
|
2015-08-20 14:47:34 +00:00
|
|
|
strbuf_addf(buf, "%"PRId64,
|
|
|
|
git_config_int64(key_, value_ ? value_ : ""));
|
builtin/config.c: treat type specifiers singularly
Internally, we represent `git config`'s type specifiers as a bitset
using OPT_BIT. 'bool' is 1<<0, 'int' is 1<<1, and so on. This technique
allows for the representation of multiple type specifiers in the `int
types` field, but this multi-representation is left unused.
In fact, `git config` will not accept multiple type specifiers at a
time, as indicated by:
$ git config --int --bool some.section
error: only one type at a time.
This patch uses `OPT_SET_INT` to prefer the _last_ mentioned type
specifier, so that the above command would instead be valid, and a
synonym of:
$ git config --bool some.section
This change is motivated by two urges: (1) it does not make sense to
represent a singular type specifier internally as a bitset, only to
complain when there are multiple bits in the set. `OPT_SET_INT` is more
well-suited to this task than `OPT_BIT` is. (2) a future patch will
introduce `--type=<type>`, and we would like not to complain in the
following situation:
$ git config --int --type=int
Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 22:46:54 +00:00
|
|
|
else if (type == TYPE_BOOL)
|
2015-08-20 14:47:34 +00:00
|
|
|
strbuf_addstr(buf, git_config_bool(key_, value_) ?
|
|
|
|
"true" : "false");
|
builtin/config.c: treat type specifiers singularly
Internally, we represent `git config`'s type specifiers as a bitset
using OPT_BIT. 'bool' is 1<<0, 'int' is 1<<1, and so on. This technique
allows for the representation of multiple type specifiers in the `int
types` field, but this multi-representation is left unused.
In fact, `git config` will not accept multiple type specifiers at a
time, as indicated by:
$ git config --int --bool some.section
error: only one type at a time.
This patch uses `OPT_SET_INT` to prefer the _last_ mentioned type
specifier, so that the above command would instead be valid, and a
synonym of:
$ git config --bool some.section
This change is motivated by two urges: (1) it does not make sense to
represent a singular type specifier internally as a bitset, only to
complain when there are multiple bits in the set. `OPT_SET_INT` is more
well-suited to this task than `OPT_BIT` is. (2) a future patch will
introduce `--type=<type>`, and we would like not to complain in the
following situation:
$ git config --int --type=int
Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 22:46:54 +00:00
|
|
|
else if (type == TYPE_BOOL_OR_INT) {
|
2015-08-20 14:14:22 +00:00
|
|
|
int is_bool, v;
|
|
|
|
v = git_config_bool_or_int(key_, value_, &is_bool);
|
|
|
|
if (is_bool)
|
2015-08-20 14:47:34 +00:00
|
|
|
strbuf_addstr(buf, v ? "true" : "false");
|
2015-08-20 14:14:22 +00:00
|
|
|
else
|
2015-08-20 14:47:34 +00:00
|
|
|
strbuf_addf(buf, "%d", v);
|
builtin/config.c: treat type specifiers singularly
Internally, we represent `git config`'s type specifiers as a bitset
using OPT_BIT. 'bool' is 1<<0, 'int' is 1<<1, and so on. This technique
allows for the representation of multiple type specifiers in the `int
types` field, but this multi-representation is left unused.
In fact, `git config` will not accept multiple type specifiers at a
time, as indicated by:
$ git config --int --bool some.section
error: only one type at a time.
This patch uses `OPT_SET_INT` to prefer the _last_ mentioned type
specifier, so that the above command would instead be valid, and a
synonym of:
$ git config --bool some.section
This change is motivated by two urges: (1) it does not make sense to
represent a singular type specifier internally as a bitset, only to
complain when there are multiple bits in the set. `OPT_SET_INT` is more
well-suited to this task than `OPT_BIT` is. (2) a future patch will
introduce `--type=<type>`, and we would like not to complain in the
following situation:
$ git config --int --type=int
Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 22:46:54 +00:00
|
|
|
} else if (type == TYPE_PATH) {
|
2015-08-20 14:47:34 +00:00
|
|
|
const char *v;
|
|
|
|
if (git_config_pathname(&v, key_, value_) < 0)
|
2015-08-20 14:14:22 +00:00
|
|
|
return -1;
|
2015-08-20 14:47:34 +00:00
|
|
|
strbuf_addstr(buf, v);
|
|
|
|
free((char *)v);
|
builtin/config.c: treat type specifiers singularly
Internally, we represent `git config`'s type specifiers as a bitset
using OPT_BIT. 'bool' is 1<<0, 'int' is 1<<1, and so on. This technique
allows for the representation of multiple type specifiers in the `int
types` field, but this multi-representation is left unused.
In fact, `git config` will not accept multiple type specifiers at a
time, as indicated by:
$ git config --int --bool some.section
error: only one type at a time.
This patch uses `OPT_SET_INT` to prefer the _last_ mentioned type
specifier, so that the above command would instead be valid, and a
synonym of:
$ git config --bool some.section
This change is motivated by two urges: (1) it does not make sense to
represent a singular type specifier internally as a bitset, only to
complain when there are multiple bits in the set. `OPT_SET_INT` is more
well-suited to this task than `OPT_BIT` is. (2) a future patch will
introduce `--type=<type>`, and we would like not to complain in the
following situation:
$ git config --int --type=int
Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 22:46:54 +00:00
|
|
|
} else if (type == TYPE_EXPIRY_DATE) {
|
2017-11-18 02:27:27 +00:00
|
|
|
timestamp_t t;
|
|
|
|
if (git_config_expiry_date(&t, key_, value_) < 0)
|
|
|
|
return -1;
|
|
|
|
strbuf_addf(buf, "%"PRItime, t);
|
2018-04-10 00:18:31 +00:00
|
|
|
} else if (type == TYPE_COLOR) {
|
|
|
|
char v[COLOR_MAXLEN];
|
|
|
|
if (git_config_color(v, key_, value_) < 0)
|
|
|
|
return -1;
|
|
|
|
strbuf_addstr(buf, v);
|
2015-08-20 14:14:22 +00:00
|
|
|
} else if (value_) {
|
2015-08-20 14:47:34 +00:00
|
|
|
strbuf_addstr(buf, value_);
|
2015-08-20 14:14:22 +00:00
|
|
|
} else {
|
2015-08-20 14:47:34 +00:00
|
|
|
/* Just show the key name; back out delimiter */
|
|
|
|
if (show_keys)
|
|
|
|
strbuf_setlen(buf, buf->len - 1);
|
2015-08-20 14:14:22 +00:00
|
|
|
}
|
2015-08-10 09:46:06 +00:00
|
|
|
}
|
git-config: do not complain about duplicate entries
If git-config is asked for a single value, it will complain
and exit with an error if it finds multiple instances of
that value. This is unlike the usual internal config
parsing, however, which will generally overwrite previous
values, leaving only the final one. For example:
[set a multivar]
$ git config user.email one@example.com
$ git config --add user.email two@example.com
[use the internal parser to fetch it]
$ git var GIT_AUTHOR_IDENT
Your Name <two@example.com> ...
[use git-config to fetch it]
$ git config user.email
one@example.com
error: More than one value for the key user.email: two@example.com
This overwriting behavior is critical for the regular
parser, which starts with the lowest-priority file (e.g.,
/etc/gitconfig) and proceeds to the highest-priority file
($GIT_DIR/config). Overwriting yields the highest priority
value at the end.
Git-config solves this problem by implementing its own
parsing. It goes from highest to lowest priorty, but does
not proceed to the next file if it has seen a value.
So in practice, this distinction never mattered much,
because it only triggered for values in the same file. And
there was not much point in doing that; the real value is in
overwriting values from lower-priority files.
However, this changed with the implementation of config
include files. Now we might see an include overriding a
value from the parent file, which is a sensible thing to do,
but git-config will flag as a duplication.
This patch drops the duplicate detection for git-config and
switches to a pure-overwrite model (for the single case;
--get-all can still be used if callers want to do something
more fancy).
As is shown by the modifications to the test suite, this is
a user-visible change in behavior. An alternative would be
to just change the include case, but this is much cleaner
for a few reasons:
1. If you change the include case, then to what? If you
just stop parsing includes after getting a value, then
you will get a _different_ answer than the regular
config parser (you'll get the first value instead of
the last value). So you'd want to implement overwrite
semantics anyway.
2. Even though it is a change in behavior for git-config,
it is bringing us in line with what the internal
parsers already do.
3. The file-order reimplementation is the only thing
keeping us from sharing more code with the internal
config parser, which will help keep differences to a
minimum.
Going under the assumption that the primary purpose of
git-config is to behave identically to how git's internal
parsing works, this change can be seen as a bug-fix.
Signed-off-by: Jeff King <peff@peff.net>
2012-10-23 20:52:44 +00:00
|
|
|
strbuf_addch(buf, term);
|
2005-11-20 05:52:22 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-07-29 21:23:16 +00:00
|
|
|
static int collect_config(const char *key_, const char *value_, void *cb)
|
|
|
|
{
|
|
|
|
struct strbuf_list *values = cb;
|
|
|
|
|
|
|
|
if (!use_key_regexp && strcmp(key_, key))
|
|
|
|
return 0;
|
|
|
|
if (use_key_regexp && regexec(key_regexp, key_, 0, NULL, 0))
|
|
|
|
return 0;
|
|
|
|
if (regexp != NULL &&
|
|
|
|
(do_not_match ^ !!regexec(regexp, (value_?value_:""), 0, NULL, 0)))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
ALLOC_GROW(values->items, values->nr + 1, values->alloc);
|
2015-08-20 14:46:04 +00:00
|
|
|
strbuf_init(&values->items[values->nr], 0);
|
2013-07-29 21:23:16 +00:00
|
|
|
|
|
|
|
return format_config(&values->items[values->nr++], key_, value_);
|
|
|
|
}
|
|
|
|
|
2009-02-21 00:48:53 +00:00
|
|
|
static int get_value(const char *key_, const char *regex_)
|
2005-11-20 05:52:22 +00:00
|
|
|
{
|
2012-07-29 20:43:21 +00:00
|
|
|
int ret = CONFIG_GENERIC_ERROR;
|
2012-10-28 21:05:25 +00:00
|
|
|
struct strbuf_list values = {NULL};
|
2012-10-23 19:51:50 +00:00
|
|
|
int i;
|
2005-11-20 05:52:22 +00:00
|
|
|
|
2006-05-02 12:22:48 +00:00
|
|
|
if (use_key_regexp) {
|
2011-01-30 19:40:41 +00:00
|
|
|
char *tl;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* NEEDSWORK: this naive pattern lowercasing obviously does not
|
|
|
|
* work for more complex patterns like "^[^.]*Foo.*bar".
|
|
|
|
* Perhaps we should deprecate this altogether someday.
|
|
|
|
*/
|
|
|
|
|
|
|
|
key = xstrdup(key_);
|
|
|
|
for (tl = key + strlen(key) - 1;
|
|
|
|
tl >= key && *tl != '.';
|
|
|
|
tl--)
|
|
|
|
*tl = tolower(*tl);
|
|
|
|
for (tl = key; *tl && *tl != '.'; tl++)
|
|
|
|
*tl = tolower(*tl);
|
|
|
|
|
2006-08-31 22:32:39 +00:00
|
|
|
key_regexp = (regex_t*)xmalloc(sizeof(regex_t));
|
2006-05-02 12:22:48 +00:00
|
|
|
if (regcomp(key_regexp, key, REG_EXTENDED)) {
|
2018-07-21 07:49:22 +00:00
|
|
|
error(_("invalid key pattern: %s"), key_);
|
2017-06-15 23:15:46 +00:00
|
|
|
FREE_AND_NULL(key_regexp);
|
2012-07-29 20:43:21 +00:00
|
|
|
ret = CONFIG_INVALID_PATTERN;
|
Read configuration also from $HOME/.gitconfig
This patch is based on Pasky's, with three notable differences:
- I did not yet update the documentation
- I named it .gitconfig, not .gitrc
- git-repo-config does not barf when a unique key is overridden locally
The last means that if you have something like
[alias]
l = log --stat -M
in ~/.gitconfig, and
[alias]
l = log --stat -M next..
in $GIT_DIR/config, then
git-repo-config alias.l
returns only one value, namely the value from $GIT_DIR/config.
If you set the environment variable GIT_CONFIG, $HOME/.gitconfig is not
read, and neither $GIT_DIR/config, but $GIT_CONFIG instead.
If you set GIT_CONFIG_LOCAL instead, it is interpreted instead of
$GIT_DIR/config, but $HOME/.gitconfig is still read.
Signed-off-by: Johannes Schindelin <Johannes.Schindelin@gmx.de>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-06-19 23:48:03 +00:00
|
|
|
goto free_strings;
|
2006-05-02 12:22:48 +00:00
|
|
|
}
|
2011-01-30 19:40:41 +00:00
|
|
|
} else {
|
2012-07-29 20:43:21 +00:00
|
|
|
if (git_config_parse_key(key_, &key, NULL)) {
|
|
|
|
ret = CONFIG_INVALID_KEY;
|
2011-01-30 19:40:41 +00:00
|
|
|
goto free_strings;
|
2012-07-29 20:43:21 +00:00
|
|
|
}
|
2006-05-02 12:22:48 +00:00
|
|
|
}
|
|
|
|
|
2005-11-20 05:52:22 +00:00
|
|
|
if (regex_) {
|
2005-11-20 12:24:18 +00:00
|
|
|
if (regex_[0] == '!') {
|
|
|
|
do_not_match = 1;
|
|
|
|
regex_++;
|
|
|
|
}
|
|
|
|
|
2006-08-31 22:32:39 +00:00
|
|
|
regexp = (regex_t*)xmalloc(sizeof(regex_t));
|
2006-01-05 00:31:02 +00:00
|
|
|
if (regcomp(regexp, regex_, REG_EXTENDED)) {
|
2018-07-21 07:49:22 +00:00
|
|
|
error(_("invalid pattern: %s"), regex_);
|
2017-06-15 23:15:46 +00:00
|
|
|
FREE_AND_NULL(regexp);
|
2012-07-29 20:43:21 +00:00
|
|
|
ret = CONFIG_INVALID_PATTERN;
|
Read configuration also from $HOME/.gitconfig
This patch is based on Pasky's, with three notable differences:
- I did not yet update the documentation
- I named it .gitconfig, not .gitrc
- git-repo-config does not barf when a unique key is overridden locally
The last means that if you have something like
[alias]
l = log --stat -M
in ~/.gitconfig, and
[alias]
l = log --stat -M next..
in $GIT_DIR/config, then
git-repo-config alias.l
returns only one value, namely the value from $GIT_DIR/config.
If you set the environment variable GIT_CONFIG, $HOME/.gitconfig is not
read, and neither $GIT_DIR/config, but $GIT_CONFIG instead.
If you set GIT_CONFIG_LOCAL instead, it is interpreted instead of
$GIT_DIR/config, but $HOME/.gitconfig is still read.
Signed-off-by: Johannes Schindelin <Johannes.Schindelin@gmx.de>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-06-19 23:48:03 +00:00
|
|
|
goto free_strings;
|
2005-11-20 05:52:22 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-14 18:07:39 +00:00
|
|
|
config_with_options(collect_config, &values,
|
|
|
|
&given_config_source, &config_options);
|
Read configuration also from $HOME/.gitconfig
This patch is based on Pasky's, with three notable differences:
- I did not yet update the documentation
- I named it .gitconfig, not .gitrc
- git-repo-config does not barf when a unique key is overridden locally
The last means that if you have something like
[alias]
l = log --stat -M
in ~/.gitconfig, and
[alias]
l = log --stat -M next..
in $GIT_DIR/config, then
git-repo-config alias.l
returns only one value, namely the value from $GIT_DIR/config.
If you set the environment variable GIT_CONFIG, $HOME/.gitconfig is not
read, and neither $GIT_DIR/config, but $GIT_CONFIG instead.
If you set GIT_CONFIG_LOCAL instead, it is interpreted instead of
$GIT_DIR/config, but $HOME/.gitconfig is still read.
Signed-off-by: Johannes Schindelin <Johannes.Schindelin@gmx.de>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-06-19 23:48:03 +00:00
|
|
|
|
builtin/config: introduce `--default`
For some use cases, callers of the `git-config(1)` builtin would like to
fallback to default values when the variable asked for does not exist.
In addition, users would like to use existing type specifiers to ensure
that values are parsed correctly when they do exist in the
configuration.
For example, to fetch a value without a type specifier and fallback to
`$fallback`, the following is required:
$ git config core.foo || echo "$fallback"
This is fine for most values, but can be tricky for difficult-to-express
`$fallback`'s, like ANSI color codes.
This motivates `--get-color`, which is a one-off exception to the normal
type specifier rules wherein a user specifies both the configuration
variable and an optional fallback. Both are formatted according to their
type specifier, which eases the burden on the user to ensure that values
are correctly formatted.
This commit (and those following it in this series) aim to eventually
replace `--get-color` with a consistent alternative. By introducing
`--default`, we allow the `--get-color` action to be promoted to a
`--type=color` type specifier, retaining the "fallback" behavior via the
`--default` flag introduced in this commit.
For example, we aim to replace:
$ git config --get-color variable [default] [...]
with:
$ git config --default default --type=color variable [...]
Values filled by `--default` behave exactly as if they were present in
the affected configuration file; they will be parsed by type specifiers
without the knowledge that they are not themselves present in the
configuration.
Specifically, this means that the following will work:
$ git config --int --default 1M does.not.exist
1048576
In subsequent commits, we will offer `--type=color`, which (in
conjunction with `--default`) will be sufficient to replace
`--get-color`.
Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-10 00:18:26 +00:00
|
|
|
if (!values.nr && default_value) {
|
|
|
|
struct strbuf *item;
|
|
|
|
ALLOC_GROW(values.items, values.nr + 1, values.alloc);
|
|
|
|
item = &values.items[values.nr++];
|
|
|
|
strbuf_init(item, 0);
|
|
|
|
if (format_config(item, key_, default_value) < 0)
|
|
|
|
die(_("failed to format default config value: %s"),
|
|
|
|
default_value);
|
|
|
|
}
|
|
|
|
|
git-config: do not complain about duplicate entries
If git-config is asked for a single value, it will complain
and exit with an error if it finds multiple instances of
that value. This is unlike the usual internal config
parsing, however, which will generally overwrite previous
values, leaving only the final one. For example:
[set a multivar]
$ git config user.email one@example.com
$ git config --add user.email two@example.com
[use the internal parser to fetch it]
$ git var GIT_AUTHOR_IDENT
Your Name <two@example.com> ...
[use git-config to fetch it]
$ git config user.email
one@example.com
error: More than one value for the key user.email: two@example.com
This overwriting behavior is critical for the regular
parser, which starts with the lowest-priority file (e.g.,
/etc/gitconfig) and proceeds to the highest-priority file
($GIT_DIR/config). Overwriting yields the highest priority
value at the end.
Git-config solves this problem by implementing its own
parsing. It goes from highest to lowest priorty, but does
not proceed to the next file if it has seen a value.
So in practice, this distinction never mattered much,
because it only triggered for values in the same file. And
there was not much point in doing that; the real value is in
overwriting values from lower-priority files.
However, this changed with the implementation of config
include files. Now we might see an include overriding a
value from the parent file, which is a sensible thing to do,
but git-config will flag as a duplication.
This patch drops the duplicate detection for git-config and
switches to a pure-overwrite model (for the single case;
--get-all can still be used if callers want to do something
more fancy).
As is shown by the modifications to the test suite, this is
a user-visible change in behavior. An alternative would be
to just change the include case, but this is much cleaner
for a few reasons:
1. If you change the include case, then to what? If you
just stop parsing includes after getting a value, then
you will get a _different_ answer than the regular
config parser (you'll get the first value instead of
the last value). So you'd want to implement overwrite
semantics anyway.
2. Even though it is a change in behavior for git-config,
it is bringing us in line with what the internal
parsers already do.
3. The file-order reimplementation is the only thing
keeping us from sharing more code with the internal
config parser, which will help keep differences to a
minimum.
Going under the assumption that the primary purpose of
git-config is to behave identically to how git's internal
parsing works, this change can be seen as a bug-fix.
Signed-off-by: Jeff King <peff@peff.net>
2012-10-23 20:52:44 +00:00
|
|
|
ret = !values.nr;
|
config: add include directive
It can be useful to split your ~/.gitconfig across multiple
files. For example, you might have a "main" file which is
used on many machines, but a small set of per-machine
tweaks. Or you may want to make some of your config public
(e.g., clever aliases) while keeping other data back (e.g.,
your name or other identifying information). Or you may want
to include a number of config options in some subset of your
repos without copying and pasting (e.g., you want to
reference them from the .git/config of participating repos).
This patch introduces an include directive for config files.
It looks like:
[include]
path = /path/to/file
This is syntactically backwards-compatible with existing git
config parsers (i.e., they will see it as another config
entry and ignore it unless you are looking up include.path).
The implementation provides a "git_config_include" callback
which wraps regular config callbacks. Callers can pass it to
git_config_from_file, and it will transparently follow any
include directives, passing all of the discovered options to
the real callback.
Include directives are turned on automatically for "regular"
git config parsing. This includes calls to git_config, as
well as calls to the "git config" program that do not
specify a single file (e.g., using "-f", "--global", etc).
They are not turned on in other cases, including:
1. Parsing of other config-like files, like .gitmodules.
There isn't a real need, and I'd rather be conservative
and avoid unnecessary incompatibility or confusion.
2. Reading single files via "git config". This is for two
reasons:
a. backwards compatibility with scripts looking at
config-like files.
b. inspection of a specific file probably means you
care about just what's in that file, not a general
lookup for "do we have this value anywhere at
all". If that is not the case, the caller can
always specify "--includes".
3. Writing files via "git config"; we want to treat
include.* variables as literal items to be copied (or
modified), and not expand them. So "git config
--unset-all foo.bar" would operate _only_ on
.git/config, not any of its included files (just as it
also does not operate on ~/.gitconfig).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-02-06 09:54:04 +00:00
|
|
|
|
2012-10-23 19:51:50 +00:00
|
|
|
for (i = 0; i < values.nr; i++) {
|
|
|
|
struct strbuf *buf = values.items + i;
|
git-config: do not complain about duplicate entries
If git-config is asked for a single value, it will complain
and exit with an error if it finds multiple instances of
that value. This is unlike the usual internal config
parsing, however, which will generally overwrite previous
values, leaving only the final one. For example:
[set a multivar]
$ git config user.email one@example.com
$ git config --add user.email two@example.com
[use the internal parser to fetch it]
$ git var GIT_AUTHOR_IDENT
Your Name <two@example.com> ...
[use git-config to fetch it]
$ git config user.email
one@example.com
error: More than one value for the key user.email: two@example.com
This overwriting behavior is critical for the regular
parser, which starts with the lowest-priority file (e.g.,
/etc/gitconfig) and proceeds to the highest-priority file
($GIT_DIR/config). Overwriting yields the highest priority
value at the end.
Git-config solves this problem by implementing its own
parsing. It goes from highest to lowest priorty, but does
not proceed to the next file if it has seen a value.
So in practice, this distinction never mattered much,
because it only triggered for values in the same file. And
there was not much point in doing that; the real value is in
overwriting values from lower-priority files.
However, this changed with the implementation of config
include files. Now we might see an include overriding a
value from the parent file, which is a sensible thing to do,
but git-config will flag as a duplication.
This patch drops the duplicate detection for git-config and
switches to a pure-overwrite model (for the single case;
--get-all can still be used if callers want to do something
more fancy).
As is shown by the modifications to the test suite, this is
a user-visible change in behavior. An alternative would be
to just change the include case, but this is much cleaner
for a few reasons:
1. If you change the include case, then to what? If you
just stop parsing includes after getting a value, then
you will get a _different_ answer than the regular
config parser (you'll get the first value instead of
the last value). So you'd want to implement overwrite
semantics anyway.
2. Even though it is a change in behavior for git-config,
it is bringing us in line with what the internal
parsers already do.
3. The file-order reimplementation is the only thing
keeping us from sharing more code with the internal
config parser, which will help keep differences to a
minimum.
Going under the assumption that the primary purpose of
git-config is to behave identically to how git's internal
parsing works, this change can be seen as a bug-fix.
Signed-off-by: Jeff King <peff@peff.net>
2012-10-23 20:52:44 +00:00
|
|
|
if (do_all || i == values.nr - 1)
|
|
|
|
fwrite(buf->buf, 1, buf->len, stdout);
|
2012-10-23 19:51:50 +00:00
|
|
|
strbuf_release(buf);
|
|
|
|
}
|
|
|
|
free(values.items);
|
Read configuration also from $HOME/.gitconfig
This patch is based on Pasky's, with three notable differences:
- I did not yet update the documentation
- I named it .gitconfig, not .gitrc
- git-repo-config does not barf when a unique key is overridden locally
The last means that if you have something like
[alias]
l = log --stat -M
in ~/.gitconfig, and
[alias]
l = log --stat -M next..
in $GIT_DIR/config, then
git-repo-config alias.l
returns only one value, namely the value from $GIT_DIR/config.
If you set the environment variable GIT_CONFIG, $HOME/.gitconfig is not
read, and neither $GIT_DIR/config, but $GIT_CONFIG instead.
If you set GIT_CONFIG_LOCAL instead, it is interpreted instead of
$GIT_DIR/config, but $HOME/.gitconfig is still read.
Signed-off-by: Johannes Schindelin <Johannes.Schindelin@gmx.de>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-06-19 23:48:03 +00:00
|
|
|
|
2012-10-23 19:40:06 +00:00
|
|
|
free_strings:
|
2005-11-20 05:52:22 +00:00
|
|
|
free(key);
|
2012-10-23 19:36:12 +00:00
|
|
|
if (key_regexp) {
|
|
|
|
regfree(key_regexp);
|
|
|
|
free(key_regexp);
|
|
|
|
}
|
2006-01-05 00:31:02 +00:00
|
|
|
if (regexp) {
|
|
|
|
regfree(regexp);
|
|
|
|
free(regexp);
|
2005-11-20 05:52:22 +00:00
|
|
|
}
|
|
|
|
|
Read configuration also from $HOME/.gitconfig
This patch is based on Pasky's, with three notable differences:
- I did not yet update the documentation
- I named it .gitconfig, not .gitrc
- git-repo-config does not barf when a unique key is overridden locally
The last means that if you have something like
[alias]
l = log --stat -M
in ~/.gitconfig, and
[alias]
l = log --stat -M next..
in $GIT_DIR/config, then
git-repo-config alias.l
returns only one value, namely the value from $GIT_DIR/config.
If you set the environment variable GIT_CONFIG, $HOME/.gitconfig is not
read, and neither $GIT_DIR/config, but $GIT_CONFIG instead.
If you set GIT_CONFIG_LOCAL instead, it is interpreted instead of
$GIT_DIR/config, but $HOME/.gitconfig is still read.
Signed-off-by: Johannes Schindelin <Johannes.Schindelin@gmx.de>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-06-19 23:48:03 +00:00
|
|
|
return ret;
|
2005-11-20 05:52:22 +00:00
|
|
|
}
|
2005-11-17 21:44:55 +00:00
|
|
|
|
2008-07-23 23:09:35 +00:00
|
|
|
static char *normalize_value(const char *key, const char *value)
|
2007-06-25 14:00:24 +00:00
|
|
|
{
|
|
|
|
if (!value)
|
|
|
|
return NULL;
|
|
|
|
|
builtin/config.c: treat type specifiers singularly
Internally, we represent `git config`'s type specifiers as a bitset
using OPT_BIT. 'bool' is 1<<0, 'int' is 1<<1, and so on. This technique
allows for the representation of multiple type specifiers in the `int
types` field, but this multi-representation is left unused.
In fact, `git config` will not accept multiple type specifiers at a
time, as indicated by:
$ git config --int --bool some.section
error: only one type at a time.
This patch uses `OPT_SET_INT` to prefer the _last_ mentioned type
specifier, so that the above command would instead be valid, and a
synonym of:
$ git config --bool some.section
This change is motivated by two urges: (1) it does not make sense to
represent a singular type specifier internally as a bitset, only to
complain when there are multiple bits in the set. `OPT_SET_INT` is more
well-suited to this task than `OPT_BIT` is. (2) a future patch will
introduce `--type=<type>`, and we would like not to complain in the
following situation:
$ git config --int --type=int
Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 22:46:54 +00:00
|
|
|
if (type == 0 || type == TYPE_PATH || type == TYPE_EXPIRY_DATE)
|
2009-12-30 16:51:53 +00:00
|
|
|
/*
|
|
|
|
* We don't do normalization for TYPE_PATH here: If
|
|
|
|
* the path is like ~/foobar/, we prefer to store
|
|
|
|
* "~/foobar/" in the config file, and to expand the ~
|
|
|
|
* when retrieving the value.
|
2017-11-18 02:27:27 +00:00
|
|
|
* Also don't do normalization for expiry dates.
|
2009-12-30 16:51:53 +00:00
|
|
|
*/
|
2015-09-24 21:07:05 +00:00
|
|
|
return xstrdup(value);
|
builtin/config.c: treat type specifiers singularly
Internally, we represent `git config`'s type specifiers as a bitset
using OPT_BIT. 'bool' is 1<<0, 'int' is 1<<1, and so on. This technique
allows for the representation of multiple type specifiers in the `int
types` field, but this multi-representation is left unused.
In fact, `git config` will not accept multiple type specifiers at a
time, as indicated by:
$ git config --int --bool some.section
error: only one type at a time.
This patch uses `OPT_SET_INT` to prefer the _last_ mentioned type
specifier, so that the above command would instead be valid, and a
synonym of:
$ git config --bool some.section
This change is motivated by two urges: (1) it does not make sense to
represent a singular type specifier internally as a bitset, only to
complain when there are multiple bits in the set. `OPT_SET_INT` is more
well-suited to this task than `OPT_BIT` is. (2) a future patch will
introduce `--type=<type>`, and we would like not to complain in the
following situation:
$ git config --int --type=int
Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 22:46:54 +00:00
|
|
|
if (type == TYPE_INT)
|
2015-09-24 21:07:05 +00:00
|
|
|
return xstrfmt("%"PRId64, git_config_int64(key, value));
|
builtin/config.c: treat type specifiers singularly
Internally, we represent `git config`'s type specifiers as a bitset
using OPT_BIT. 'bool' is 1<<0, 'int' is 1<<1, and so on. This technique
allows for the representation of multiple type specifiers in the `int
types` field, but this multi-representation is left unused.
In fact, `git config` will not accept multiple type specifiers at a
time, as indicated by:
$ git config --int --bool some.section
error: only one type at a time.
This patch uses `OPT_SET_INT` to prefer the _last_ mentioned type
specifier, so that the above command would instead be valid, and a
synonym of:
$ git config --bool some.section
This change is motivated by two urges: (1) it does not make sense to
represent a singular type specifier internally as a bitset, only to
complain when there are multiple bits in the set. `OPT_SET_INT` is more
well-suited to this task than `OPT_BIT` is. (2) a future patch will
introduce `--type=<type>`, and we would like not to complain in the
following situation:
$ git config --int --type=int
Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 22:46:54 +00:00
|
|
|
if (type == TYPE_BOOL)
|
2015-09-24 21:07:05 +00:00
|
|
|
return xstrdup(git_config_bool(key, value) ? "true" : "false");
|
builtin/config.c: treat type specifiers singularly
Internally, we represent `git config`'s type specifiers as a bitset
using OPT_BIT. 'bool' is 1<<0, 'int' is 1<<1, and so on. This technique
allows for the representation of multiple type specifiers in the `int
types` field, but this multi-representation is left unused.
In fact, `git config` will not accept multiple type specifiers at a
time, as indicated by:
$ git config --int --bool some.section
error: only one type at a time.
This patch uses `OPT_SET_INT` to prefer the _last_ mentioned type
specifier, so that the above command would instead be valid, and a
synonym of:
$ git config --bool some.section
This change is motivated by two urges: (1) it does not make sense to
represent a singular type specifier internally as a bitset, only to
complain when there are multiple bits in the set. `OPT_SET_INT` is more
well-suited to this task than `OPT_BIT` is. (2) a future patch will
introduce `--type=<type>`, and we would like not to complain in the
following situation:
$ git config --int --type=int
Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 22:46:54 +00:00
|
|
|
if (type == TYPE_BOOL_OR_INT) {
|
2015-09-24 21:07:05 +00:00
|
|
|
int is_bool, v;
|
|
|
|
v = git_config_bool_or_int(key, value, &is_bool);
|
|
|
|
if (!is_bool)
|
|
|
|
return xstrfmt("%d", v);
|
|
|
|
else
|
|
|
|
return xstrdup(v ? "true" : "false");
|
2007-06-25 14:00:24 +00:00
|
|
|
}
|
2018-04-10 00:18:31 +00:00
|
|
|
if (type == TYPE_COLOR) {
|
|
|
|
char v[COLOR_MAXLEN];
|
|
|
|
if (git_config_color(v, key, value))
|
2018-07-21 07:49:22 +00:00
|
|
|
die(_("cannot parse color '%s'"), value);
|
2018-04-10 00:18:31 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The contents of `v` now contain an ANSI escape
|
|
|
|
* sequence, not suitable for including within a
|
|
|
|
* configuration file. Treat the above as a
|
|
|
|
* "sanity-check", and return the given value, which we
|
|
|
|
* know is representable as valid color code.
|
|
|
|
*/
|
|
|
|
return xstrdup(value);
|
|
|
|
}
|
2007-06-25 14:00:24 +00:00
|
|
|
|
2018-05-30 05:04:07 +00:00
|
|
|
BUG("cannot normalize type %d", type);
|
2007-06-25 14:00:24 +00:00
|
|
|
}
|
|
|
|
|
2007-11-28 06:41:05 +00:00
|
|
|
static int get_color_found;
|
|
|
|
static const char *get_color_slot;
|
2009-02-21 00:48:56 +00:00
|
|
|
static const char *get_colorbool_slot;
|
2007-11-28 06:41:05 +00:00
|
|
|
static char parsed_color[COLOR_MAXLEN];
|
|
|
|
|
2008-05-14 17:46:53 +00:00
|
|
|
static int git_get_color_config(const char *var, const char *value, void *cb)
|
2007-11-28 06:41:05 +00:00
|
|
|
{
|
|
|
|
if (!strcmp(var, get_color_slot)) {
|
2008-02-11 18:48:12 +00:00
|
|
|
if (!value)
|
|
|
|
config_error_nonbool(var);
|
2014-10-07 19:33:09 +00:00
|
|
|
if (color_parse(value, parsed_color) < 0)
|
|
|
|
return -1;
|
2007-11-28 06:41:05 +00:00
|
|
|
get_color_found = 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
config: fix parsing of "git config --get-color some.key -1"
Most of git-config's command line options use OPT_BIT to
choose an action, and then parse the non-option arguments
in a context-dependent way. However, --get-color and
--get-colorbool are unlike the rest of the options, in that
they are OPT_STRING, taking the option name as a parameter.
This generally works, because we then use the presence of
those strings to set an action bit anyway. But it does mean
that the option-parser will continue looking for options
even after the key (because it is not a non-option; it is an
argument to an option). And running:
git config --get-color some.key -1
(to use "-1" as the default color spec) will barf, claiming
that "-1" is not an option. Instead, we should treat
--get-color and --get-colorbool as action bits, just like
--add, --get, and all the other actions, and then check that
the non-option arguments we got are sane. This fixes the
weirdness above, and makes those two options like all the
others.
This "fixes" a test in t4026, which checked that feeding
"-2" as a color should fail (it does fail, but prior to this
patch, because parseopt barfed, not because we actually ever
tried to parse the color).
This also catches other errors, like:
git config --get-color some.key black blue
which previously silently ignored "blue" (and now will
complain that you gave too many arguments).
There are some possible regressions, though. We now disallow
these, which currently do what you would expect:
# specifying other options after the action
git config --get-color some.key --file whatever
# using long-arg syntax
git config --get-color=some.key
However, we have never advertised these in the
documentation, and in fact they did not work in some older
versions of git. The behavior was apparently switched as an
accidental side effect of d64ec16 (git config: reorganize to
use parseopt, 2009-02-21).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-20 15:15:51 +00:00
|
|
|
static void get_color(const char *var, const char *def_color)
|
2007-11-28 06:41:05 +00:00
|
|
|
{
|
config: fix parsing of "git config --get-color some.key -1"
Most of git-config's command line options use OPT_BIT to
choose an action, and then parse the non-option arguments
in a context-dependent way. However, --get-color and
--get-colorbool are unlike the rest of the options, in that
they are OPT_STRING, taking the option name as a parameter.
This generally works, because we then use the presence of
those strings to set an action bit anyway. But it does mean
that the option-parser will continue looking for options
even after the key (because it is not a non-option; it is an
argument to an option). And running:
git config --get-color some.key -1
(to use "-1" as the default color spec) will barf, claiming
that "-1" is not an option. Instead, we should treat
--get-color and --get-colorbool as action bits, just like
--add, --get, and all the other actions, and then check that
the non-option arguments we got are sane. This fixes the
weirdness above, and makes those two options like all the
others.
This "fixes" a test in t4026, which checked that feeding
"-2" as a color should fail (it does fail, but prior to this
patch, because parseopt barfed, not because we actually ever
tried to parse the color).
This also catches other errors, like:
git config --get-color some.key black blue
which previously silently ignored "blue" (and now will
complain that you gave too many arguments).
There are some possible regressions, though. We now disallow
these, which currently do what you would expect:
# specifying other options after the action
git config --get-color some.key --file whatever
# using long-arg syntax
git config --get-color=some.key
However, we have never advertised these in the
documentation, and in fact they did not work in some older
versions of git. The behavior was apparently switched as an
accidental side effect of d64ec16 (git config: reorganize to
use parseopt, 2009-02-21).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-20 15:15:51 +00:00
|
|
|
get_color_slot = var;
|
2007-11-28 06:41:05 +00:00
|
|
|
get_color_found = 0;
|
|
|
|
parsed_color[0] = '\0';
|
2017-06-14 18:07:39 +00:00
|
|
|
config_with_options(git_get_color_config, NULL,
|
|
|
|
&given_config_source, &config_options);
|
2007-11-28 06:41:05 +00:00
|
|
|
|
2014-10-07 19:33:09 +00:00
|
|
|
if (!get_color_found && def_color) {
|
|
|
|
if (color_parse(def_color, parsed_color) < 0)
|
|
|
|
die(_("unable to parse default color value"));
|
|
|
|
}
|
2007-11-28 06:41:05 +00:00
|
|
|
|
|
|
|
fputs(parsed_color, stdout);
|
|
|
|
}
|
|
|
|
|
2007-12-06 01:26:11 +00:00
|
|
|
static int get_colorbool_found;
|
2007-12-06 06:12:07 +00:00
|
|
|
static int get_diff_color_found;
|
config: refactor get_colorbool function
For "git config --get-colorbool color.foo", we use a custom
callback that looks not only for the key that the user gave
us, but also for "diff.color" (for backwards compatibility)
and "color.ui" (as a fallback).
For the former, we use a custom variable to store the
diff.color value. For the latter, though, we store it in the
main "git_use_color_default" variable, turning on color.ui
for any other parts of git that respect this value.
In practice, this doesn't cause any bugs, because git-config
runs without caring about git_use_color_default, and then
exits. But it crosses module boundaries in an unusual and
confusing way, and it makes refactoring color handling
harder than it needs to be.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-08-18 05:04:56 +00:00
|
|
|
static int get_color_ui_found;
|
2008-05-14 17:46:53 +00:00
|
|
|
static int git_get_colorbool_config(const char *var, const char *value,
|
|
|
|
void *cb)
|
2007-12-06 01:26:11 +00:00
|
|
|
{
|
2011-08-18 05:03:48 +00:00
|
|
|
if (!strcmp(var, get_colorbool_slot))
|
|
|
|
get_colorbool_found = git_config_colorbool(var, value);
|
|
|
|
else if (!strcmp(var, "diff.color"))
|
|
|
|
get_diff_color_found = git_config_colorbool(var, value);
|
|
|
|
else if (!strcmp(var, "color.ui"))
|
config: refactor get_colorbool function
For "git config --get-colorbool color.foo", we use a custom
callback that looks not only for the key that the user gave
us, but also for "diff.color" (for backwards compatibility)
and "color.ui" (as a fallback).
For the former, we use a custom variable to store the
diff.color value. For the latter, though, we store it in the
main "git_use_color_default" variable, turning on color.ui
for any other parts of git that respect this value.
In practice, this doesn't cause any bugs, because git-config
runs without caring about git_use_color_default, and then
exits. But it crosses module boundaries in an unusual and
confusing way, and it makes refactoring color handling
harder than it needs to be.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-08-18 05:04:56 +00:00
|
|
|
get_color_ui_found = git_config_colorbool(var, value);
|
2007-12-06 01:26:11 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
config: fix parsing of "git config --get-color some.key -1"
Most of git-config's command line options use OPT_BIT to
choose an action, and then parse the non-option arguments
in a context-dependent way. However, --get-color and
--get-colorbool are unlike the rest of the options, in that
they are OPT_STRING, taking the option name as a parameter.
This generally works, because we then use the presence of
those strings to set an action bit anyway. But it does mean
that the option-parser will continue looking for options
even after the key (because it is not a non-option; it is an
argument to an option). And running:
git config --get-color some.key -1
(to use "-1" as the default color spec) will barf, claiming
that "-1" is not an option. Instead, we should treat
--get-color and --get-colorbool as action bits, just like
--add, --get, and all the other actions, and then check that
the non-option arguments we got are sane. This fixes the
weirdness above, and makes those two options like all the
others.
This "fixes" a test in t4026, which checked that feeding
"-2" as a color should fail (it does fail, but prior to this
patch, because parseopt barfed, not because we actually ever
tried to parse the color).
This also catches other errors, like:
git config --get-color some.key black blue
which previously silently ignored "blue" (and now will
complain that you gave too many arguments).
There are some possible regressions, though. We now disallow
these, which currently do what you would expect:
# specifying other options after the action
git config --get-color some.key --file whatever
# using long-arg syntax
git config --get-color=some.key
However, we have never advertised these in the
documentation, and in fact they did not work in some older
versions of git. The behavior was apparently switched as an
accidental side effect of d64ec16 (git config: reorganize to
use parseopt, 2009-02-21).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-20 15:15:51 +00:00
|
|
|
static int get_colorbool(const char *var, int print)
|
2007-12-06 01:26:11 +00:00
|
|
|
{
|
config: fix parsing of "git config --get-color some.key -1"
Most of git-config's command line options use OPT_BIT to
choose an action, and then parse the non-option arguments
in a context-dependent way. However, --get-color and
--get-colorbool are unlike the rest of the options, in that
they are OPT_STRING, taking the option name as a parameter.
This generally works, because we then use the presence of
those strings to set an action bit anyway. But it does mean
that the option-parser will continue looking for options
even after the key (because it is not a non-option; it is an
argument to an option). And running:
git config --get-color some.key -1
(to use "-1" as the default color spec) will barf, claiming
that "-1" is not an option. Instead, we should treat
--get-color and --get-colorbool as action bits, just like
--add, --get, and all the other actions, and then check that
the non-option arguments we got are sane. This fixes the
weirdness above, and makes those two options like all the
others.
This "fixes" a test in t4026, which checked that feeding
"-2" as a color should fail (it does fail, but prior to this
patch, because parseopt barfed, not because we actually ever
tried to parse the color).
This also catches other errors, like:
git config --get-color some.key black blue
which previously silently ignored "blue" (and now will
complain that you gave too many arguments).
There are some possible regressions, though. We now disallow
these, which currently do what you would expect:
# specifying other options after the action
git config --get-color some.key --file whatever
# using long-arg syntax
git config --get-color=some.key
However, we have never advertised these in the
documentation, and in fact they did not work in some older
versions of git. The behavior was apparently switched as an
accidental side effect of d64ec16 (git config: reorganize to
use parseopt, 2009-02-21).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-20 15:15:51 +00:00
|
|
|
get_colorbool_slot = var;
|
2007-12-06 06:12:07 +00:00
|
|
|
get_colorbool_found = -1;
|
|
|
|
get_diff_color_found = -1;
|
2013-05-15 17:00:55 +00:00
|
|
|
get_color_ui_found = -1;
|
2017-06-14 18:07:39 +00:00
|
|
|
config_with_options(git_get_colorbool_config, NULL,
|
|
|
|
&given_config_source, &config_options);
|
2007-12-06 01:26:11 +00:00
|
|
|
|
2007-12-06 06:12:07 +00:00
|
|
|
if (get_colorbool_found < 0) {
|
2009-02-21 00:48:56 +00:00
|
|
|
if (!strcmp(get_colorbool_slot, "color.diff"))
|
2007-12-06 06:12:07 +00:00
|
|
|
get_colorbool_found = get_diff_color_found;
|
|
|
|
if (get_colorbool_found < 0)
|
config: refactor get_colorbool function
For "git config --get-colorbool color.foo", we use a custom
callback that looks not only for the key that the user gave
us, but also for "diff.color" (for backwards compatibility)
and "color.ui" (as a fallback).
For the former, we use a custom variable to store the
diff.color value. For the latter, though, we store it in the
main "git_use_color_default" variable, turning on color.ui
for any other parts of git that respect this value.
In practice, this doesn't cause any bugs, because git-config
runs without caring about git_use_color_default, and then
exits. But it crosses module boundaries in an unusual and
confusing way, and it makes refactoring color handling
harder than it needs to be.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-08-18 05:04:56 +00:00
|
|
|
get_colorbool_found = get_color_ui_found;
|
2007-12-06 06:12:07 +00:00
|
|
|
}
|
|
|
|
|
2013-05-15 17:00:55 +00:00
|
|
|
if (get_colorbool_found < 0)
|
|
|
|
/* default value if none found in config */
|
make color.ui default to 'auto'
Most users seem to like having colors enabled, and colors can help
beginners to understand the output of some commands (e.g. notice
immediately the boundary between commits in the output of "git log").
Many tutorials tell the users to set color.ui=auto as a very first step,
which tend to indicate that color.ui=none is not the recommanded value,
hence should not be the default.
These tutorials would benefit from skipping this step and starting the
real Git manipulations earlier. Other beginners do not know about
color.ui=auto, and may not discover it by themselves, hence live with
black&white outputs while they may have preferred colors.
A few people (e.g. color-blind) prefer having no colors, but they can
easily set color.ui=never for this (and googling "disable colors in git"
already tells them how to do so), but this needs not occupy space in
beginner-oriented documentations.
A transition period with Git emitting a warning when color.ui is unset
would be possible, but the discomfort of having the warning seems
superior to the benefit: users may be surprised by the change, but not
harmed by it.
The default value is changed, and the documentation is reworded to
mention "color.ui=false" first, since the primary use of color.ui after
this change is to disable colors, not to enable it.
Signed-off-by: Matthieu Moy <Matthieu.Moy@imag.fr>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-06-10 14:26:09 +00:00
|
|
|
get_colorbool_found = GIT_COLOR_AUTO;
|
2013-05-15 17:00:55 +00:00
|
|
|
|
color: delay auto-color decision until point of use
When we read a color value either from a config file or from
the command line, we use git_config_colorbool to convert it
from the tristate always/never/auto into a single yes/no
boolean value.
This has some timing implications with respect to starting
a pager.
If we start (or decide not to start) the pager before
checking the colorbool, everything is fine. Either isatty(1)
will give us the right information, or we will properly
check for pager_in_use().
However, if we decide to start a pager after we have checked
the colorbool, things are not so simple. If stdout is a tty,
then we will have already decided to use color. However, the
user may also have configured color.pager not to use color
with the pager. In this case, we need to actually turn off
color. Unfortunately, the pager code has no idea which color
variables were turned on (and there are many of them
throughout the code, and they may even have been manipulated
after the colorbool selection by something like "--color" on
the command line).
This bug can be seen any time a pager is started after
config and command line options are checked. This has
affected "git diff" since 89d07f7 (diff: don't run pager if
user asked for a diff style exit code, 2007-08-12). It has
also affect the log family since 1fda91b (Fix 'git log'
early pager startup error case, 2010-08-24).
This patch splits the notion of parsing a colorbool and
actually checking the configuration. The "use_color"
variables now have an additional possible value,
GIT_COLOR_AUTO. Users of the variable should use the new
"want_color()" wrapper, which will lazily determine and
cache the auto-color decision.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-08-18 05:04:23 +00:00
|
|
|
get_colorbool_found = want_color(get_colorbool_found);
|
|
|
|
|
2009-02-21 00:48:57 +00:00
|
|
|
if (print) {
|
2007-12-06 01:26:11 +00:00
|
|
|
printf("%s\n", get_colorbool_found ? "true" : "false");
|
|
|
|
return 0;
|
2009-02-21 00:48:57 +00:00
|
|
|
} else
|
|
|
|
return get_colorbool_found ? 0 : 1;
|
2007-12-06 01:26:11 +00:00
|
|
|
}
|
|
|
|
|
2014-02-18 22:58:53 +00:00
|
|
|
static void check_write(void)
|
2013-07-11 22:46:47 +00:00
|
|
|
{
|
2016-02-24 12:48:11 +00:00
|
|
|
if (!given_config_source.file && !startup_info->have_repository)
|
2018-07-21 07:49:22 +00:00
|
|
|
die(_("not in a git directory"));
|
2016-02-24 12:48:11 +00:00
|
|
|
|
2014-02-18 22:58:55 +00:00
|
|
|
if (given_config_source.use_stdin)
|
2018-07-21 07:49:22 +00:00
|
|
|
die(_("writing to stdin is not supported"));
|
2014-02-18 22:58:55 +00:00
|
|
|
|
2014-02-18 22:58:54 +00:00
|
|
|
if (given_config_source.blob)
|
2018-07-21 07:49:22 +00:00
|
|
|
die(_("writing config blobs is not supported"));
|
2013-07-11 22:46:47 +00:00
|
|
|
}
|
|
|
|
|
2013-07-31 18:14:59 +00:00
|
|
|
struct urlmatch_current_candidate_value {
|
|
|
|
char value_is_null;
|
|
|
|
struct strbuf value;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int urlmatch_collect_fn(const char *var, const char *value, void *cb)
|
|
|
|
{
|
|
|
|
struct string_list *values = cb;
|
|
|
|
struct string_list_item *item = string_list_insert(values, var);
|
|
|
|
struct urlmatch_current_candidate_value *matched = item->util;
|
|
|
|
|
|
|
|
if (!matched) {
|
|
|
|
matched = xmalloc(sizeof(*matched));
|
|
|
|
strbuf_init(&matched->value, 0);
|
|
|
|
item->util = matched;
|
|
|
|
} else {
|
|
|
|
strbuf_reset(&matched->value);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (value) {
|
|
|
|
strbuf_addstr(&matched->value, value);
|
|
|
|
matched->value_is_null = 0;
|
|
|
|
} else {
|
|
|
|
matched->value_is_null = 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int get_urlmatch(const char *var, const char *url)
|
|
|
|
{
|
2016-02-28 11:54:35 +00:00
|
|
|
int ret;
|
2013-07-31 18:14:59 +00:00
|
|
|
char *section_tail;
|
|
|
|
struct string_list_item *item;
|
|
|
|
struct urlmatch_config config = { STRING_LIST_INIT_DUP };
|
|
|
|
struct string_list values = STRING_LIST_INIT_DUP;
|
|
|
|
|
|
|
|
config.collect_fn = urlmatch_collect_fn;
|
|
|
|
config.cascade_fn = NULL;
|
|
|
|
config.cb = &values;
|
|
|
|
|
|
|
|
if (!url_normalize(url, &config.url))
|
2013-08-09 04:41:44 +00:00
|
|
|
die("%s", config.url.err);
|
2013-07-31 18:14:59 +00:00
|
|
|
|
2014-05-22 09:44:09 +00:00
|
|
|
config.section = xstrdup_tolower(var);
|
2013-07-31 18:14:59 +00:00
|
|
|
section_tail = strchr(config.section, '.');
|
|
|
|
if (section_tail) {
|
|
|
|
*section_tail = '\0';
|
|
|
|
config.key = section_tail + 1;
|
|
|
|
show_keys = 0;
|
|
|
|
} else {
|
|
|
|
config.key = NULL;
|
|
|
|
show_keys = 1;
|
|
|
|
}
|
|
|
|
|
2017-06-14 18:07:39 +00:00
|
|
|
config_with_options(urlmatch_config_entry, &config,
|
|
|
|
&given_config_source, &config_options);
|
2013-07-31 18:14:59 +00:00
|
|
|
|
2016-02-28 11:54:35 +00:00
|
|
|
ret = !values.nr;
|
|
|
|
|
2013-07-31 18:14:59 +00:00
|
|
|
for_each_string_list_item(item, &values) {
|
|
|
|
struct urlmatch_current_candidate_value *matched = item->util;
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
|
2015-08-20 14:49:45 +00:00
|
|
|
format_config(&buf, item->string,
|
2013-07-31 18:14:59 +00:00
|
|
|
matched->value_is_null ? NULL : matched->value.buf);
|
|
|
|
fwrite(buf.buf, 1, buf.len, stdout);
|
|
|
|
strbuf_release(&buf);
|
|
|
|
|
|
|
|
strbuf_release(&matched->value);
|
|
|
|
}
|
|
|
|
string_list_clear(&config.vars, 1);
|
|
|
|
string_list_clear(&values, 1);
|
|
|
|
free(config.url.url);
|
|
|
|
|
|
|
|
free((void *)config.section);
|
2016-02-28 11:54:35 +00:00
|
|
|
return ret;
|
2013-07-31 18:14:59 +00:00
|
|
|
}
|
|
|
|
|
2014-07-25 19:11:34 +00:00
|
|
|
static char *default_user_config(void)
|
|
|
|
{
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
strbuf_addf(&buf,
|
|
|
|
_("# This is Git's per-user configuration file.\n"
|
2015-04-17 14:50:10 +00:00
|
|
|
"[user]\n"
|
2014-07-25 19:11:34 +00:00
|
|
|
"# Please adapt and uncomment the following lines:\n"
|
2015-04-17 14:50:10 +00:00
|
|
|
"# name = %s\n"
|
2014-07-25 19:11:34 +00:00
|
|
|
"# email = %s\n"),
|
|
|
|
ident_default_name(),
|
|
|
|
ident_default_email());
|
|
|
|
return strbuf_detach(&buf, NULL);
|
|
|
|
}
|
|
|
|
|
2010-08-06 03:15:09 +00:00
|
|
|
int cmd_config(int argc, const char **argv, const char *prefix)
|
2005-11-17 21:44:55 +00:00
|
|
|
{
|
2010-08-06 03:15:09 +00:00
|
|
|
int nongit = !startup_info->have_repository;
|
2009-02-21 00:48:53 +00:00
|
|
|
char *value;
|
2006-02-12 03:14:48 +00:00
|
|
|
|
2019-01-11 22:15:54 +00:00
|
|
|
given_config_source.file = xstrdup_or_null(getenv(CONFIG_ENVIRONMENT));
|
2008-06-30 07:37:47 +00:00
|
|
|
|
2009-05-23 18:53:12 +00:00
|
|
|
argc = parse_options(argc, argv, prefix, builtin_config_options,
|
|
|
|
builtin_config_usage,
|
2009-02-21 00:49:25 +00:00
|
|
|
PARSE_OPT_STOP_AT_NON_OPTION);
|
|
|
|
|
2013-07-11 22:46:47 +00:00
|
|
|
if (use_global_config + use_system_config + use_local_config +
|
2018-10-21 14:02:28 +00:00
|
|
|
use_worktree_config +
|
2014-02-18 22:58:54 +00:00
|
|
|
!!given_config_source.file + !!given_config_source.blob > 1) {
|
2018-07-21 07:49:22 +00:00
|
|
|
error(_("only one config file at a time"));
|
2018-07-05 18:34:45 +00:00
|
|
|
usage_builtin_config();
|
2009-02-21 00:49:26 +00:00
|
|
|
}
|
|
|
|
|
2017-05-13 03:29:31 +00:00
|
|
|
if (use_local_config && nongit)
|
|
|
|
die(_("--local can only be used inside a git repository"));
|
|
|
|
|
2018-05-18 22:27:04 +00:00
|
|
|
if (given_config_source.blob && nongit)
|
|
|
|
die(_("--blob can only be used inside a git repository"));
|
|
|
|
|
2014-02-18 22:58:55 +00:00
|
|
|
if (given_config_source.file &&
|
|
|
|
!strcmp(given_config_source.file, "-")) {
|
|
|
|
given_config_source.file = NULL;
|
|
|
|
given_config_source.use_stdin = 1;
|
2020-02-10 00:30:57 +00:00
|
|
|
given_config_source.scope = CONFIG_SCOPE_COMMAND;
|
2014-02-18 22:58:55 +00:00
|
|
|
}
|
|
|
|
|
2009-02-21 00:49:25 +00:00
|
|
|
if (use_global_config) {
|
2017-04-05 10:24:38 +00:00
|
|
|
char *user_config = expand_user_path("~/.gitconfig", 0);
|
2015-05-06 08:01:03 +00:00
|
|
|
char *xdg_config = xdg_config_home("config");
|
2012-06-22 09:03:23 +00:00
|
|
|
|
2012-07-12 12:04:20 +00:00
|
|
|
if (!user_config)
|
|
|
|
/*
|
|
|
|
* It is unknown if HOME/.gitconfig exists, so
|
|
|
|
* we do not know if we should write to XDG
|
|
|
|
* location; error out even if XDG_CONFIG_HOME
|
|
|
|
* is set and points at a sane location.
|
|
|
|
*/
|
2018-07-21 07:49:22 +00:00
|
|
|
die(_("$HOME not set"));
|
2012-07-12 12:04:20 +00:00
|
|
|
|
2020-02-10 00:30:57 +00:00
|
|
|
given_config_source.scope = CONFIG_SCOPE_GLOBAL;
|
|
|
|
|
config: allow inaccessible configuration under $HOME
The changes v1.7.12.1~2^2~4 (config: warn on inaccessible files,
2012-08-21) and v1.8.1.1~22^2~2 (config: treat user and xdg config
permission problems as errors, 2012-10-13) were intended to prevent
important configuration (think "[transfer] fsckobjects") from being
ignored when the configuration is unintentionally unreadable (for
example with EIO on a flaky filesystem, or with ENOMEM due to a DoS
attack). Usually ~/.gitconfig and ~/.config/git are readable by the
current user, and if they aren't then it would be easy to fix those
permissions, so the damage from adding this check should have been
minimal.
Unfortunately the access() check often trips when git is being run as
a server. A daemon (such as inetd or git-daemon) starts as "root",
creates a listening socket, and then drops privileges, meaning that
when git commands are invoked they cannot access $HOME and die with
fatal: unable to access '/root/.config/git/config': Permission denied
Any patch to fix this would have one of three problems:
1. We annoy sysadmins who need to take an extra step to handle HOME
when dropping privileges (the current behavior, or any other
proposal that they have to opt into).
2. We annoy sysadmins who want to set HOME when dropping privileges,
either by making what they want to do impossible, or making them
set an extra variable or option to accomplish what used to work
(e.g., a patch to git-daemon to set HOME when --user is passed).
3. We loosen the check, so some cases which might be noteworthy are
not caught.
This patch is of type (3).
Treat user and xdg configuration that are inaccessible due to
permissions (EACCES) as though no user configuration was provided at
all.
An alternative method would be to check if $HOME is readable, but that
would not help in cases where the user who dropped privileges had a
globally readable HOME with only .config or .gitconfig being private.
This does not change the behavior when /etc/gitconfig or .git/config
is unreadable (since those are more serious configuration errors),
nor when ~/.gitconfig or ~/.config/git is unreadable due to problems
other than permissions.
Signed-off-by: Jonathan Nieder <jrnieder@gmail.com>
Improved-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-12 21:03:18 +00:00
|
|
|
if (access_or_warn(user_config, R_OK, 0) &&
|
2017-09-05 13:04:20 +00:00
|
|
|
xdg_config && !access_or_warn(xdg_config, R_OK, 0)) {
|
2014-02-18 22:58:54 +00:00
|
|
|
given_config_source.file = xdg_config;
|
2017-09-05 13:04:20 +00:00
|
|
|
free(user_config);
|
|
|
|
} else {
|
2014-02-18 22:58:54 +00:00
|
|
|
given_config_source.file = user_config;
|
2017-09-05 13:04:20 +00:00
|
|
|
free(xdg_config);
|
|
|
|
}
|
2009-02-21 00:49:25 +00:00
|
|
|
}
|
2020-02-10 00:30:57 +00:00
|
|
|
else if (use_system_config) {
|
2014-02-18 22:58:54 +00:00
|
|
|
given_config_source.file = git_etc_gitconfig();
|
2020-02-10 00:30:57 +00:00
|
|
|
given_config_source.scope = CONFIG_SCOPE_SYSTEM;
|
|
|
|
} else if (use_local_config) {
|
2014-02-18 22:58:54 +00:00
|
|
|
given_config_source.file = git_pathdup("config");
|
2020-02-10 00:30:57 +00:00
|
|
|
given_config_source.scope = CONFIG_SCOPE_LOCAL;
|
|
|
|
} else if (use_worktree_config) {
|
2020-06-19 23:35:44 +00:00
|
|
|
struct worktree **worktrees = get_worktrees();
|
2018-10-21 14:02:28 +00:00
|
|
|
if (repository_format_worktree_config)
|
|
|
|
given_config_source.file = git_pathdup("config.worktree");
|
|
|
|
else if (worktrees[0] && worktrees[1])
|
|
|
|
die(_("--worktree cannot be used with multiple "
|
|
|
|
"working trees unless the config\n"
|
|
|
|
"extension worktreeConfig is enabled. "
|
|
|
|
"Please read \"CONFIGURATION FILE\"\n"
|
|
|
|
"section in \"git help worktree\" for details"));
|
|
|
|
else
|
|
|
|
given_config_source.file = git_pathdup("config");
|
2020-02-10 00:30:57 +00:00
|
|
|
given_config_source.scope = CONFIG_SCOPE_LOCAL;
|
2018-10-21 14:02:28 +00:00
|
|
|
free_worktrees(worktrees);
|
|
|
|
} else if (given_config_source.file) {
|
2014-02-18 22:58:54 +00:00
|
|
|
if (!is_absolute_path(given_config_source.file) && prefix)
|
|
|
|
given_config_source.file =
|
2017-03-21 01:28:49 +00:00
|
|
|
prefix_filename(prefix, given_config_source.file);
|
2020-02-10 00:30:57 +00:00
|
|
|
given_config_source.scope = CONFIG_SCOPE_COMMAND;
|
|
|
|
} else if (given_config_source.blob) {
|
|
|
|
given_config_source.scope = CONFIG_SCOPE_COMMAND;
|
2009-02-21 00:49:25 +00:00
|
|
|
}
|
|
|
|
|
2020-02-10 00:30:57 +00:00
|
|
|
|
2017-04-17 10:10:00 +00:00
|
|
|
if (respect_includes_opt == -1)
|
|
|
|
config_options.respect_includes = !given_config_source.file;
|
|
|
|
else
|
|
|
|
config_options.respect_includes = respect_includes_opt;
|
2017-06-14 18:07:39 +00:00
|
|
|
if (!nongit) {
|
|
|
|
config_options.commondir = get_git_common_dir();
|
|
|
|
config_options.git_dir = get_git_dir();
|
|
|
|
}
|
config: add include directive
It can be useful to split your ~/.gitconfig across multiple
files. For example, you might have a "main" file which is
used on many machines, but a small set of per-machine
tweaks. Or you may want to make some of your config public
(e.g., clever aliases) while keeping other data back (e.g.,
your name or other identifying information). Or you may want
to include a number of config options in some subset of your
repos without copying and pasting (e.g., you want to
reference them from the .git/config of participating repos).
This patch introduces an include directive for config files.
It looks like:
[include]
path = /path/to/file
This is syntactically backwards-compatible with existing git
config parsers (i.e., they will see it as another config
entry and ignore it unless you are looking up include.path).
The implementation provides a "git_config_include" callback
which wraps regular config callbacks. Callers can pass it to
git_config_from_file, and it will transparently follow any
include directives, passing all of the discovered options to
the real callback.
Include directives are turned on automatically for "regular"
git config parsing. This includes calls to git_config, as
well as calls to the "git config" program that do not
specify a single file (e.g., using "-f", "--global", etc).
They are not turned on in other cases, including:
1. Parsing of other config-like files, like .gitmodules.
There isn't a real need, and I'd rather be conservative
and avoid unnecessary incompatibility or confusion.
2. Reading single files via "git config". This is for two
reasons:
a. backwards compatibility with scripts looking at
config-like files.
b. inspection of a specific file probably means you
care about just what's in that file, not a general
lookup for "do we have this value anywhere at
all". If that is not the case, the caller can
always specify "--includes".
3. Writing files via "git config"; we want to treat
include.* variables as literal items to be copied (or
modified), and not expand them. So "git config
--unset-all foo.bar" would operate _only_ on
.git/config, not any of its included files (just as it
also does not operate on ~/.gitconfig).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-02-06 09:54:04 +00:00
|
|
|
|
2020-01-24 00:21:01 +00:00
|
|
|
if (end_nul) {
|
2009-02-21 00:49:25 +00:00
|
|
|
term = '\0';
|
|
|
|
delim = '\n';
|
|
|
|
key_delim = '\n';
|
|
|
|
}
|
|
|
|
|
builtin/config.c: treat type specifiers singularly
Internally, we represent `git config`'s type specifiers as a bitset
using OPT_BIT. 'bool' is 1<<0, 'int' is 1<<1, and so on. This technique
allows for the representation of multiple type specifiers in the `int
types` field, but this multi-representation is left unused.
In fact, `git config` will not accept multiple type specifiers at a
time, as indicated by:
$ git config --int --bool some.section
error: only one type at a time.
This patch uses `OPT_SET_INT` to prefer the _last_ mentioned type
specifier, so that the above command would instead be valid, and a
synonym of:
$ git config --bool some.section
This change is motivated by two urges: (1) it does not make sense to
represent a singular type specifier internally as a bitset, only to
complain when there are multiple bits in the set. `OPT_SET_INT` is more
well-suited to this task than `OPT_BIT` is. (2) a future patch will
introduce `--type=<type>`, and we would like not to complain in the
following situation:
$ git config --int --type=int
Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 22:46:54 +00:00
|
|
|
if ((actions & (ACTION_GET_COLOR|ACTION_GET_COLORBOOL)) && type) {
|
2018-07-21 07:49:22 +00:00
|
|
|
error(_("--get-color and variable type are incoherent"));
|
2018-07-05 18:34:45 +00:00
|
|
|
usage_builtin_config();
|
2009-02-21 00:49:29 +00:00
|
|
|
}
|
|
|
|
|
2009-02-21 00:49:25 +00:00
|
|
|
if (HAS_MULTI_BITS(actions)) {
|
2018-07-21 07:49:22 +00:00
|
|
|
error(_("only one action at a time"));
|
2018-07-05 18:34:45 +00:00
|
|
|
usage_builtin_config();
|
2009-02-21 00:49:25 +00:00
|
|
|
}
|
|
|
|
if (actions == 0)
|
|
|
|
switch (argc) {
|
|
|
|
case 1: actions = ACTION_GET; break;
|
|
|
|
case 2: actions = ACTION_SET; break;
|
|
|
|
case 3: actions = ACTION_SET_ALL; break;
|
|
|
|
default:
|
2018-07-05 18:34:45 +00:00
|
|
|
usage_builtin_config();
|
2007-06-25 14:00:24 +00:00
|
|
|
}
|
2015-08-10 09:46:06 +00:00
|
|
|
if (omit_values &&
|
|
|
|
!(actions == ACTION_LIST || actions == ACTION_GET_REGEXP)) {
|
2018-07-21 07:49:22 +00:00
|
|
|
error(_("--name-only is only applicable to --list or --get-regexp"));
|
2018-07-05 18:34:45 +00:00
|
|
|
usage_builtin_config();
|
2015-08-10 09:46:06 +00:00
|
|
|
}
|
2016-02-19 09:16:02 +00:00
|
|
|
|
|
|
|
if (show_origin && !(actions &
|
|
|
|
(ACTION_GET|ACTION_GET_ALL|ACTION_GET_REGEXP|ACTION_LIST))) {
|
2018-07-21 07:49:22 +00:00
|
|
|
error(_("--show-origin is only applicable to --get, --get-all, "
|
|
|
|
"--get-regexp, and --list"));
|
2018-07-05 18:34:45 +00:00
|
|
|
usage_builtin_config();
|
2016-02-19 09:16:02 +00:00
|
|
|
}
|
|
|
|
|
builtin/config: introduce `--default`
For some use cases, callers of the `git-config(1)` builtin would like to
fallback to default values when the variable asked for does not exist.
In addition, users would like to use existing type specifiers to ensure
that values are parsed correctly when they do exist in the
configuration.
For example, to fetch a value without a type specifier and fallback to
`$fallback`, the following is required:
$ git config core.foo || echo "$fallback"
This is fine for most values, but can be tricky for difficult-to-express
`$fallback`'s, like ANSI color codes.
This motivates `--get-color`, which is a one-off exception to the normal
type specifier rules wherein a user specifies both the configuration
variable and an optional fallback. Both are formatted according to their
type specifier, which eases the burden on the user to ensure that values
are correctly formatted.
This commit (and those following it in this series) aim to eventually
replace `--get-color` with a consistent alternative. By introducing
`--default`, we allow the `--get-color` action to be promoted to a
`--type=color` type specifier, retaining the "fallback" behavior via the
`--default` flag introduced in this commit.
For example, we aim to replace:
$ git config --get-color variable [default] [...]
with:
$ git config --default default --type=color variable [...]
Values filled by `--default` behave exactly as if they were present in
the affected configuration file; they will be parsed by type specifiers
without the knowledge that they are not themselves present in the
configuration.
Specifically, this means that the following will work:
$ git config --int --default 1M does.not.exist
1048576
In subsequent commits, we will offer `--type=color`, which (in
conjunction with `--default`) will be sufficient to replace
`--get-color`.
Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-10 00:18:26 +00:00
|
|
|
if (default_value && !(actions & ACTION_GET)) {
|
2018-07-21 07:49:22 +00:00
|
|
|
error(_("--default is only applicable to --get"));
|
2018-07-05 18:34:45 +00:00
|
|
|
usage_builtin_config();
|
builtin/config: introduce `--default`
For some use cases, callers of the `git-config(1)` builtin would like to
fallback to default values when the variable asked for does not exist.
In addition, users would like to use existing type specifiers to ensure
that values are parsed correctly when they do exist in the
configuration.
For example, to fetch a value without a type specifier and fallback to
`$fallback`, the following is required:
$ git config core.foo || echo "$fallback"
This is fine for most values, but can be tricky for difficult-to-express
`$fallback`'s, like ANSI color codes.
This motivates `--get-color`, which is a one-off exception to the normal
type specifier rules wherein a user specifies both the configuration
variable and an optional fallback. Both are formatted according to their
type specifier, which eases the burden on the user to ensure that values
are correctly formatted.
This commit (and those following it in this series) aim to eventually
replace `--get-color` with a consistent alternative. By introducing
`--default`, we allow the `--get-color` action to be promoted to a
`--type=color` type specifier, retaining the "fallback" behavior via the
`--default` flag introduced in this commit.
For example, we aim to replace:
$ git config --get-color variable [default] [...]
with:
$ git config --default default --type=color variable [...]
Values filled by `--default` behave exactly as if they were present in
the affected configuration file; they will be parsed by type specifiers
without the knowledge that they are not themselves present in the
configuration.
Specifically, this means that the following will work:
$ git config --int --default 1M does.not.exist
1048576
In subsequent commits, we will offer `--type=color`, which (in
conjunction with `--default`) will be sufficient to replace
`--get-color`.
Signed-off-by: Taylor Blau <me@ttaylorr.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-10 00:18:26 +00:00
|
|
|
}
|
|
|
|
|
2018-02-21 18:51:43 +00:00
|
|
|
if (actions & PAGING_ACTIONS)
|
2018-02-21 18:51:44 +00:00
|
|
|
setup_auto_pager("config", 1);
|
2018-02-21 18:51:43 +00:00
|
|
|
|
2009-02-21 00:49:25 +00:00
|
|
|
if (actions == ACTION_LIST) {
|
2009-02-21 00:49:28 +00:00
|
|
|
check_argc(argc, 0, 0);
|
2017-06-14 18:07:39 +00:00
|
|
|
if (config_with_options(show_all_config, NULL,
|
|
|
|
&given_config_source,
|
|
|
|
&config_options) < 0) {
|
2014-02-18 22:58:54 +00:00
|
|
|
if (given_config_source.file)
|
2018-07-21 07:49:22 +00:00
|
|
|
die_errno(_("unable to read config file '%s'"),
|
2014-02-18 22:58:54 +00:00
|
|
|
given_config_source.file);
|
2009-02-21 00:49:25 +00:00
|
|
|
else
|
2018-07-21 07:49:22 +00:00
|
|
|
die(_("error processing config file(s)"));
|
2007-06-25 14:00:24 +00:00
|
|
|
}
|
2005-11-17 21:44:55 +00:00
|
|
|
}
|
2009-02-21 00:49:25 +00:00
|
|
|
else if (actions == ACTION_EDIT) {
|
2014-11-16 07:37:44 +00:00
|
|
|
char *config_file;
|
|
|
|
|
2009-02-21 00:49:28 +00:00
|
|
|
check_argc(argc, 0, 0);
|
2014-02-18 22:58:54 +00:00
|
|
|
if (!given_config_source.file && nongit)
|
2018-07-21 07:49:22 +00:00
|
|
|
die(_("not in a git directory"));
|
2014-02-18 22:58:55 +00:00
|
|
|
if (given_config_source.use_stdin)
|
2018-07-21 07:49:22 +00:00
|
|
|
die(_("editing stdin is not supported"));
|
2014-02-18 22:58:54 +00:00
|
|
|
if (given_config_source.blob)
|
2018-07-21 07:49:22 +00:00
|
|
|
die(_("editing blobs is not supported"));
|
2009-02-21 00:49:25 +00:00
|
|
|
git_config(git_default_config, NULL);
|
2017-04-20 21:09:09 +00:00
|
|
|
config_file = given_config_source.file ?
|
|
|
|
xstrdup(given_config_source.file) :
|
|
|
|
git_pathdup("config");
|
2014-07-25 19:11:34 +00:00
|
|
|
if (use_global_config) {
|
|
|
|
int fd = open(config_file, O_CREAT | O_EXCL | O_WRONLY, 0666);
|
config: fix bogus fd check when setting up default config
Since 9830534 (config --global --edit: create a template
file if needed, 2014-07-25), an edit of the global config
file will try to open() it with O_EXCL, and wants to handle
three cases:
1. We succeeded; the user has no config file, and we
should fill in the default template.
2. We got EEXIST; they have a file already, proceed as usual.
3. We got another error; we should complain.
However, the check for case 1 does "if (fd)", which will
generally _always_ be true (except for the oddball case that
somehow our stdin got closed and opening really did give us
a new descriptor 0).
So in the EEXIST case, we tried to write the default config
anyway! Fortunately, this turns out to be a noop, since we
just end up writing to and closing "-1", which does nothing.
But in case 3, we would fail to notice any other errors, and
just silently continue (given that we don't actually notice
write errors for the template either, it's probably not that
big a deal; we're about to spawn the editor, so it would
notice any problems. But the code is clearly _trying_ to hit
cover this case and failing).
We can fix it easily by using "fd >= 0" for case 1.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-07-08 09:06:50 +00:00
|
|
|
if (fd >= 0) {
|
2014-07-25 19:11:34 +00:00
|
|
|
char *content = default_user_config();
|
|
|
|
write_str_in_full(fd, content);
|
|
|
|
free(content);
|
|
|
|
close(fd);
|
|
|
|
}
|
|
|
|
else if (errno != EEXIST)
|
|
|
|
die_errno(_("cannot create configuration file %s"), config_file);
|
|
|
|
}
|
|
|
|
launch_editor(config_file, NULL, NULL);
|
2014-11-16 07:37:44 +00:00
|
|
|
free(config_file);
|
2009-02-21 00:49:25 +00:00
|
|
|
}
|
|
|
|
else if (actions == ACTION_SET) {
|
2011-05-17 15:38:53 +00:00
|
|
|
int ret;
|
2014-02-18 22:58:53 +00:00
|
|
|
check_write();
|
2009-02-21 00:49:25 +00:00
|
|
|
check_argc(argc, 2, 2);
|
|
|
|
value = normalize_value(argv[0], argv[1]);
|
add UNLEAK annotation for reducing leak false positives
It's a common pattern in git commands to allocate some
memory that should last for the lifetime of the program and
then not bother to free it, relying on the OS to throw it
away.
This keeps the code simple, and it's fast (we don't waste
time traversing structures or calling free at the end of the
program). But it also triggers warnings from memory-leak
checkers like valgrind or LSAN. They know that the memory
was still allocated at program exit, but they don't know
_when_ the leaked memory stopped being useful. If it was
early in the program, then it's probably a real and
important leak. But if it was used right up until program
exit, it's not an interesting leak and we'd like to suppress
it so that we can see the real leaks.
This patch introduces an UNLEAK() macro that lets us do so.
To understand its design, let's first look at some of the
alternatives.
Unfortunately the suppression systems offered by
leak-checking tools don't quite do what we want. A
leak-checker basically knows two things:
1. Which blocks were allocated via malloc, and the
callstack during the allocation.
2. Which blocks were left un-freed at the end of the
program (and which are unreachable, but more on that
later).
Their suppressions work by mentioning the function or
callstack of a particular allocation, and marking it as OK
to leak. So imagine you have code like this:
int cmd_foo(...)
{
/* this allocates some memory */
char *p = some_function();
printf("%s", p);
return 0;
}
You can say "ignore allocations from some_function(),
they're not leaks". But that's not right. That function may
be called elsewhere, too, and we would potentially want to
know about those leaks.
So you can say "ignore the callstack when main calls
some_function". That works, but your annotations are
brittle. In this case it's only two functions, but you can
imagine that the actual allocation is much deeper. If any of
the intermediate code changes, you have to update the
suppression.
What we _really_ want to say is that "the value assigned to
p at the end of the function is not a real leak". But
leak-checkers can't understand that; they don't know about
"p" in the first place.
However, we can do something a little bit tricky if we make
some assumptions about how leak-checkers work. They
generally don't just report all un-freed blocks. That would
report even globals which are still accessible when the
leak-check is run. Instead they take some set of memory
(like BSS) as a root and mark it as "reachable". Then they
scan the reachable blocks for anything that looks like a
pointer to a malloc'd block, and consider that block
reachable. And then they scan those blocks, and so on,
transitively marking anything reachable from a global as
"not leaked" (or at least leaked in a different category).
So we can mark the value of "p" as reachable by putting it
into a variable with program lifetime. One way to do that is
to just mark "p" as static. But that actually affects the
run-time behavior if the function is called twice (you
aren't likely to call main() twice, but some of our cmd_*()
functions are called from other commands).
Instead, we can trick the leak-checker by putting the value
into _any_ reachable bytes. This patch keeps a global
linked-list of bytes copied from "unleaked" variables. That
list is reachable even at program exit, which confers
recursive reachability on whatever values we unleak.
In other words, you can do:
int cmd_foo(...)
{
char *p = some_function();
printf("%s", p);
UNLEAK(p);
return 0;
}
to annotate "p" and suppress the leak report.
But wait, couldn't we just say "free(p)"? In this toy
example, yes. But UNLEAK()'s byte-copying strategy has
several advantages over actually freeing the memory:
1. It's recursive across structures. In many cases our "p"
is not just a pointer, but a complex struct whose
fields may have been allocated by a sub-function. And
in some cases (e.g., dir_struct) we don't even have a
function which knows how to free all of the struct
members.
By marking the struct itself as reachable, that confers
reachability on any pointers it contains (including those
found in embedded structs, or reachable by walking
heap blocks recursively.
2. It works on cases where we're not sure if the value is
allocated or not. For example:
char *p = argc > 1 ? argv[1] : some_function();
It's safe to use UNLEAK(p) here, because it's not
freeing any memory. In the case that we're pointing to
argv here, the reachability checker will just ignore
our bytes.
3. Likewise, it works even if the variable has _already_
been freed. We're just copying the pointer bytes. If
the block has been freed, the leak-checker will skip
over those bytes as uninteresting.
4. Because it's not actually freeing memory, you can
UNLEAK() before we are finished accessing the variable.
This is helpful in cases like this:
char *p = some_function();
return another_function(p);
Writing this with free() requires:
int ret;
char *p = some_function();
ret = another_function(p);
free(p);
return ret;
But with unleak we can just write:
char *p = some_function();
UNLEAK(p);
return another_function(p);
This patch adds the UNLEAK() macro and enables it
automatically when Git is compiled with SANITIZE=leak. In
normal builds it's a noop, so we pay no runtime cost.
It also adds some UNLEAK() annotations to show off how the
feature works. On top of other recent leak fixes, these are
enough to get t0000 and t0001 to pass when compiled with
LSAN.
Note the case in commit.c which actually converts a
strbuf_release() into an UNLEAK. This code was already
non-leaky, but the free didn't do anything useful, since
we're exiting. Converting it to an annotation means that
non-leak-checking builds pay no runtime cost. The cost is
minimal enough that it's probably not worth going on a
crusade to convert these kinds of frees to UNLEAKS. I did it
here for consistency with the "sb" leak (though it would
have been equally correct to go the other way, and turn them
both into strbuf_release() calls).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-08 06:38:41 +00:00
|
|
|
UNLEAK(value);
|
2016-02-22 11:23:35 +00:00
|
|
|
ret = git_config_set_in_file_gently(given_config_source.file, argv[0], value);
|
2011-05-17 15:38:53 +00:00
|
|
|
if (ret == CONFIG_NOTHING_SET)
|
2016-09-15 14:59:00 +00:00
|
|
|
error(_("cannot overwrite multiple values with a single value\n"
|
|
|
|
" Use a regexp, --add or --replace-all to change %s."), argv[0]);
|
2011-05-17 15:38:53 +00:00
|
|
|
return ret;
|
2009-02-21 00:49:25 +00:00
|
|
|
}
|
|
|
|
else if (actions == ACTION_SET_ALL) {
|
2014-02-18 22:58:53 +00:00
|
|
|
check_write();
|
2009-02-21 00:49:25 +00:00
|
|
|
check_argc(argc, 2, 3);
|
|
|
|
value = normalize_value(argv[0], argv[1]);
|
add UNLEAK annotation for reducing leak false positives
It's a common pattern in git commands to allocate some
memory that should last for the lifetime of the program and
then not bother to free it, relying on the OS to throw it
away.
This keeps the code simple, and it's fast (we don't waste
time traversing structures or calling free at the end of the
program). But it also triggers warnings from memory-leak
checkers like valgrind or LSAN. They know that the memory
was still allocated at program exit, but they don't know
_when_ the leaked memory stopped being useful. If it was
early in the program, then it's probably a real and
important leak. But if it was used right up until program
exit, it's not an interesting leak and we'd like to suppress
it so that we can see the real leaks.
This patch introduces an UNLEAK() macro that lets us do so.
To understand its design, let's first look at some of the
alternatives.
Unfortunately the suppression systems offered by
leak-checking tools don't quite do what we want. A
leak-checker basically knows two things:
1. Which blocks were allocated via malloc, and the
callstack during the allocation.
2. Which blocks were left un-freed at the end of the
program (and which are unreachable, but more on that
later).
Their suppressions work by mentioning the function or
callstack of a particular allocation, and marking it as OK
to leak. So imagine you have code like this:
int cmd_foo(...)
{
/* this allocates some memory */
char *p = some_function();
printf("%s", p);
return 0;
}
You can say "ignore allocations from some_function(),
they're not leaks". But that's not right. That function may
be called elsewhere, too, and we would potentially want to
know about those leaks.
So you can say "ignore the callstack when main calls
some_function". That works, but your annotations are
brittle. In this case it's only two functions, but you can
imagine that the actual allocation is much deeper. If any of
the intermediate code changes, you have to update the
suppression.
What we _really_ want to say is that "the value assigned to
p at the end of the function is not a real leak". But
leak-checkers can't understand that; they don't know about
"p" in the first place.
However, we can do something a little bit tricky if we make
some assumptions about how leak-checkers work. They
generally don't just report all un-freed blocks. That would
report even globals which are still accessible when the
leak-check is run. Instead they take some set of memory
(like BSS) as a root and mark it as "reachable". Then they
scan the reachable blocks for anything that looks like a
pointer to a malloc'd block, and consider that block
reachable. And then they scan those blocks, and so on,
transitively marking anything reachable from a global as
"not leaked" (or at least leaked in a different category).
So we can mark the value of "p" as reachable by putting it
into a variable with program lifetime. One way to do that is
to just mark "p" as static. But that actually affects the
run-time behavior if the function is called twice (you
aren't likely to call main() twice, but some of our cmd_*()
functions are called from other commands).
Instead, we can trick the leak-checker by putting the value
into _any_ reachable bytes. This patch keeps a global
linked-list of bytes copied from "unleaked" variables. That
list is reachable even at program exit, which confers
recursive reachability on whatever values we unleak.
In other words, you can do:
int cmd_foo(...)
{
char *p = some_function();
printf("%s", p);
UNLEAK(p);
return 0;
}
to annotate "p" and suppress the leak report.
But wait, couldn't we just say "free(p)"? In this toy
example, yes. But UNLEAK()'s byte-copying strategy has
several advantages over actually freeing the memory:
1. It's recursive across structures. In many cases our "p"
is not just a pointer, but a complex struct whose
fields may have been allocated by a sub-function. And
in some cases (e.g., dir_struct) we don't even have a
function which knows how to free all of the struct
members.
By marking the struct itself as reachable, that confers
reachability on any pointers it contains (including those
found in embedded structs, or reachable by walking
heap blocks recursively.
2. It works on cases where we're not sure if the value is
allocated or not. For example:
char *p = argc > 1 ? argv[1] : some_function();
It's safe to use UNLEAK(p) here, because it's not
freeing any memory. In the case that we're pointing to
argv here, the reachability checker will just ignore
our bytes.
3. Likewise, it works even if the variable has _already_
been freed. We're just copying the pointer bytes. If
the block has been freed, the leak-checker will skip
over those bytes as uninteresting.
4. Because it's not actually freeing memory, you can
UNLEAK() before we are finished accessing the variable.
This is helpful in cases like this:
char *p = some_function();
return another_function(p);
Writing this with free() requires:
int ret;
char *p = some_function();
ret = another_function(p);
free(p);
return ret;
But with unleak we can just write:
char *p = some_function();
UNLEAK(p);
return another_function(p);
This patch adds the UNLEAK() macro and enables it
automatically when Git is compiled with SANITIZE=leak. In
normal builds it's a noop, so we pay no runtime cost.
It also adds some UNLEAK() annotations to show off how the
feature works. On top of other recent leak fixes, these are
enough to get t0000 and t0001 to pass when compiled with
LSAN.
Note the case in commit.c which actually converts a
strbuf_release() into an UNLEAK. This code was already
non-leaky, but the free didn't do anything useful, since
we're exiting. Converting it to an annotation means that
non-leak-checking builds pay no runtime cost. The cost is
minimal enough that it's probably not worth going on a
crusade to convert these kinds of frees to UNLEAKS. I did it
here for consistency with the "sb" leak (though it would
have been equally correct to go the other way, and turn them
both into strbuf_release() calls).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-08 06:38:41 +00:00
|
|
|
UNLEAK(value);
|
2016-02-22 11:23:35 +00:00
|
|
|
return git_config_set_multivar_in_file_gently(given_config_source.file,
|
|
|
|
argv[0], value, argv[2], 0);
|
2009-02-21 00:49:25 +00:00
|
|
|
}
|
|
|
|
else if (actions == ACTION_ADD) {
|
2014-02-18 22:58:53 +00:00
|
|
|
check_write();
|
2009-02-21 00:49:25 +00:00
|
|
|
check_argc(argc, 2, 2);
|
|
|
|
value = normalize_value(argv[0], argv[1]);
|
add UNLEAK annotation for reducing leak false positives
It's a common pattern in git commands to allocate some
memory that should last for the lifetime of the program and
then not bother to free it, relying on the OS to throw it
away.
This keeps the code simple, and it's fast (we don't waste
time traversing structures or calling free at the end of the
program). But it also triggers warnings from memory-leak
checkers like valgrind or LSAN. They know that the memory
was still allocated at program exit, but they don't know
_when_ the leaked memory stopped being useful. If it was
early in the program, then it's probably a real and
important leak. But if it was used right up until program
exit, it's not an interesting leak and we'd like to suppress
it so that we can see the real leaks.
This patch introduces an UNLEAK() macro that lets us do so.
To understand its design, let's first look at some of the
alternatives.
Unfortunately the suppression systems offered by
leak-checking tools don't quite do what we want. A
leak-checker basically knows two things:
1. Which blocks were allocated via malloc, and the
callstack during the allocation.
2. Which blocks were left un-freed at the end of the
program (and which are unreachable, but more on that
later).
Their suppressions work by mentioning the function or
callstack of a particular allocation, and marking it as OK
to leak. So imagine you have code like this:
int cmd_foo(...)
{
/* this allocates some memory */
char *p = some_function();
printf("%s", p);
return 0;
}
You can say "ignore allocations from some_function(),
they're not leaks". But that's not right. That function may
be called elsewhere, too, and we would potentially want to
know about those leaks.
So you can say "ignore the callstack when main calls
some_function". That works, but your annotations are
brittle. In this case it's only two functions, but you can
imagine that the actual allocation is much deeper. If any of
the intermediate code changes, you have to update the
suppression.
What we _really_ want to say is that "the value assigned to
p at the end of the function is not a real leak". But
leak-checkers can't understand that; they don't know about
"p" in the first place.
However, we can do something a little bit tricky if we make
some assumptions about how leak-checkers work. They
generally don't just report all un-freed blocks. That would
report even globals which are still accessible when the
leak-check is run. Instead they take some set of memory
(like BSS) as a root and mark it as "reachable". Then they
scan the reachable blocks for anything that looks like a
pointer to a malloc'd block, and consider that block
reachable. And then they scan those blocks, and so on,
transitively marking anything reachable from a global as
"not leaked" (or at least leaked in a different category).
So we can mark the value of "p" as reachable by putting it
into a variable with program lifetime. One way to do that is
to just mark "p" as static. But that actually affects the
run-time behavior if the function is called twice (you
aren't likely to call main() twice, but some of our cmd_*()
functions are called from other commands).
Instead, we can trick the leak-checker by putting the value
into _any_ reachable bytes. This patch keeps a global
linked-list of bytes copied from "unleaked" variables. That
list is reachable even at program exit, which confers
recursive reachability on whatever values we unleak.
In other words, you can do:
int cmd_foo(...)
{
char *p = some_function();
printf("%s", p);
UNLEAK(p);
return 0;
}
to annotate "p" and suppress the leak report.
But wait, couldn't we just say "free(p)"? In this toy
example, yes. But UNLEAK()'s byte-copying strategy has
several advantages over actually freeing the memory:
1. It's recursive across structures. In many cases our "p"
is not just a pointer, but a complex struct whose
fields may have been allocated by a sub-function. And
in some cases (e.g., dir_struct) we don't even have a
function which knows how to free all of the struct
members.
By marking the struct itself as reachable, that confers
reachability on any pointers it contains (including those
found in embedded structs, or reachable by walking
heap blocks recursively.
2. It works on cases where we're not sure if the value is
allocated or not. For example:
char *p = argc > 1 ? argv[1] : some_function();
It's safe to use UNLEAK(p) here, because it's not
freeing any memory. In the case that we're pointing to
argv here, the reachability checker will just ignore
our bytes.
3. Likewise, it works even if the variable has _already_
been freed. We're just copying the pointer bytes. If
the block has been freed, the leak-checker will skip
over those bytes as uninteresting.
4. Because it's not actually freeing memory, you can
UNLEAK() before we are finished accessing the variable.
This is helpful in cases like this:
char *p = some_function();
return another_function(p);
Writing this with free() requires:
int ret;
char *p = some_function();
ret = another_function(p);
free(p);
return ret;
But with unleak we can just write:
char *p = some_function();
UNLEAK(p);
return another_function(p);
This patch adds the UNLEAK() macro and enables it
automatically when Git is compiled with SANITIZE=leak. In
normal builds it's a noop, so we pay no runtime cost.
It also adds some UNLEAK() annotations to show off how the
feature works. On top of other recent leak fixes, these are
enough to get t0000 and t0001 to pass when compiled with
LSAN.
Note the case in commit.c which actually converts a
strbuf_release() into an UNLEAK. This code was already
non-leaky, but the free didn't do anything useful, since
we're exiting. Converting it to an annotation means that
non-leak-checking builds pay no runtime cost. The cost is
minimal enough that it's probably not worth going on a
crusade to convert these kinds of frees to UNLEAKS. I did it
here for consistency with the "sb" leak (though it would
have been equally correct to go the other way, and turn them
both into strbuf_release() calls).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-08 06:38:41 +00:00
|
|
|
UNLEAK(value);
|
2016-02-22 11:23:35 +00:00
|
|
|
return git_config_set_multivar_in_file_gently(given_config_source.file,
|
|
|
|
argv[0], value,
|
|
|
|
CONFIG_REGEX_NONE, 0);
|
2009-02-21 00:49:25 +00:00
|
|
|
}
|
|
|
|
else if (actions == ACTION_REPLACE_ALL) {
|
2014-02-18 22:58:53 +00:00
|
|
|
check_write();
|
2009-02-21 00:49:25 +00:00
|
|
|
check_argc(argc, 2, 3);
|
|
|
|
value = normalize_value(argv[0], argv[1]);
|
add UNLEAK annotation for reducing leak false positives
It's a common pattern in git commands to allocate some
memory that should last for the lifetime of the program and
then not bother to free it, relying on the OS to throw it
away.
This keeps the code simple, and it's fast (we don't waste
time traversing structures or calling free at the end of the
program). But it also triggers warnings from memory-leak
checkers like valgrind or LSAN. They know that the memory
was still allocated at program exit, but they don't know
_when_ the leaked memory stopped being useful. If it was
early in the program, then it's probably a real and
important leak. But if it was used right up until program
exit, it's not an interesting leak and we'd like to suppress
it so that we can see the real leaks.
This patch introduces an UNLEAK() macro that lets us do so.
To understand its design, let's first look at some of the
alternatives.
Unfortunately the suppression systems offered by
leak-checking tools don't quite do what we want. A
leak-checker basically knows two things:
1. Which blocks were allocated via malloc, and the
callstack during the allocation.
2. Which blocks were left un-freed at the end of the
program (and which are unreachable, but more on that
later).
Their suppressions work by mentioning the function or
callstack of a particular allocation, and marking it as OK
to leak. So imagine you have code like this:
int cmd_foo(...)
{
/* this allocates some memory */
char *p = some_function();
printf("%s", p);
return 0;
}
You can say "ignore allocations from some_function(),
they're not leaks". But that's not right. That function may
be called elsewhere, too, and we would potentially want to
know about those leaks.
So you can say "ignore the callstack when main calls
some_function". That works, but your annotations are
brittle. In this case it's only two functions, but you can
imagine that the actual allocation is much deeper. If any of
the intermediate code changes, you have to update the
suppression.
What we _really_ want to say is that "the value assigned to
p at the end of the function is not a real leak". But
leak-checkers can't understand that; they don't know about
"p" in the first place.
However, we can do something a little bit tricky if we make
some assumptions about how leak-checkers work. They
generally don't just report all un-freed blocks. That would
report even globals which are still accessible when the
leak-check is run. Instead they take some set of memory
(like BSS) as a root and mark it as "reachable". Then they
scan the reachable blocks for anything that looks like a
pointer to a malloc'd block, and consider that block
reachable. And then they scan those blocks, and so on,
transitively marking anything reachable from a global as
"not leaked" (or at least leaked in a different category).
So we can mark the value of "p" as reachable by putting it
into a variable with program lifetime. One way to do that is
to just mark "p" as static. But that actually affects the
run-time behavior if the function is called twice (you
aren't likely to call main() twice, but some of our cmd_*()
functions are called from other commands).
Instead, we can trick the leak-checker by putting the value
into _any_ reachable bytes. This patch keeps a global
linked-list of bytes copied from "unleaked" variables. That
list is reachable even at program exit, which confers
recursive reachability on whatever values we unleak.
In other words, you can do:
int cmd_foo(...)
{
char *p = some_function();
printf("%s", p);
UNLEAK(p);
return 0;
}
to annotate "p" and suppress the leak report.
But wait, couldn't we just say "free(p)"? In this toy
example, yes. But UNLEAK()'s byte-copying strategy has
several advantages over actually freeing the memory:
1. It's recursive across structures. In many cases our "p"
is not just a pointer, but a complex struct whose
fields may have been allocated by a sub-function. And
in some cases (e.g., dir_struct) we don't even have a
function which knows how to free all of the struct
members.
By marking the struct itself as reachable, that confers
reachability on any pointers it contains (including those
found in embedded structs, or reachable by walking
heap blocks recursively.
2. It works on cases where we're not sure if the value is
allocated or not. For example:
char *p = argc > 1 ? argv[1] : some_function();
It's safe to use UNLEAK(p) here, because it's not
freeing any memory. In the case that we're pointing to
argv here, the reachability checker will just ignore
our bytes.
3. Likewise, it works even if the variable has _already_
been freed. We're just copying the pointer bytes. If
the block has been freed, the leak-checker will skip
over those bytes as uninteresting.
4. Because it's not actually freeing memory, you can
UNLEAK() before we are finished accessing the variable.
This is helpful in cases like this:
char *p = some_function();
return another_function(p);
Writing this with free() requires:
int ret;
char *p = some_function();
ret = another_function(p);
free(p);
return ret;
But with unleak we can just write:
char *p = some_function();
UNLEAK(p);
return another_function(p);
This patch adds the UNLEAK() macro and enables it
automatically when Git is compiled with SANITIZE=leak. In
normal builds it's a noop, so we pay no runtime cost.
It also adds some UNLEAK() annotations to show off how the
feature works. On top of other recent leak fixes, these are
enough to get t0000 and t0001 to pass when compiled with
LSAN.
Note the case in commit.c which actually converts a
strbuf_release() into an UNLEAK. This code was already
non-leaky, but the free didn't do anything useful, since
we're exiting. Converting it to an annotation means that
non-leak-checking builds pay no runtime cost. The cost is
minimal enough that it's probably not worth going on a
crusade to convert these kinds of frees to UNLEAKS. I did it
here for consistency with the "sb" leak (though it would
have been equally correct to go the other way, and turn them
both into strbuf_release() calls).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-08 06:38:41 +00:00
|
|
|
UNLEAK(value);
|
2016-02-22 11:23:35 +00:00
|
|
|
return git_config_set_multivar_in_file_gently(given_config_source.file,
|
|
|
|
argv[0], value, argv[2], 1);
|
2009-02-21 00:49:25 +00:00
|
|
|
}
|
|
|
|
else if (actions == ACTION_GET) {
|
|
|
|
check_argc(argc, 1, 2);
|
|
|
|
return get_value(argv[0], argv[1]);
|
|
|
|
}
|
|
|
|
else if (actions == ACTION_GET_ALL) {
|
|
|
|
do_all = 1;
|
|
|
|
check_argc(argc, 1, 2);
|
|
|
|
return get_value(argv[0], argv[1]);
|
|
|
|
}
|
|
|
|
else if (actions == ACTION_GET_REGEXP) {
|
|
|
|
show_keys = 1;
|
|
|
|
use_key_regexp = 1;
|
|
|
|
do_all = 1;
|
|
|
|
check_argc(argc, 1, 2);
|
|
|
|
return get_value(argv[0], argv[1]);
|
|
|
|
}
|
2013-07-31 18:14:59 +00:00
|
|
|
else if (actions == ACTION_GET_URLMATCH) {
|
|
|
|
check_argc(argc, 2, 2);
|
|
|
|
return get_urlmatch(argv[0], argv[1]);
|
|
|
|
}
|
2009-02-21 00:49:25 +00:00
|
|
|
else if (actions == ACTION_UNSET) {
|
2014-02-18 22:58:53 +00:00
|
|
|
check_write();
|
2009-02-21 00:49:25 +00:00
|
|
|
check_argc(argc, 1, 2);
|
|
|
|
if (argc == 2)
|
2016-02-22 11:23:35 +00:00
|
|
|
return git_config_set_multivar_in_file_gently(given_config_source.file,
|
|
|
|
argv[0], NULL, argv[1], 0);
|
2009-02-21 00:49:25 +00:00
|
|
|
else
|
2016-02-22 11:23:35 +00:00
|
|
|
return git_config_set_in_file_gently(given_config_source.file,
|
|
|
|
argv[0], NULL);
|
2009-02-21 00:49:25 +00:00
|
|
|
}
|
|
|
|
else if (actions == ACTION_UNSET_ALL) {
|
2014-02-18 22:58:53 +00:00
|
|
|
check_write();
|
2009-02-21 00:49:25 +00:00
|
|
|
check_argc(argc, 1, 2);
|
2016-02-22 11:23:35 +00:00
|
|
|
return git_config_set_multivar_in_file_gently(given_config_source.file,
|
|
|
|
argv[0], NULL, argv[1], 1);
|
2009-02-21 00:49:25 +00:00
|
|
|
}
|
|
|
|
else if (actions == ACTION_RENAME_SECTION) {
|
|
|
|
int ret;
|
2014-02-18 22:58:53 +00:00
|
|
|
check_write();
|
2009-02-21 00:49:25 +00:00
|
|
|
check_argc(argc, 2, 2);
|
2014-02-18 22:58:54 +00:00
|
|
|
ret = git_config_rename_section_in_file(given_config_source.file,
|
config: stop using config_exclusive_filename
The git-config command sometimes operates on the default set
of config files (either reading from all, or writing to repo
config), and sometimes operates on a specific file. In the
latter case, we set the magic global config_exclusive_filename,
and the code in config.c does the right thing.
Instead, let's have git-config use the "advanced" variants
of config.c's functions which let it specify an individual
filename (or NULL for the default). This makes the code a
lot more obvious, and fixes two small bugs:
1. A relative path specified by GIT_CONFIG=foo will look
in the wrong directory if we have to chdir as part of
repository setup. We already handle this properly for
"git config -f foo", but the GIT_CONFIG lookup used
config_exclusive_filename directly. By dropping to a
single magic variable, the GIT_CONFIG case now just
works.
2. Calling "git config -f foo --edit" would not respect
core.editor. This is because just before editing, we
called git_config, which would respect the
config_exclusive_filename setting, even though this
particular git_config call was not about looking in the
user's specified file, but rather about loading actual
git config, just as any other git program would.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-02-16 08:07:32 +00:00
|
|
|
argv[0], argv[1]);
|
2009-02-21 00:49:25 +00:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
if (ret == 0)
|
2018-07-21 07:49:22 +00:00
|
|
|
die(_("no such section: %s"), argv[0]);
|
2009-02-21 00:49:25 +00:00
|
|
|
}
|
|
|
|
else if (actions == ACTION_REMOVE_SECTION) {
|
|
|
|
int ret;
|
2014-02-18 22:58:53 +00:00
|
|
|
check_write();
|
2009-02-21 00:49:25 +00:00
|
|
|
check_argc(argc, 1, 1);
|
2014-02-18 22:58:54 +00:00
|
|
|
ret = git_config_rename_section_in_file(given_config_source.file,
|
config: stop using config_exclusive_filename
The git-config command sometimes operates on the default set
of config files (either reading from all, or writing to repo
config), and sometimes operates on a specific file. In the
latter case, we set the magic global config_exclusive_filename,
and the code in config.c does the right thing.
Instead, let's have git-config use the "advanced" variants
of config.c's functions which let it specify an individual
filename (or NULL for the default). This makes the code a
lot more obvious, and fixes two small bugs:
1. A relative path specified by GIT_CONFIG=foo will look
in the wrong directory if we have to chdir as part of
repository setup. We already handle this properly for
"git config -f foo", but the GIT_CONFIG lookup used
config_exclusive_filename directly. By dropping to a
single magic variable, the GIT_CONFIG case now just
works.
2. Calling "git config -f foo --edit" would not respect
core.editor. This is because just before editing, we
called git_config, which would respect the
config_exclusive_filename setting, even though this
particular git_config call was not about looking in the
user's specified file, but rather about loading actual
git config, just as any other git program would.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-02-16 08:07:32 +00:00
|
|
|
argv[0], NULL);
|
2009-02-21 00:49:25 +00:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
if (ret == 0)
|
2018-07-21 07:49:22 +00:00
|
|
|
die(_("no such section: %s"), argv[0]);
|
2009-02-21 00:49:25 +00:00
|
|
|
}
|
|
|
|
else if (actions == ACTION_GET_COLOR) {
|
config: fix parsing of "git config --get-color some.key -1"
Most of git-config's command line options use OPT_BIT to
choose an action, and then parse the non-option arguments
in a context-dependent way. However, --get-color and
--get-colorbool are unlike the rest of the options, in that
they are OPT_STRING, taking the option name as a parameter.
This generally works, because we then use the presence of
those strings to set an action bit anyway. But it does mean
that the option-parser will continue looking for options
even after the key (because it is not a non-option; it is an
argument to an option). And running:
git config --get-color some.key -1
(to use "-1" as the default color spec) will barf, claiming
that "-1" is not an option. Instead, we should treat
--get-color and --get-colorbool as action bits, just like
--add, --get, and all the other actions, and then check that
the non-option arguments we got are sane. This fixes the
weirdness above, and makes those two options like all the
others.
This "fixes" a test in t4026, which checked that feeding
"-2" as a color should fail (it does fail, but prior to this
patch, because parseopt barfed, not because we actually ever
tried to parse the color).
This also catches other errors, like:
git config --get-color some.key black blue
which previously silently ignored "blue" (and now will
complain that you gave too many arguments).
There are some possible regressions, though. We now disallow
these, which currently do what you would expect:
# specifying other options after the action
git config --get-color some.key --file whatever
# using long-arg syntax
git config --get-color=some.key
However, we have never advertised these in the
documentation, and in fact they did not work in some older
versions of git. The behavior was apparently switched as an
accidental side effect of d64ec16 (git config: reorganize to
use parseopt, 2009-02-21).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-20 15:15:51 +00:00
|
|
|
check_argc(argc, 1, 2);
|
|
|
|
get_color(argv[0], argv[1]);
|
2009-02-21 00:49:25 +00:00
|
|
|
}
|
|
|
|
else if (actions == ACTION_GET_COLORBOOL) {
|
config: fix parsing of "git config --get-color some.key -1"
Most of git-config's command line options use OPT_BIT to
choose an action, and then parse the non-option arguments
in a context-dependent way. However, --get-color and
--get-colorbool are unlike the rest of the options, in that
they are OPT_STRING, taking the option name as a parameter.
This generally works, because we then use the presence of
those strings to set an action bit anyway. But it does mean
that the option-parser will continue looking for options
even after the key (because it is not a non-option; it is an
argument to an option). And running:
git config --get-color some.key -1
(to use "-1" as the default color spec) will barf, claiming
that "-1" is not an option. Instead, we should treat
--get-color and --get-colorbool as action bits, just like
--add, --get, and all the other actions, and then check that
the non-option arguments we got are sane. This fixes the
weirdness above, and makes those two options like all the
others.
This "fixes" a test in t4026, which checked that feeding
"-2" as a color should fail (it does fail, but prior to this
patch, because parseopt barfed, not because we actually ever
tried to parse the color).
This also catches other errors, like:
git config --get-color some.key black blue
which previously silently ignored "blue" (and now will
complain that you gave too many arguments).
There are some possible regressions, though. We now disallow
these, which currently do what you would expect:
# specifying other options after the action
git config --get-color some.key --file whatever
# using long-arg syntax
git config --get-color=some.key
However, we have never advertised these in the
documentation, and in fact they did not work in some older
versions of git. The behavior was apparently switched as an
accidental side effect of d64ec16 (git config: reorganize to
use parseopt, 2009-02-21).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-11-20 15:15:51 +00:00
|
|
|
check_argc(argc, 1, 2);
|
|
|
|
if (argc == 2)
|
|
|
|
color_stdout_is_tty = git_config_bool("command line", argv[1]);
|
|
|
|
return get_colorbool(argv[0], argc == 2);
|
2009-02-21 00:49:25 +00:00
|
|
|
}
|
|
|
|
|
2005-11-17 21:44:55 +00:00
|
|
|
return 0;
|
|
|
|
}
|