2005-11-18 05:32:36 +08:00
|
|
|
/*
|
|
|
|
|
* GIT - The information manager from hell
|
|
|
|
|
*
|
|
|
|
|
* Copyright (C) Linus Torvalds, 2005
|
|
|
|
|
* Copyright (C) Johannes Schindelin, 2005
|
|
|
|
|
*
|
|
|
|
|
*/
|
2005-10-11 07:31:08 +08:00
|
|
|
#include "cache.h"
|
2018-08-16 01:54:07 +08:00
|
|
|
#include "branch.h"
|
2017-06-15 02:07:36 +08:00
|
|
|
#include "config.h"
|
2017-06-23 02:43:42 +08:00
|
|
|
#include "repository.h"
|
2014-10-01 18:28:42 +08:00
|
|
|
#include "lockfile.h"
|
2018-04-11 05:26:18 +08:00
|
|
|
#include "exec-cmd.h"
|
2010-03-27 06:56:01 +08:00
|
|
|
#include "strbuf.h"
|
2010-08-24 03:16:00 +08:00
|
|
|
#include "quote.h"
|
2014-07-28 18:10:38 +08:00
|
|
|
#include "hashmap.h"
|
|
|
|
|
#include "string-list.h"
|
2018-05-16 07:42:15 +08:00
|
|
|
#include "object-store.h"
|
2015-04-17 01:47:45 +08:00
|
|
|
#include "utf8.h"
|
config: add conditional include
Sometimes a set of repositories want to share configuration settings
among themselves that are distinct from other such sets of repositories.
A user may work on two projects, each of which have multiple
repositories, and use one user.email for one project while using another
for the other.
Setting $GIT_DIR/.config works, but if the penalty of forgetting to
update $GIT_DIR/.config is high (especially when you end up cloning
often), it may not be the best way to go. Having the settings in
~/.gitconfig, which would work for just one set of repositories, would
not well in such a situation. Having separate ${HOME}s may add more
problems than it solves.
Extend the include.path mechanism that lets a config file include
another config file, so that the inclusion can be done only when some
conditions hold. Then ~/.gitconfig can say "include config-project-A
only when working on project-A" for each project A the user works on.
In this patch, the only supported grouping is based on $GIT_DIR (in
absolute path), so you would need to group repositories by directory, or
something like that to take advantage of it.
We already have include.path for unconditional includes. This patch goes
with includeIf.<condition>.path to make it clearer that a condition is
required. The new config has the same backward compatibility approach as
include.path: older git versions that don't understand includeIf will
simply ignore them.
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-01 19:26:31 +08:00
|
|
|
#include "dir.h"
|
2018-04-10 08:18:28 +08:00
|
|
|
#include "color.h"
|
2019-06-06 05:21:59 +08:00
|
|
|
#include "refs.h"
|
2005-10-11 07:31:08 +08:00
|
|
|
|
2013-07-12 06:44:39 +08:00
|
|
|
struct config_source {
|
|
|
|
|
struct config_source *prev;
|
|
|
|
|
union {
|
|
|
|
|
FILE *file;
|
2013-07-12 06:46:47 +08:00
|
|
|
struct config_buf {
|
|
|
|
|
const char *buf;
|
|
|
|
|
size_t len;
|
|
|
|
|
size_t pos;
|
|
|
|
|
} buf;
|
2013-07-12 06:44:39 +08:00
|
|
|
} u;
|
i18n: config: unfold error messages marked for translation
Introduced in 473166b ("config: add 'origin_type' to config_source
struct", 2016-02-19), Git can inform the user about the origin of a
config error, but the implementation does not allow translators to
translate the keywords 'file', 'blob, 'standard input', and
'submodule-blob'. Moreover, for the second message, a reason for the
error is appended to the message, not allowing translators to translate
that reason either.
Unfold the message into several templates for each known origin_type.
That would result in better translation at the expense of code
verbosity.
Add enum config_oringin_type to ease management of the various
configuration origin types (blob, file, etc). Previously origin type
was considered from command line if cf->origin_type == NULL, i.e.,
uninitialized. Now we set origin_type to CONFIG_ORIGIN_CMDLINE in
git_config_from_parameters() and configset_add_value().
For error message in git_parse_source(), use xstrfmt() function to
prepare the message string, instead of doing something like it's done
for die_bad_number(), because intelligibility and code conciseness are
improved for that instance.
Signed-off-by: Vasco Almeida <vascomalmeida@sapo.pt>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-07-28 21:14:03 +08:00
|
|
|
enum config_origin_type origin_type;
|
config.c: Make git_config() work correctly when called recursively
On Cygwin, this fixes a test failure in t3301-notes.sh (test 98,
"git notes copy --for-rewrite (disabled)").
The test failure is caused by a recursive call to git_config() which
has the effect of skipping to the end-of-file while processing the
"notes.rewriteref" config variable. Thus, any config variables that
appear after "notes.rewriteref" are simply ignored by git_config().
Also, we note that the original FILE handle is leaked as a result
of the recursive call.
The recursive call to git_config() is due to the "schizophrenic stat"
functions on cygwin, where one of two different implementations of
the l/stat functions is selected lazily, depending on some config
variables.
In this case, the init_copy_notes_for_rewrite() function calls
git_config() with the notes_rewrite_config() callback function.
This callback, while processing the "notes.rewriteref" variable,
in turn calls string_list_add_refs_by_glob() to process the
associated ref value. This eventually leads to a call to the
get_ref_dir() function, which in turn calls stat(). On cygwin,
the stat() macro leads to an indirect call to cygwin_stat_stub()
which, via init_stat(), then calls git_config() in order to
determine which l/stat implementation to bind to.
In order to solve this problem, we modify git_config() so that the
global state variables used by the config reading code is packaged
up and managed on a local state stack.
Signed-off-by: Ramsay Jones <ramsay@ramsay1.demon.co.uk>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-06-17 04:24:51 +08:00
|
|
|
const char *name;
|
2014-02-19 06:58:52 +08:00
|
|
|
const char *path;
|
2018-06-29 06:05:00 +08:00
|
|
|
enum config_error_action default_error_action;
|
config.c: Make git_config() work correctly when called recursively
On Cygwin, this fixes a test failure in t3301-notes.sh (test 98,
"git notes copy --for-rewrite (disabled)").
The test failure is caused by a recursive call to git_config() which
has the effect of skipping to the end-of-file while processing the
"notes.rewriteref" config variable. Thus, any config variables that
appear after "notes.rewriteref" are simply ignored by git_config().
Also, we note that the original FILE handle is leaked as a result
of the recursive call.
The recursive call to git_config() is due to the "schizophrenic stat"
functions on cygwin, where one of two different implementations of
the l/stat functions is selected lazily, depending on some config
variables.
In this case, the init_copy_notes_for_rewrite() function calls
git_config() with the notes_rewrite_config() callback function.
This callback, while processing the "notes.rewriteref" variable,
in turn calls string_list_add_refs_by_glob() to process the
associated ref value. This eventually leads to a call to the
get_ref_dir() function, which in turn calls stat(). On cygwin,
the stat() macro leads to an indirect call to cygwin_stat_stub()
which, via init_stat(), then calls git_config() in order to
determine which l/stat implementation to bind to.
In order to solve this problem, we modify git_config() so that the
global state variables used by the config reading code is packaged
up and managed on a local state stack.
Signed-off-by: Ramsay Jones <ramsay@ramsay1.demon.co.uk>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-06-17 04:24:51 +08:00
|
|
|
int linenr;
|
|
|
|
|
int eof;
|
|
|
|
|
struct strbuf value;
|
2012-10-01 03:44:36 +08:00
|
|
|
struct strbuf var;
|
2018-08-09 03:50:19 +08:00
|
|
|
unsigned subsection_case_sensitive : 1;
|
config.c: Make git_config() work correctly when called recursively
On Cygwin, this fixes a test failure in t3301-notes.sh (test 98,
"git notes copy --for-rewrite (disabled)").
The test failure is caused by a recursive call to git_config() which
has the effect of skipping to the end-of-file while processing the
"notes.rewriteref" config variable. Thus, any config variables that
appear after "notes.rewriteref" are simply ignored by git_config().
Also, we note that the original FILE handle is leaked as a result
of the recursive call.
The recursive call to git_config() is due to the "schizophrenic stat"
functions on cygwin, where one of two different implementations of
the l/stat functions is selected lazily, depending on some config
variables.
In this case, the init_copy_notes_for_rewrite() function calls
git_config() with the notes_rewrite_config() callback function.
This callback, while processing the "notes.rewriteref" variable,
in turn calls string_list_add_refs_by_glob() to process the
associated ref value. This eventually leads to a call to the
get_ref_dir() function, which in turn calls stat(). On cygwin,
the stat() macro leads to an indirect call to cygwin_stat_stub()
which, via init_stat(), then calls git_config() in order to
determine which l/stat implementation to bind to.
In order to solve this problem, we modify git_config() so that the
global state variables used by the config reading code is packaged
up and managed on a local state stack.
Signed-off-by: Ramsay Jones <ramsay@ramsay1.demon.co.uk>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-06-17 04:24:51 +08:00
|
|
|
|
2013-08-27 05:57:18 +08:00
|
|
|
int (*do_fgetc)(struct config_source *c);
|
|
|
|
|
int (*do_ungetc)(int c, struct config_source *conf);
|
|
|
|
|
long (*do_ftell)(struct config_source *c);
|
2013-07-12 06:44:39 +08:00
|
|
|
};
|
|
|
|
|
|
2016-05-27 08:32:23 +08:00
|
|
|
/*
|
|
|
|
|
* These variables record the "current" config source, which
|
|
|
|
|
* can be accessed by parsing callbacks.
|
|
|
|
|
*
|
|
|
|
|
* The "cf" variable will be non-NULL only when we are actually parsing a real
|
|
|
|
|
* config source (file, blob, cmdline, etc).
|
|
|
|
|
*
|
|
|
|
|
* The "current_config_kvi" variable will be non-NULL only when we are feeding
|
|
|
|
|
* cached config from a configset into a callback.
|
|
|
|
|
*
|
|
|
|
|
* They should generally never be non-NULL at the same time. If they are both
|
|
|
|
|
* NULL, then we aren't parsing anything (and depending on the function looking
|
|
|
|
|
* at the variables, it's either a bug for it to be called in the first place,
|
|
|
|
|
* or it's a function which can be reused for non-config purposes, and should
|
|
|
|
|
* fall back to some sane behavior).
|
|
|
|
|
*/
|
2013-07-12 06:44:39 +08:00
|
|
|
static struct config_source *cf;
|
2016-05-27 08:32:23 +08:00
|
|
|
static struct key_value_info *current_config_kvi;
|
config.c: Make git_config() work correctly when called recursively
On Cygwin, this fixes a test failure in t3301-notes.sh (test 98,
"git notes copy --for-rewrite (disabled)").
The test failure is caused by a recursive call to git_config() which
has the effect of skipping to the end-of-file while processing the
"notes.rewriteref" config variable. Thus, any config variables that
appear after "notes.rewriteref" are simply ignored by git_config().
Also, we note that the original FILE handle is leaked as a result
of the recursive call.
The recursive call to git_config() is due to the "schizophrenic stat"
functions on cygwin, where one of two different implementations of
the l/stat functions is selected lazily, depending on some config
variables.
In this case, the init_copy_notes_for_rewrite() function calls
git_config() with the notes_rewrite_config() callback function.
This callback, while processing the "notes.rewriteref" variable,
in turn calls string_list_add_refs_by_glob() to process the
associated ref value. This eventually leads to a call to the
get_ref_dir() function, which in turn calls stat(). On cygwin,
the stat() macro leads to an indirect call to cygwin_stat_stub()
which, via init_stat(), then calls git_config() in order to
determine which l/stat implementation to bind to.
In order to solve this problem, we modify git_config() so that the
global state variables used by the config reading code is packaged
up and managed on a local state stack.
Signed-off-by: Ramsay Jones <ramsay@ramsay1.demon.co.uk>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-06-17 04:24:51 +08:00
|
|
|
|
config: add a notion of "scope"
A config callback passed to git_config() doesn't know very
much about the context in which it sees a variable. It can
ask whether the variable comes from a file, and get the file
name. But without analyzing the filename (which is hard to
do accurately), it cannot tell whether it is in system-level
config, user-level config, or repo-specific config.
Generally this doesn't matter; the point of not passing this
to the callback is that it should treat the config the same
no matter where it comes from. But some programs, like
upload-pack, are a special case: we should be able to run
them in an untrusted repository, which means we cannot use
any "dangerous" config from the repository config file (but
it is OK to use it from system or user config).
This patch teaches the config code to record the "scope" of
each variable, and make it available inside config
callbacks, similar to how we give access to the filename.
The scope is the starting source for a particular parsing
operation, and remains the same even if we include other
files (so a .git/config which includes another file will
remain CONFIG_SCOPE_REPO, as it would be similarly
untrusted).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-05-19 06:44:23 +08:00
|
|
|
/*
|
|
|
|
|
* Similar to the variables above, this gives access to the "scope" of the
|
|
|
|
|
* current value (repo, global, etc). For cached values, it can be found via
|
|
|
|
|
* the current_config_kvi as above. During parsing, the current value can be
|
|
|
|
|
* found in this variable. It's not part of "cf" because it transcends a single
|
|
|
|
|
* file (i.e., a file included from .git/config is still in "repo" scope).
|
|
|
|
|
*/
|
|
|
|
|
static enum config_scope current_parsing_scope;
|
config.c: Make git_config() work correctly when called recursively
On Cygwin, this fixes a test failure in t3301-notes.sh (test 98,
"git notes copy --for-rewrite (disabled)").
The test failure is caused by a recursive call to git_config() which
has the effect of skipping to the end-of-file while processing the
"notes.rewriteref" config variable. Thus, any config variables that
appear after "notes.rewriteref" are simply ignored by git_config().
Also, we note that the original FILE handle is leaked as a result
of the recursive call.
The recursive call to git_config() is due to the "schizophrenic stat"
functions on cygwin, where one of two different implementations of
the l/stat functions is selected lazily, depending on some config
variables.
In this case, the init_copy_notes_for_rewrite() function calls
git_config() with the notes_rewrite_config() callback function.
This callback, while processing the "notes.rewriteref" variable,
in turn calls string_list_add_refs_by_glob() to process the
associated ref value. This eventually leads to a call to the
get_ref_dir() function, which in turn calls stat(). On cygwin,
the stat() macro leads to an indirect call to cygwin_stat_stub()
which, via init_stat(), then calls git_config() in order to
determine which l/stat implementation to bind to.
In order to solve this problem, we modify git_config() so that the
global state variables used by the config reading code is packaged
up and managed on a local state stack.
Signed-off-by: Ramsay Jones <ramsay@ramsay1.demon.co.uk>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-06-17 04:24:51 +08:00
|
|
|
|
2016-11-16 09:42:40 +08:00
|
|
|
static int core_compression_seen;
|
|
|
|
|
static int pack_compression_seen;
|
Custom compression levels for objects and packs
Add config variables pack.compression and core.loosecompression ,
and switch --compression=level to pack-objects.
Loose objects will be compressed using core.loosecompression if set,
else core.compression if set, else Z_BEST_SPEED.
Packed objects will be compressed using --compression=level if seen,
else pack.compression if set, else core.compression if set,
else Z_DEFAULT_COMPRESSION. This is the "pack compression level".
Loose objects added to a pack undeltified will be recompressed
to the pack compression level if it is unequal to the current
loose compression level by the preceding rules, or if the loose
object was written while core.legacyheaders = true. Newly
deltified loose objects are always compressed to the current
pack compression level.
Previously packed objects added to a pack are recompressed
to the current pack compression level exactly when their
deltification status changes, since the previous pack data
cannot be reused.
In either case, the --no-reuse-object switch from the first
patch below will always force recompression to the current pack
compression level, instead of assuming the pack compression level
hasn't changed and pack data can be reused when possible.
This applies on top of the following patches from Nicolas Pitre:
[PATCH] allow for undeltified objects not to be reused
[PATCH] make "repack -f" imply "pack-objects --no-reuse-object"
Signed-off-by: Dana L. How <danahow@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-05-10 04:56:50 +08:00
|
|
|
static int zlib_compression_seen;
|
|
|
|
|
|
2013-07-12 06:44:39 +08:00
|
|
|
static int config_file_fgetc(struct config_source *conf)
|
|
|
|
|
{
|
2015-04-16 16:51:18 +08:00
|
|
|
return getc_unlocked(conf->u.file);
|
2013-07-12 06:44:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int config_file_ungetc(int c, struct config_source *conf)
|
|
|
|
|
{
|
|
|
|
|
return ungetc(c, conf->u.file);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static long config_file_ftell(struct config_source *conf)
|
|
|
|
|
{
|
|
|
|
|
return ftell(conf->u.file);
|
|
|
|
|
}
|
|
|
|
|
|
2013-07-12 06:46:47 +08:00
|
|
|
|
|
|
|
|
static int config_buf_fgetc(struct config_source *conf)
|
|
|
|
|
{
|
|
|
|
|
if (conf->u.buf.pos < conf->u.buf.len)
|
|
|
|
|
return conf->u.buf.buf[conf->u.buf.pos++];
|
|
|
|
|
|
|
|
|
|
return EOF;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int config_buf_ungetc(int c, struct config_source *conf)
|
|
|
|
|
{
|
config_buf_ungetc: warn when pushing back a random character
Our config code simulates a stdio stream around a buffer,
but our fake ungetc() does not behave quite like the real
one. In particular, we only rewind the position by one
character, but do _not_ actually put the character from the
caller into position.
It turns out that this does not matter, because we only ever
push back the character we just read. In other words, such
an assignment would be a noop. But because the function is
called ungetc, and because it takes a character parameter,
it is a mistake waiting to happen.
Actually assigning the character into the buffer would be
ideal, but our pointer is actually a "const" copy of the
buffer. We do not know who the real owner of the buffer is
in this code, and would not want to munge their contents.
Instead, we can simply add an assertion that matches what
the current caller does, and will let us know if new callers
are added that violate the contract.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-02-06 05:00:24 +08:00
|
|
|
if (conf->u.buf.pos > 0) {
|
|
|
|
|
conf->u.buf.pos--;
|
|
|
|
|
if (conf->u.buf.buf[conf->u.buf.pos] != c)
|
2018-05-02 17:38:39 +08:00
|
|
|
BUG("config_buf can only ungetc the same character");
|
config_buf_ungetc: warn when pushing back a random character
Our config code simulates a stdio stream around a buffer,
but our fake ungetc() does not behave quite like the real
one. In particular, we only rewind the position by one
character, but do _not_ actually put the character from the
caller into position.
It turns out that this does not matter, because we only ever
push back the character we just read. In other words, such
an assignment would be a noop. But because the function is
called ungetc, and because it takes a character parameter,
it is a mistake waiting to happen.
Actually assigning the character into the buffer would be
ideal, but our pointer is actually a "const" copy of the
buffer. We do not know who the real owner of the buffer is
in this code, and would not want to munge their contents.
Instead, we can simply add an assertion that matches what
the current caller does, and will let us know if new callers
are added that violate the contract.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-02-06 05:00:24 +08:00
|
|
|
return c;
|
|
|
|
|
}
|
2013-07-12 06:46:47 +08:00
|
|
|
|
|
|
|
|
return EOF;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static long config_buf_ftell(struct config_source *conf)
|
|
|
|
|
{
|
|
|
|
|
return conf->u.buf.pos;
|
|
|
|
|
}
|
|
|
|
|
|
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 17:54:04 +08:00
|
|
|
#define MAX_INCLUDE_DEPTH 10
|
2018-07-21 15:49:27 +08:00
|
|
|
static const char include_depth_advice[] = N_(
|
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 17:54:04 +08:00
|
|
|
"exceeded maximum include depth (%d) while including\n"
|
|
|
|
|
" %s\n"
|
|
|
|
|
"from\n"
|
|
|
|
|
" %s\n"
|
2018-08-24 05:00:56 +08:00
|
|
|
"This might be due to circular includes.");
|
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 17:54:04 +08:00
|
|
|
static int handle_path_include(const char *path, struct config_include_data *inc)
|
|
|
|
|
{
|
|
|
|
|
int ret = 0;
|
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
2014-01-28 09:37:30 +08:00
|
|
|
char *expanded;
|
2012-04-25 20:00:36 +08:00
|
|
|
|
2014-01-28 09:37:30 +08:00
|
|
|
if (!path)
|
|
|
|
|
return config_error_nonbool("include.path");
|
|
|
|
|
|
2017-04-05 18:24:38 +08:00
|
|
|
expanded = expand_user_path(path, 0);
|
2012-04-25 20:00:36 +08:00
|
|
|
if (!expanded)
|
2018-07-21 15:49:27 +08:00
|
|
|
return error(_("could not expand include path '%s'"), path);
|
2012-04-25 20:00:36 +08:00
|
|
|
path = expanded;
|
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 17:54:04 +08:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Use an absolute path as-is, but interpret relative paths
|
|
|
|
|
* based on the including config file.
|
|
|
|
|
*/
|
|
|
|
|
if (!is_absolute_path(path)) {
|
|
|
|
|
char *slash;
|
|
|
|
|
|
2014-02-19 06:58:52 +08:00
|
|
|
if (!cf || !cf->path)
|
2018-07-21 15:49:27 +08:00
|
|
|
return error(_("relative config includes must come from files"));
|
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 17:54:04 +08:00
|
|
|
|
2014-02-19 06:58:52 +08:00
|
|
|
slash = find_last_dir_sep(cf->path);
|
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 17:54:04 +08:00
|
|
|
if (slash)
|
2014-02-19 06:58:52 +08:00
|
|
|
strbuf_add(&buf, cf->path, slash - cf->path + 1);
|
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 17:54:04 +08:00
|
|
|
strbuf_addstr(&buf, path);
|
|
|
|
|
path = buf.buf;
|
|
|
|
|
}
|
|
|
|
|
|
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-13 05:03:18 +08:00
|
|
|
if (!access_or_die(path, R_OK, 0)) {
|
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 17:54:04 +08:00
|
|
|
if (++inc->depth > MAX_INCLUDE_DEPTH)
|
2018-07-21 15:49:27 +08:00
|
|
|
die(_(include_depth_advice), MAX_INCLUDE_DEPTH, path,
|
2016-05-19 06:41:08 +08:00
|
|
|
!cf ? "<unknown>" :
|
|
|
|
|
cf->name ? cf->name :
|
|
|
|
|
"the command line");
|
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 17:54:04 +08:00
|
|
|
ret = git_config_from_file(git_config_include, path, inc);
|
|
|
|
|
inc->depth--;
|
|
|
|
|
}
|
|
|
|
|
strbuf_release(&buf);
|
2012-04-25 20:00:36 +08:00
|
|
|
free(expanded);
|
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 17:54:04 +08:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2019-06-06 05:21:59 +08:00
|
|
|
static void add_trailing_starstar_for_dir(struct strbuf *pat)
|
|
|
|
|
{
|
|
|
|
|
if (pat->len && is_dir_sep(pat->buf[pat->len - 1]))
|
|
|
|
|
strbuf_addstr(pat, "**");
|
|
|
|
|
}
|
|
|
|
|
|
config: add conditional include
Sometimes a set of repositories want to share configuration settings
among themselves that are distinct from other such sets of repositories.
A user may work on two projects, each of which have multiple
repositories, and use one user.email for one project while using another
for the other.
Setting $GIT_DIR/.config works, but if the penalty of forgetting to
update $GIT_DIR/.config is high (especially when you end up cloning
often), it may not be the best way to go. Having the settings in
~/.gitconfig, which would work for just one set of repositories, would
not well in such a situation. Having separate ${HOME}s may add more
problems than it solves.
Extend the include.path mechanism that lets a config file include
another config file, so that the inclusion can be done only when some
conditions hold. Then ~/.gitconfig can say "include config-project-A
only when working on project-A" for each project A the user works on.
In this patch, the only supported grouping is based on $GIT_DIR (in
absolute path), so you would need to group repositories by directory, or
something like that to take advantage of it.
We already have include.path for unconditional includes. This patch goes
with includeIf.<condition>.path to make it clearer that a condition is
required. The new config has the same backward compatibility approach as
include.path: older git versions that don't understand includeIf will
simply ignore them.
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-01 19:26:31 +08:00
|
|
|
static int prepare_include_condition_pattern(struct strbuf *pat)
|
|
|
|
|
{
|
|
|
|
|
struct strbuf path = STRBUF_INIT;
|
|
|
|
|
char *expanded;
|
|
|
|
|
int prefix = 0;
|
|
|
|
|
|
2017-04-05 18:24:39 +08:00
|
|
|
expanded = expand_user_path(pat->buf, 1);
|
config: add conditional include
Sometimes a set of repositories want to share configuration settings
among themselves that are distinct from other such sets of repositories.
A user may work on two projects, each of which have multiple
repositories, and use one user.email for one project while using another
for the other.
Setting $GIT_DIR/.config works, but if the penalty of forgetting to
update $GIT_DIR/.config is high (especially when you end up cloning
often), it may not be the best way to go. Having the settings in
~/.gitconfig, which would work for just one set of repositories, would
not well in such a situation. Having separate ${HOME}s may add more
problems than it solves.
Extend the include.path mechanism that lets a config file include
another config file, so that the inclusion can be done only when some
conditions hold. Then ~/.gitconfig can say "include config-project-A
only when working on project-A" for each project A the user works on.
In this patch, the only supported grouping is based on $GIT_DIR (in
absolute path), so you would need to group repositories by directory, or
something like that to take advantage of it.
We already have include.path for unconditional includes. This patch goes
with includeIf.<condition>.path to make it clearer that a condition is
required. The new config has the same backward compatibility approach as
include.path: older git versions that don't understand includeIf will
simply ignore them.
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-01 19:26:31 +08:00
|
|
|
if (expanded) {
|
|
|
|
|
strbuf_reset(pat);
|
|
|
|
|
strbuf_addstr(pat, expanded);
|
|
|
|
|
free(expanded);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (pat->buf[0] == '.' && is_dir_sep(pat->buf[1])) {
|
|
|
|
|
const char *slash;
|
|
|
|
|
|
|
|
|
|
if (!cf || !cf->path)
|
|
|
|
|
return error(_("relative config include "
|
|
|
|
|
"conditionals must come from files"));
|
|
|
|
|
|
2017-04-05 18:24:39 +08:00
|
|
|
strbuf_realpath(&path, cf->path, 1);
|
config: add conditional include
Sometimes a set of repositories want to share configuration settings
among themselves that are distinct from other such sets of repositories.
A user may work on two projects, each of which have multiple
repositories, and use one user.email for one project while using another
for the other.
Setting $GIT_DIR/.config works, but if the penalty of forgetting to
update $GIT_DIR/.config is high (especially when you end up cloning
often), it may not be the best way to go. Having the settings in
~/.gitconfig, which would work for just one set of repositories, would
not well in such a situation. Having separate ${HOME}s may add more
problems than it solves.
Extend the include.path mechanism that lets a config file include
another config file, so that the inclusion can be done only when some
conditions hold. Then ~/.gitconfig can say "include config-project-A
only when working on project-A" for each project A the user works on.
In this patch, the only supported grouping is based on $GIT_DIR (in
absolute path), so you would need to group repositories by directory, or
something like that to take advantage of it.
We already have include.path for unconditional includes. This patch goes
with includeIf.<condition>.path to make it clearer that a condition is
required. The new config has the same backward compatibility approach as
include.path: older git versions that don't understand includeIf will
simply ignore them.
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-01 19:26:31 +08:00
|
|
|
slash = find_last_dir_sep(path.buf);
|
|
|
|
|
if (!slash)
|
2018-05-02 17:38:39 +08:00
|
|
|
BUG("how is this possible?");
|
config: add conditional include
Sometimes a set of repositories want to share configuration settings
among themselves that are distinct from other such sets of repositories.
A user may work on two projects, each of which have multiple
repositories, and use one user.email for one project while using another
for the other.
Setting $GIT_DIR/.config works, but if the penalty of forgetting to
update $GIT_DIR/.config is high (especially when you end up cloning
often), it may not be the best way to go. Having the settings in
~/.gitconfig, which would work for just one set of repositories, would
not well in such a situation. Having separate ${HOME}s may add more
problems than it solves.
Extend the include.path mechanism that lets a config file include
another config file, so that the inclusion can be done only when some
conditions hold. Then ~/.gitconfig can say "include config-project-A
only when working on project-A" for each project A the user works on.
In this patch, the only supported grouping is based on $GIT_DIR (in
absolute path), so you would need to group repositories by directory, or
something like that to take advantage of it.
We already have include.path for unconditional includes. This patch goes
with includeIf.<condition>.path to make it clearer that a condition is
required. The new config has the same backward compatibility approach as
include.path: older git versions that don't understand includeIf will
simply ignore them.
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-01 19:26:31 +08:00
|
|
|
strbuf_splice(pat, 0, 1, path.buf, slash - path.buf);
|
|
|
|
|
prefix = slash - path.buf + 1 /* slash */;
|
|
|
|
|
} else if (!is_absolute_path(pat->buf))
|
|
|
|
|
strbuf_insert(pat, 0, "**/", 3);
|
|
|
|
|
|
2019-06-06 05:21:59 +08:00
|
|
|
add_trailing_starstar_for_dir(pat);
|
config: add conditional include
Sometimes a set of repositories want to share configuration settings
among themselves that are distinct from other such sets of repositories.
A user may work on two projects, each of which have multiple
repositories, and use one user.email for one project while using another
for the other.
Setting $GIT_DIR/.config works, but if the penalty of forgetting to
update $GIT_DIR/.config is high (especially when you end up cloning
often), it may not be the best way to go. Having the settings in
~/.gitconfig, which would work for just one set of repositories, would
not well in such a situation. Having separate ${HOME}s may add more
problems than it solves.
Extend the include.path mechanism that lets a config file include
another config file, so that the inclusion can be done only when some
conditions hold. Then ~/.gitconfig can say "include config-project-A
only when working on project-A" for each project A the user works on.
In this patch, the only supported grouping is based on $GIT_DIR (in
absolute path), so you would need to group repositories by directory, or
something like that to take advantage of it.
We already have include.path for unconditional includes. This patch goes
with includeIf.<condition>.path to make it clearer that a condition is
required. The new config has the same backward compatibility approach as
include.path: older git versions that don't understand includeIf will
simply ignore them.
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-01 19:26:31 +08:00
|
|
|
|
|
|
|
|
strbuf_release(&path);
|
|
|
|
|
return prefix;
|
|
|
|
|
}
|
|
|
|
|
|
2017-04-17 18:10:01 +08:00
|
|
|
static int include_by_gitdir(const struct config_options *opts,
|
|
|
|
|
const char *cond, size_t cond_len, int icase)
|
config: add conditional include
Sometimes a set of repositories want to share configuration settings
among themselves that are distinct from other such sets of repositories.
A user may work on two projects, each of which have multiple
repositories, and use one user.email for one project while using another
for the other.
Setting $GIT_DIR/.config works, but if the penalty of forgetting to
update $GIT_DIR/.config is high (especially when you end up cloning
often), it may not be the best way to go. Having the settings in
~/.gitconfig, which would work for just one set of repositories, would
not well in such a situation. Having separate ${HOME}s may add more
problems than it solves.
Extend the include.path mechanism that lets a config file include
another config file, so that the inclusion can be done only when some
conditions hold. Then ~/.gitconfig can say "include config-project-A
only when working on project-A" for each project A the user works on.
In this patch, the only supported grouping is based on $GIT_DIR (in
absolute path), so you would need to group repositories by directory, or
something like that to take advantage of it.
We already have include.path for unconditional includes. This patch goes
with includeIf.<condition>.path to make it clearer that a condition is
required. The new config has the same backward compatibility approach as
include.path: older git versions that don't understand includeIf will
simply ignore them.
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-01 19:26:31 +08:00
|
|
|
{
|
|
|
|
|
struct strbuf text = STRBUF_INIT;
|
|
|
|
|
struct strbuf pattern = STRBUF_INIT;
|
|
|
|
|
int ret = 0, prefix;
|
2017-04-17 18:10:01 +08:00
|
|
|
const char *git_dir;
|
2017-05-16 16:28:46 +08:00
|
|
|
int already_tried_absolute = 0;
|
config: add conditional include
Sometimes a set of repositories want to share configuration settings
among themselves that are distinct from other such sets of repositories.
A user may work on two projects, each of which have multiple
repositories, and use one user.email for one project while using another
for the other.
Setting $GIT_DIR/.config works, but if the penalty of forgetting to
update $GIT_DIR/.config is high (especially when you end up cloning
often), it may not be the best way to go. Having the settings in
~/.gitconfig, which would work for just one set of repositories, would
not well in such a situation. Having separate ${HOME}s may add more
problems than it solves.
Extend the include.path mechanism that lets a config file include
another config file, so that the inclusion can be done only when some
conditions hold. Then ~/.gitconfig can say "include config-project-A
only when working on project-A" for each project A the user works on.
In this patch, the only supported grouping is based on $GIT_DIR (in
absolute path), so you would need to group repositories by directory, or
something like that to take advantage of it.
We already have include.path for unconditional includes. This patch goes
with includeIf.<condition>.path to make it clearer that a condition is
required. The new config has the same backward compatibility approach as
include.path: older git versions that don't understand includeIf will
simply ignore them.
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-01 19:26:31 +08:00
|
|
|
|
2017-04-17 18:10:01 +08:00
|
|
|
if (opts->git_dir)
|
|
|
|
|
git_dir = opts->git_dir;
|
|
|
|
|
else
|
|
|
|
|
goto done;
|
|
|
|
|
|
2017-04-26 14:39:05 +08:00
|
|
|
strbuf_realpath(&text, git_dir, 1);
|
config: add conditional include
Sometimes a set of repositories want to share configuration settings
among themselves that are distinct from other such sets of repositories.
A user may work on two projects, each of which have multiple
repositories, and use one user.email for one project while using another
for the other.
Setting $GIT_DIR/.config works, but if the penalty of forgetting to
update $GIT_DIR/.config is high (especially when you end up cloning
often), it may not be the best way to go. Having the settings in
~/.gitconfig, which would work for just one set of repositories, would
not well in such a situation. Having separate ${HOME}s may add more
problems than it solves.
Extend the include.path mechanism that lets a config file include
another config file, so that the inclusion can be done only when some
conditions hold. Then ~/.gitconfig can say "include config-project-A
only when working on project-A" for each project A the user works on.
In this patch, the only supported grouping is based on $GIT_DIR (in
absolute path), so you would need to group repositories by directory, or
something like that to take advantage of it.
We already have include.path for unconditional includes. This patch goes
with includeIf.<condition>.path to make it clearer that a condition is
required. The new config has the same backward compatibility approach as
include.path: older git versions that don't understand includeIf will
simply ignore them.
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-01 19:26:31 +08:00
|
|
|
strbuf_add(&pattern, cond, cond_len);
|
|
|
|
|
prefix = prepare_include_condition_pattern(&pattern);
|
|
|
|
|
|
2017-05-16 16:28:46 +08:00
|
|
|
again:
|
config: add conditional include
Sometimes a set of repositories want to share configuration settings
among themselves that are distinct from other such sets of repositories.
A user may work on two projects, each of which have multiple
repositories, and use one user.email for one project while using another
for the other.
Setting $GIT_DIR/.config works, but if the penalty of forgetting to
update $GIT_DIR/.config is high (especially when you end up cloning
often), it may not be the best way to go. Having the settings in
~/.gitconfig, which would work for just one set of repositories, would
not well in such a situation. Having separate ${HOME}s may add more
problems than it solves.
Extend the include.path mechanism that lets a config file include
another config file, so that the inclusion can be done only when some
conditions hold. Then ~/.gitconfig can say "include config-project-A
only when working on project-A" for each project A the user works on.
In this patch, the only supported grouping is based on $GIT_DIR (in
absolute path), so you would need to group repositories by directory, or
something like that to take advantage of it.
We already have include.path for unconditional includes. This patch goes
with includeIf.<condition>.path to make it clearer that a condition is
required. The new config has the same backward compatibility approach as
include.path: older git versions that don't understand includeIf will
simply ignore them.
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-01 19:26:31 +08:00
|
|
|
if (prefix < 0)
|
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
|
|
if (prefix > 0) {
|
|
|
|
|
/*
|
|
|
|
|
* perform literal matching on the prefix part so that
|
|
|
|
|
* any wildcard character in it can't create side effects.
|
|
|
|
|
*/
|
|
|
|
|
if (text.len < prefix)
|
|
|
|
|
goto done;
|
|
|
|
|
if (!icase && strncmp(pattern.buf, text.buf, prefix))
|
|
|
|
|
goto done;
|
|
|
|
|
if (icase && strncasecmp(pattern.buf, text.buf, prefix))
|
|
|
|
|
goto done;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ret = !wildmatch(pattern.buf + prefix, text.buf + prefix,
|
2019-03-26 17:41:01 +08:00
|
|
|
WM_PATHNAME | (icase ? WM_CASEFOLD : 0));
|
config: add conditional include
Sometimes a set of repositories want to share configuration settings
among themselves that are distinct from other such sets of repositories.
A user may work on two projects, each of which have multiple
repositories, and use one user.email for one project while using another
for the other.
Setting $GIT_DIR/.config works, but if the penalty of forgetting to
update $GIT_DIR/.config is high (especially when you end up cloning
often), it may not be the best way to go. Having the settings in
~/.gitconfig, which would work for just one set of repositories, would
not well in such a situation. Having separate ${HOME}s may add more
problems than it solves.
Extend the include.path mechanism that lets a config file include
another config file, so that the inclusion can be done only when some
conditions hold. Then ~/.gitconfig can say "include config-project-A
only when working on project-A" for each project A the user works on.
In this patch, the only supported grouping is based on $GIT_DIR (in
absolute path), so you would need to group repositories by directory, or
something like that to take advantage of it.
We already have include.path for unconditional includes. This patch goes
with includeIf.<condition>.path to make it clearer that a condition is
required. The new config has the same backward compatibility approach as
include.path: older git versions that don't understand includeIf will
simply ignore them.
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-01 19:26:31 +08:00
|
|
|
|
2017-05-16 16:28:46 +08:00
|
|
|
if (!ret && !already_tried_absolute) {
|
|
|
|
|
/*
|
|
|
|
|
* We've tried e.g. matching gitdir:~/work, but if
|
|
|
|
|
* ~/work is a symlink to /mnt/storage/work
|
|
|
|
|
* strbuf_realpath() will expand it, so the rule won't
|
|
|
|
|
* match. Let's match against a
|
|
|
|
|
* strbuf_add_absolute_path() version of the path,
|
|
|
|
|
* which'll do the right thing
|
|
|
|
|
*/
|
|
|
|
|
strbuf_reset(&text);
|
|
|
|
|
strbuf_add_absolute_path(&text, git_dir);
|
|
|
|
|
already_tried_absolute = 1;
|
|
|
|
|
goto again;
|
|
|
|
|
}
|
config: add conditional include
Sometimes a set of repositories want to share configuration settings
among themselves that are distinct from other such sets of repositories.
A user may work on two projects, each of which have multiple
repositories, and use one user.email for one project while using another
for the other.
Setting $GIT_DIR/.config works, but if the penalty of forgetting to
update $GIT_DIR/.config is high (especially when you end up cloning
often), it may not be the best way to go. Having the settings in
~/.gitconfig, which would work for just one set of repositories, would
not well in such a situation. Having separate ${HOME}s may add more
problems than it solves.
Extend the include.path mechanism that lets a config file include
another config file, so that the inclusion can be done only when some
conditions hold. Then ~/.gitconfig can say "include config-project-A
only when working on project-A" for each project A the user works on.
In this patch, the only supported grouping is based on $GIT_DIR (in
absolute path), so you would need to group repositories by directory, or
something like that to take advantage of it.
We already have include.path for unconditional includes. This patch goes
with includeIf.<condition>.path to make it clearer that a condition is
required. The new config has the same backward compatibility approach as
include.path: older git versions that don't understand includeIf will
simply ignore them.
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-01 19:26:31 +08:00
|
|
|
done:
|
|
|
|
|
strbuf_release(&pattern);
|
|
|
|
|
strbuf_release(&text);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2019-06-06 05:21:59 +08:00
|
|
|
static int include_by_branch(const char *cond, size_t cond_len)
|
|
|
|
|
{
|
|
|
|
|
int flags;
|
|
|
|
|
int ret;
|
|
|
|
|
struct strbuf pattern = STRBUF_INIT;
|
2019-08-06 20:27:58 +08:00
|
|
|
const char *refname = !the_repository->gitdir ?
|
config: work around bug with includeif:onbranch and early config
Since 07b2c0eacac (config: learn the "onbranch:" includeIf condition,
2019-06-05), there is a potential catch-22 in the early config path: if
the `include.onbranch:` feature is used, Git assumes that the Git
directory has been initialized already. However, in the early config
code path that is not true.
One way to trigger this is to call the following commands in any
repository:
git config includeif.onbranch:refs/heads/master.path broken
git help -a
The symptom triggered by the `git help -a` invocation reads like this:
BUG: refs.c:1851: attempting to get main_ref_store outside of repository
Let's work around this, simply by ignoring the `includeif.onbranch:`
setting when parsing the config when the ref store has not been
initialized (yet).
Technically, there is a way to solve this properly: teach the refs
machinery to initialize the ref_store from a given gitdir/commondir pair
(which we _do_ have in the early config code path), and then use that in
`include_by_branch()`. This, however, is a pretty involved project, and
we're already in the feature freeze for Git v2.23.0.
Note: when calling above-mentioned two commands _outside_ of any Git
worktree (passing the `--global` flag to `git config`, as there is
obviously no repository config available), at the point when
`include_by_branch()` is called, `the_repository` is `NULL`, therefore
we have to be extra careful not to dereference it in that case.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-08-01 04:06:42 +08:00
|
|
|
NULL : resolve_ref_unsafe("HEAD", 0, NULL, &flags);
|
2019-06-06 05:21:59 +08:00
|
|
|
const char *shortname;
|
|
|
|
|
|
|
|
|
|
if (!refname || !(flags & REF_ISSYMREF) ||
|
|
|
|
|
!skip_prefix(refname, "refs/heads/", &shortname))
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
strbuf_add(&pattern, cond, cond_len);
|
|
|
|
|
add_trailing_starstar_for_dir(&pattern);
|
|
|
|
|
ret = !wildmatch(pattern.buf, shortname, WM_PATHNAME);
|
|
|
|
|
strbuf_release(&pattern);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2017-04-17 18:10:01 +08:00
|
|
|
static int include_condition_is_true(const struct config_options *opts,
|
|
|
|
|
const char *cond, size_t cond_len)
|
config: add conditional include
Sometimes a set of repositories want to share configuration settings
among themselves that are distinct from other such sets of repositories.
A user may work on two projects, each of which have multiple
repositories, and use one user.email for one project while using another
for the other.
Setting $GIT_DIR/.config works, but if the penalty of forgetting to
update $GIT_DIR/.config is high (especially when you end up cloning
often), it may not be the best way to go. Having the settings in
~/.gitconfig, which would work for just one set of repositories, would
not well in such a situation. Having separate ${HOME}s may add more
problems than it solves.
Extend the include.path mechanism that lets a config file include
another config file, so that the inclusion can be done only when some
conditions hold. Then ~/.gitconfig can say "include config-project-A
only when working on project-A" for each project A the user works on.
In this patch, the only supported grouping is based on $GIT_DIR (in
absolute path), so you would need to group repositories by directory, or
something like that to take advantage of it.
We already have include.path for unconditional includes. This patch goes
with includeIf.<condition>.path to make it clearer that a condition is
required. The new config has the same backward compatibility approach as
include.path: older git versions that don't understand includeIf will
simply ignore them.
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-01 19:26:31 +08:00
|
|
|
{
|
|
|
|
|
|
|
|
|
|
if (skip_prefix_mem(cond, cond_len, "gitdir:", &cond, &cond_len))
|
2017-04-17 18:10:01 +08:00
|
|
|
return include_by_gitdir(opts, cond, cond_len, 0);
|
config: add conditional include
Sometimes a set of repositories want to share configuration settings
among themselves that are distinct from other such sets of repositories.
A user may work on two projects, each of which have multiple
repositories, and use one user.email for one project while using another
for the other.
Setting $GIT_DIR/.config works, but if the penalty of forgetting to
update $GIT_DIR/.config is high (especially when you end up cloning
often), it may not be the best way to go. Having the settings in
~/.gitconfig, which would work for just one set of repositories, would
not well in such a situation. Having separate ${HOME}s may add more
problems than it solves.
Extend the include.path mechanism that lets a config file include
another config file, so that the inclusion can be done only when some
conditions hold. Then ~/.gitconfig can say "include config-project-A
only when working on project-A" for each project A the user works on.
In this patch, the only supported grouping is based on $GIT_DIR (in
absolute path), so you would need to group repositories by directory, or
something like that to take advantage of it.
We already have include.path for unconditional includes. This patch goes
with includeIf.<condition>.path to make it clearer that a condition is
required. The new config has the same backward compatibility approach as
include.path: older git versions that don't understand includeIf will
simply ignore them.
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-01 19:26:31 +08:00
|
|
|
else if (skip_prefix_mem(cond, cond_len, "gitdir/i:", &cond, &cond_len))
|
2017-04-17 18:10:01 +08:00
|
|
|
return include_by_gitdir(opts, cond, cond_len, 1);
|
2019-06-06 05:21:59 +08:00
|
|
|
else if (skip_prefix_mem(cond, cond_len, "onbranch:", &cond, &cond_len))
|
|
|
|
|
return include_by_branch(cond, cond_len);
|
config: add conditional include
Sometimes a set of repositories want to share configuration settings
among themselves that are distinct from other such sets of repositories.
A user may work on two projects, each of which have multiple
repositories, and use one user.email for one project while using another
for the other.
Setting $GIT_DIR/.config works, but if the penalty of forgetting to
update $GIT_DIR/.config is high (especially when you end up cloning
often), it may not be the best way to go. Having the settings in
~/.gitconfig, which would work for just one set of repositories, would
not well in such a situation. Having separate ${HOME}s may add more
problems than it solves.
Extend the include.path mechanism that lets a config file include
another config file, so that the inclusion can be done only when some
conditions hold. Then ~/.gitconfig can say "include config-project-A
only when working on project-A" for each project A the user works on.
In this patch, the only supported grouping is based on $GIT_DIR (in
absolute path), so you would need to group repositories by directory, or
something like that to take advantage of it.
We already have include.path for unconditional includes. This patch goes
with includeIf.<condition>.path to make it clearer that a condition is
required. The new config has the same backward compatibility approach as
include.path: older git versions that don't understand includeIf will
simply ignore them.
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-01 19:26:31 +08:00
|
|
|
|
|
|
|
|
/* unknown conditionals are always false */
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
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 17:54:04 +08:00
|
|
|
int git_config_include(const char *var, const char *value, void *data)
|
|
|
|
|
{
|
|
|
|
|
struct config_include_data *inc = data;
|
config: add conditional include
Sometimes a set of repositories want to share configuration settings
among themselves that are distinct from other such sets of repositories.
A user may work on two projects, each of which have multiple
repositories, and use one user.email for one project while using another
for the other.
Setting $GIT_DIR/.config works, but if the penalty of forgetting to
update $GIT_DIR/.config is high (especially when you end up cloning
often), it may not be the best way to go. Having the settings in
~/.gitconfig, which would work for just one set of repositories, would
not well in such a situation. Having separate ${HOME}s may add more
problems than it solves.
Extend the include.path mechanism that lets a config file include
another config file, so that the inclusion can be done only when some
conditions hold. Then ~/.gitconfig can say "include config-project-A
only when working on project-A" for each project A the user works on.
In this patch, the only supported grouping is based on $GIT_DIR (in
absolute path), so you would need to group repositories by directory, or
something like that to take advantage of it.
We already have include.path for unconditional includes. This patch goes
with includeIf.<condition>.path to make it clearer that a condition is
required. The new config has the same backward compatibility approach as
include.path: older git versions that don't understand includeIf will
simply ignore them.
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-01 19:26:31 +08:00
|
|
|
const char *cond, *key;
|
|
|
|
|
int cond_len;
|
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 17:54:04 +08:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Pass along all values, including "include" directives; this makes it
|
|
|
|
|
* possible to query information on the includes themselves.
|
|
|
|
|
*/
|
|
|
|
|
ret = inc->fn(var, value, inc->data);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
return ret;
|
|
|
|
|
|
2014-08-31 00:07:05 +08:00
|
|
|
if (!strcmp(var, "include.path"))
|
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 17:54:04 +08:00
|
|
|
ret = handle_path_include(value, inc);
|
config: add conditional include
Sometimes a set of repositories want to share configuration settings
among themselves that are distinct from other such sets of repositories.
A user may work on two projects, each of which have multiple
repositories, and use one user.email for one project while using another
for the other.
Setting $GIT_DIR/.config works, but if the penalty of forgetting to
update $GIT_DIR/.config is high (especially when you end up cloning
often), it may not be the best way to go. Having the settings in
~/.gitconfig, which would work for just one set of repositories, would
not well in such a situation. Having separate ${HOME}s may add more
problems than it solves.
Extend the include.path mechanism that lets a config file include
another config file, so that the inclusion can be done only when some
conditions hold. Then ~/.gitconfig can say "include config-project-A
only when working on project-A" for each project A the user works on.
In this patch, the only supported grouping is based on $GIT_DIR (in
absolute path), so you would need to group repositories by directory, or
something like that to take advantage of it.
We already have include.path for unconditional includes. This patch goes
with includeIf.<condition>.path to make it clearer that a condition is
required. The new config has the same backward compatibility approach as
include.path: older git versions that don't understand includeIf will
simply ignore them.
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-01 19:26:31 +08:00
|
|
|
|
|
|
|
|
if (!parse_config_key(var, "includeif", &cond, &cond_len, &key) &&
|
2017-04-17 18:10:01 +08:00
|
|
|
(cond && include_condition_is_true(inc->opts, cond, cond_len)) &&
|
config: add conditional include
Sometimes a set of repositories want to share configuration settings
among themselves that are distinct from other such sets of repositories.
A user may work on two projects, each of which have multiple
repositories, and use one user.email for one project while using another
for the other.
Setting $GIT_DIR/.config works, but if the penalty of forgetting to
update $GIT_DIR/.config is high (especially when you end up cloning
often), it may not be the best way to go. Having the settings in
~/.gitconfig, which would work for just one set of repositories, would
not well in such a situation. Having separate ${HOME}s may add more
problems than it solves.
Extend the include.path mechanism that lets a config file include
another config file, so that the inclusion can be done only when some
conditions hold. Then ~/.gitconfig can say "include config-project-A
only when working on project-A" for each project A the user works on.
In this patch, the only supported grouping is based on $GIT_DIR (in
absolute path), so you would need to group repositories by directory, or
something like that to take advantage of it.
We already have include.path for unconditional includes. This patch goes
with includeIf.<condition>.path to make it clearer that a condition is
required. The new config has the same backward compatibility approach as
include.path: older git versions that don't understand includeIf will
simply ignore them.
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-01 19:26:31 +08:00
|
|
|
!strcmp(key, "path"))
|
|
|
|
|
ret = handle_path_include(value, inc);
|
|
|
|
|
|
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 17:54:04 +08:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2010-08-24 03:16:00 +08:00
|
|
|
void git_config_push_parameter(const char *text)
|
|
|
|
|
{
|
|
|
|
|
struct strbuf env = STRBUF_INIT;
|
|
|
|
|
const char *old = getenv(CONFIG_DATA_ENVIRONMENT);
|
git_config_push_parameter: handle empty GIT_CONFIG_PARAMETERS
The "git -c var=value" option stuffs the config value into
$GIT_CONFIG_PARAMETERS, so that sub-processes can see it.
When the config is later read via git_config() or similar,
we parse it back out of that variable. The parsing end is a
little bit picky; it assumes that each entry was generated
with sq_quote_buf(), and that there is no extraneous
whitespace.
On the generating end, we are careful to append to an
existing $GIT_CONFIG_PARAMETERS variable if it exists.
However, our test for "should we add a space separator" is
too liberal: it will add one even if the environment
variable exists but is empty. As a result, you might end up
with:
GIT_CONFIG_PARAMETERS=" 'core.foo=bar'"
which the parser will choke on.
This was hard to trigger in older versions of git, since we
only set the variable when we had something to put into it
(though you could certainly trigger it manually). But since
14111fc (git: submodule honor -c credential.* from command
line, 2016-02-29), the submodule code will unconditionally
put the $GIT_CONFIG_PARAMETERS variable into the environment
of any operation in the submodule, whether it is empty or
not. So any of those operations which themselves use "git
-c" will generate the unparseable value and fail.
We can easily fix it by catching this case on the generating
side. While we're adding a test, let's also check that
multiple layers of "git -c" work, which was previously not
tested at all.
Reported-by: Shin Fan <shinfan@google.com>
Signed-off-by: Jeff King <peff@peff.net>
Reviewed-by: Jonathan Nieder <jrnieder@gmail.com>
Tested-by: Jonathan Nieder <jrnieder@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-03-23 03:50:51 +08:00
|
|
|
if (old && *old) {
|
2010-08-24 03:16:00 +08:00
|
|
|
strbuf_addstr(&env, old);
|
|
|
|
|
strbuf_addch(&env, ' ');
|
|
|
|
|
}
|
|
|
|
|
sq_quote_buf(&env, text);
|
|
|
|
|
setenv(CONFIG_DATA_ENVIRONMENT, env.buf, 1);
|
|
|
|
|
strbuf_release(&env);
|
|
|
|
|
}
|
|
|
|
|
|
2017-02-24 06:44:07 +08:00
|
|
|
static inline int iskeychar(int c)
|
|
|
|
|
{
|
|
|
|
|
return isalnum(c) || c == '-';
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Auxiliary function to sanity-check and split the key into the section
|
|
|
|
|
* identifier and variable name.
|
|
|
|
|
*
|
|
|
|
|
* Returns 0 on success, -1 when there is an invalid character in the key and
|
|
|
|
|
* -2 if there is no section name in the key.
|
|
|
|
|
*
|
|
|
|
|
* store_key - pointer to char* which will hold a copy of the key with
|
|
|
|
|
* lowercase section and variable name
|
|
|
|
|
* baselen - pointer to int which will hold the length of the
|
|
|
|
|
* section + subsection part, can be NULL
|
|
|
|
|
*/
|
|
|
|
|
static int git_config_parse_key_1(const char *key, char **store_key, int *baselen_, int quiet)
|
|
|
|
|
{
|
|
|
|
|
int i, dot, baselen;
|
|
|
|
|
const char *last_dot = strrchr(key, '.');
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Since "key" actually contains the section name and the real
|
|
|
|
|
* key name separated by a dot, we have to know where the dot is.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
if (last_dot == NULL || last_dot == key) {
|
|
|
|
|
if (!quiet)
|
2018-07-21 15:49:27 +08:00
|
|
|
error(_("key does not contain a section: %s"), key);
|
2017-02-24 06:44:07 +08:00
|
|
|
return -CONFIG_NO_SECTION_OR_NAME;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!last_dot[1]) {
|
|
|
|
|
if (!quiet)
|
2018-07-21 15:49:27 +08:00
|
|
|
error(_("key does not contain variable name: %s"), key);
|
2017-02-24 06:44:07 +08:00
|
|
|
return -CONFIG_NO_SECTION_OR_NAME;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
baselen = last_dot - key;
|
|
|
|
|
if (baselen_)
|
|
|
|
|
*baselen_ = baselen;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Validate the key and while at it, lower case it for matching.
|
|
|
|
|
*/
|
|
|
|
|
if (store_key)
|
|
|
|
|
*store_key = xmallocz(strlen(key));
|
|
|
|
|
|
|
|
|
|
dot = 0;
|
|
|
|
|
for (i = 0; key[i]; i++) {
|
|
|
|
|
unsigned char c = key[i];
|
|
|
|
|
if (c == '.')
|
|
|
|
|
dot = 1;
|
|
|
|
|
/* Leave the extended basename untouched.. */
|
|
|
|
|
if (!dot || i > baselen) {
|
|
|
|
|
if (!iskeychar(c) ||
|
|
|
|
|
(i == baselen + 1 && !isalpha(c))) {
|
|
|
|
|
if (!quiet)
|
2018-07-21 15:49:27 +08:00
|
|
|
error(_("invalid key: %s"), key);
|
2017-02-24 06:44:07 +08:00
|
|
|
goto out_free_ret_1;
|
|
|
|
|
}
|
|
|
|
|
c = tolower(c);
|
|
|
|
|
} else if (c == '\n') {
|
|
|
|
|
if (!quiet)
|
2018-07-21 15:49:27 +08:00
|
|
|
error(_("invalid key (newline): %s"), key);
|
2017-02-24 06:44:07 +08:00
|
|
|
goto out_free_ret_1;
|
|
|
|
|
}
|
|
|
|
|
if (store_key)
|
|
|
|
|
(*store_key)[i] = c;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
out_free_ret_1:
|
|
|
|
|
if (store_key) {
|
2017-06-16 07:15:46 +08:00
|
|
|
FREE_AND_NULL(*store_key);
|
2017-02-24 06:44:07 +08:00
|
|
|
}
|
|
|
|
|
return -CONFIG_INVALID_KEY;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int git_config_parse_key(const char *key, char **store_key, int *baselen)
|
|
|
|
|
{
|
|
|
|
|
return git_config_parse_key_1(key, store_key, baselen, 0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int git_config_key_is_valid(const char *key)
|
|
|
|
|
{
|
|
|
|
|
return !git_config_parse_key_1(key, NULL, NULL, 1);
|
|
|
|
|
}
|
|
|
|
|
|
2011-06-09 23:56:42 +08:00
|
|
|
int git_config_parse_parameter(const char *text,
|
|
|
|
|
config_fn_t fn, void *data)
|
2010-03-27 06:53:57 +08:00
|
|
|
{
|
2014-08-05 06:40:19 +08:00
|
|
|
const char *value;
|
2017-02-24 07:04:40 +08:00
|
|
|
char *canonical_name;
|
2010-03-27 06:56:01 +08:00
|
|
|
struct strbuf **pair;
|
2017-02-24 07:04:40 +08:00
|
|
|
int ret;
|
2014-08-05 06:40:19 +08:00
|
|
|
|
2011-06-09 23:55:09 +08:00
|
|
|
pair = strbuf_split_str(text, '=', 2);
|
2011-06-09 23:52:43 +08:00
|
|
|
if (!pair[0])
|
2018-07-21 15:49:27 +08:00
|
|
|
return error(_("bogus config parameter: %s"), text);
|
2014-08-05 06:40:19 +08:00
|
|
|
|
|
|
|
|
if (pair[0]->len && pair[0]->buf[pair[0]->len - 1] == '=') {
|
2010-03-27 06:56:01 +08:00
|
|
|
strbuf_setlen(pair[0], pair[0]->len - 1);
|
2014-08-05 06:40:19 +08:00
|
|
|
value = pair[1] ? pair[1]->buf : "";
|
|
|
|
|
} else {
|
|
|
|
|
value = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2010-03-27 06:56:01 +08:00
|
|
|
strbuf_trim(pair[0]);
|
|
|
|
|
if (!pair[0]->len) {
|
|
|
|
|
strbuf_list_free(pair);
|
2018-07-21 15:49:27 +08:00
|
|
|
return error(_("bogus config parameter: %s"), text);
|
2010-03-27 06:53:57 +08:00
|
|
|
}
|
2017-02-24 07:04:40 +08:00
|
|
|
|
|
|
|
|
if (git_config_parse_key(pair[0]->buf, &canonical_name, NULL)) {
|
|
|
|
|
ret = -1;
|
|
|
|
|
} else {
|
|
|
|
|
ret = (fn(canonical_name, value, data) < 0) ? -1 : 0;
|
|
|
|
|
free(canonical_name);
|
2010-03-27 06:56:01 +08:00
|
|
|
}
|
|
|
|
|
strbuf_list_free(pair);
|
2017-02-24 07:04:40 +08:00
|
|
|
return ret;
|
2010-03-27 06:53:57 +08:00
|
|
|
}
|
|
|
|
|
|
2011-05-25 06:49:55 +08:00
|
|
|
int git_config_from_parameters(config_fn_t fn, void *data)
|
|
|
|
|
{
|
2010-08-24 03:16:00 +08:00
|
|
|
const char *env = getenv(CONFIG_DATA_ENVIRONMENT);
|
2016-05-19 06:39:49 +08:00
|
|
|
int ret = 0;
|
2010-08-24 03:16:00 +08:00
|
|
|
char *envw;
|
|
|
|
|
const char **argv = NULL;
|
|
|
|
|
int nr = 0, alloc = 0;
|
|
|
|
|
int i;
|
2016-05-19 06:41:08 +08:00
|
|
|
struct config_source source;
|
2010-08-24 03:16:00 +08:00
|
|
|
|
|
|
|
|
if (!env)
|
|
|
|
|
return 0;
|
2016-05-19 06:41:08 +08:00
|
|
|
|
|
|
|
|
memset(&source, 0, sizeof(source));
|
|
|
|
|
source.prev = cf;
|
i18n: config: unfold error messages marked for translation
Introduced in 473166b ("config: add 'origin_type' to config_source
struct", 2016-02-19), Git can inform the user about the origin of a
config error, but the implementation does not allow translators to
translate the keywords 'file', 'blob, 'standard input', and
'submodule-blob'. Moreover, for the second message, a reason for the
error is appended to the message, not allowing translators to translate
that reason either.
Unfold the message into several templates for each known origin_type.
That would result in better translation at the expense of code
verbosity.
Add enum config_oringin_type to ease management of the various
configuration origin types (blob, file, etc). Previously origin type
was considered from command line if cf->origin_type == NULL, i.e.,
uninitialized. Now we set origin_type to CONFIG_ORIGIN_CMDLINE in
git_config_from_parameters() and configset_add_value().
For error message in git_parse_source(), use xstrfmt() function to
prepare the message string, instead of doing something like it's done
for die_bad_number(), because intelligibility and code conciseness are
improved for that instance.
Signed-off-by: Vasco Almeida <vascomalmeida@sapo.pt>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-07-28 21:14:03 +08:00
|
|
|
source.origin_type = CONFIG_ORIGIN_CMDLINE;
|
2016-05-19 06:41:08 +08:00
|
|
|
cf = &source;
|
|
|
|
|
|
2010-08-24 03:16:00 +08:00
|
|
|
/* sq_dequote will write over it */
|
|
|
|
|
envw = xstrdup(env);
|
|
|
|
|
|
|
|
|
|
if (sq_dequote_to_argv(envw, &argv, &nr, &alloc) < 0) {
|
2018-07-21 15:49:27 +08:00
|
|
|
ret = error(_("bogus format in %s"), CONFIG_DATA_ENVIRONMENT);
|
2016-05-19 06:39:49 +08:00
|
|
|
goto out;
|
2010-08-24 03:16:00 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < nr; i++) {
|
2011-05-25 06:49:55 +08:00
|
|
|
if (git_config_parse_parameter(argv[i], fn, data) < 0) {
|
2016-05-19 06:39:49 +08:00
|
|
|
ret = -1;
|
|
|
|
|
goto out;
|
2010-08-24 03:16:00 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2016-05-19 06:39:49 +08:00
|
|
|
out:
|
2010-08-24 03:16:00 +08:00
|
|
|
free(argv);
|
|
|
|
|
free(envw);
|
2016-05-19 06:41:08 +08:00
|
|
|
cf = source.prev;
|
2016-05-19 06:39:49 +08:00
|
|
|
return ret;
|
2010-08-24 03:16:00 +08:00
|
|
|
}
|
|
|
|
|
|
2005-10-11 07:31:08 +08:00
|
|
|
static int get_next_char(void)
|
|
|
|
|
{
|
2013-08-27 05:57:18 +08:00
|
|
|
int c = cf->do_fgetc(cf);
|
2005-10-11 07:31:08 +08:00
|
|
|
|
2013-05-11 21:19:29 +08:00
|
|
|
if (c == '\r') {
|
|
|
|
|
/* DOS like systems */
|
2013-08-27 05:57:18 +08:00
|
|
|
c = cf->do_fgetc(cf);
|
2013-05-11 21:19:29 +08:00
|
|
|
if (c != '\n') {
|
config: do not ungetc EOF
When we are parsing a config value, if we see a carriage
return, we fgetc the next character to see if it is a
line feed (in which case we silently drop the CR). If it
isn't, we then ungetc the character, and take the literal
CR.
But we never check whether we in fact got a character at
all. If the config file ends in CR, we will get EOF here,
and try to ungetc EOF. This works OK for a real stdio
stream. The ungetc returns an error, and the next fgetc will
then return EOF again.
However, our custom buffer-based stream is not so fortunate.
It happily rewinds the position of the stream by one
character, ignoring the fact that we fed it EOF. The next
fgetc call returns the final CR again, over and over, and we
end up in an infinite loop.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-02-05 14:53:28 +08:00
|
|
|
if (c != EOF)
|
|
|
|
|
cf->do_ungetc(c, cf);
|
2013-05-11 21:19:29 +08:00
|
|
|
c = '\r';
|
2005-10-11 07:31:08 +08:00
|
|
|
}
|
|
|
|
|
}
|
2013-05-11 21:19:29 +08:00
|
|
|
if (c == '\n')
|
|
|
|
|
cf->linenr++;
|
|
|
|
|
if (c == EOF) {
|
|
|
|
|
cf->eof = 1;
|
2014-08-07 19:59:13 +08:00
|
|
|
cf->linenr++;
|
2013-05-11 21:19:29 +08:00
|
|
|
c = '\n';
|
|
|
|
|
}
|
2005-10-11 07:31:08 +08:00
|
|
|
return c;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static char *parse_value(void)
|
|
|
|
|
{
|
2011-04-11 04:54:18 +08:00
|
|
|
int quote = 0, comment = 0, space = 0;
|
2005-10-11 07:31:08 +08:00
|
|
|
|
config.c: Make git_config() work correctly when called recursively
On Cygwin, this fixes a test failure in t3301-notes.sh (test 98,
"git notes copy --for-rewrite (disabled)").
The test failure is caused by a recursive call to git_config() which
has the effect of skipping to the end-of-file while processing the
"notes.rewriteref" config variable. Thus, any config variables that
appear after "notes.rewriteref" are simply ignored by git_config().
Also, we note that the original FILE handle is leaked as a result
of the recursive call.
The recursive call to git_config() is due to the "schizophrenic stat"
functions on cygwin, where one of two different implementations of
the l/stat functions is selected lazily, depending on some config
variables.
In this case, the init_copy_notes_for_rewrite() function calls
git_config() with the notes_rewrite_config() callback function.
This callback, while processing the "notes.rewriteref" variable,
in turn calls string_list_add_refs_by_glob() to process the
associated ref value. This eventually leads to a call to the
get_ref_dir() function, which in turn calls stat(). On cygwin,
the stat() macro leads to an indirect call to cygwin_stat_stub()
which, via init_stat(), then calls git_config() in order to
determine which l/stat implementation to bind to.
In order to solve this problem, we modify git_config() so that the
global state variables used by the config reading code is packaged
up and managed on a local state stack.
Signed-off-by: Ramsay Jones <ramsay@ramsay1.demon.co.uk>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-06-17 04:24:51 +08:00
|
|
|
strbuf_reset(&cf->value);
|
2005-10-11 07:31:08 +08:00
|
|
|
for (;;) {
|
|
|
|
|
int c = get_next_char();
|
|
|
|
|
if (c == '\n') {
|
2012-03-10 05:57:54 +08:00
|
|
|
if (quote) {
|
|
|
|
|
cf->linenr--;
|
2005-10-11 07:31:08 +08:00
|
|
|
return NULL;
|
2012-03-10 05:57:54 +08:00
|
|
|
}
|
config.c: Make git_config() work correctly when called recursively
On Cygwin, this fixes a test failure in t3301-notes.sh (test 98,
"git notes copy --for-rewrite (disabled)").
The test failure is caused by a recursive call to git_config() which
has the effect of skipping to the end-of-file while processing the
"notes.rewriteref" config variable. Thus, any config variables that
appear after "notes.rewriteref" are simply ignored by git_config().
Also, we note that the original FILE handle is leaked as a result
of the recursive call.
The recursive call to git_config() is due to the "schizophrenic stat"
functions on cygwin, where one of two different implementations of
the l/stat functions is selected lazily, depending on some config
variables.
In this case, the init_copy_notes_for_rewrite() function calls
git_config() with the notes_rewrite_config() callback function.
This callback, while processing the "notes.rewriteref" variable,
in turn calls string_list_add_refs_by_glob() to process the
associated ref value. This eventually leads to a call to the
get_ref_dir() function, which in turn calls stat(). On cygwin,
the stat() macro leads to an indirect call to cygwin_stat_stub()
which, via init_stat(), then calls git_config() in order to
determine which l/stat implementation to bind to.
In order to solve this problem, we modify git_config() so that the
global state variables used by the config reading code is packaged
up and managed on a local state stack.
Signed-off-by: Ramsay Jones <ramsay@ramsay1.demon.co.uk>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-06-17 04:24:51 +08:00
|
|
|
return cf->value.buf;
|
2005-10-11 07:31:08 +08:00
|
|
|
}
|
|
|
|
|
if (comment)
|
|
|
|
|
continue;
|
|
|
|
|
if (isspace(c) && !quote) {
|
config.c: Make git_config() work correctly when called recursively
On Cygwin, this fixes a test failure in t3301-notes.sh (test 98,
"git notes copy --for-rewrite (disabled)").
The test failure is caused by a recursive call to git_config() which
has the effect of skipping to the end-of-file while processing the
"notes.rewriteref" config variable. Thus, any config variables that
appear after "notes.rewriteref" are simply ignored by git_config().
Also, we note that the original FILE handle is leaked as a result
of the recursive call.
The recursive call to git_config() is due to the "schizophrenic stat"
functions on cygwin, where one of two different implementations of
the l/stat functions is selected lazily, depending on some config
variables.
In this case, the init_copy_notes_for_rewrite() function calls
git_config() with the notes_rewrite_config() callback function.
This callback, while processing the "notes.rewriteref" variable,
in turn calls string_list_add_refs_by_glob() to process the
associated ref value. This eventually leads to a call to the
get_ref_dir() function, which in turn calls stat(). On cygwin,
the stat() macro leads to an indirect call to cygwin_stat_stub()
which, via init_stat(), then calls git_config() in order to
determine which l/stat implementation to bind to.
In order to solve this problem, we modify git_config() so that the
global state variables used by the config reading code is packaged
up and managed on a local state stack.
Signed-off-by: Ramsay Jones <ramsay@ramsay1.demon.co.uk>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-06-17 04:24:51 +08:00
|
|
|
if (cf->value.len)
|
2009-07-30 19:41:57 +08:00
|
|
|
space++;
|
2005-10-11 07:31:08 +08:00
|
|
|
continue;
|
|
|
|
|
}
|
2006-05-02 22:58:37 +08:00
|
|
|
if (!quote) {
|
|
|
|
|
if (c == ';' || c == '#') {
|
|
|
|
|
comment = 1;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
}
|
2009-07-30 19:41:57 +08:00
|
|
|
for (; space; space--)
|
config.c: Make git_config() work correctly when called recursively
On Cygwin, this fixes a test failure in t3301-notes.sh (test 98,
"git notes copy --for-rewrite (disabled)").
The test failure is caused by a recursive call to git_config() which
has the effect of skipping to the end-of-file while processing the
"notes.rewriteref" config variable. Thus, any config variables that
appear after "notes.rewriteref" are simply ignored by git_config().
Also, we note that the original FILE handle is leaked as a result
of the recursive call.
The recursive call to git_config() is due to the "schizophrenic stat"
functions on cygwin, where one of two different implementations of
the l/stat functions is selected lazily, depending on some config
variables.
In this case, the init_copy_notes_for_rewrite() function calls
git_config() with the notes_rewrite_config() callback function.
This callback, while processing the "notes.rewriteref" variable,
in turn calls string_list_add_refs_by_glob() to process the
associated ref value. This eventually leads to a call to the
get_ref_dir() function, which in turn calls stat(). On cygwin,
the stat() macro leads to an indirect call to cygwin_stat_stub()
which, via init_stat(), then calls git_config() in order to
determine which l/stat implementation to bind to.
In order to solve this problem, we modify git_config() so that the
global state variables used by the config reading code is packaged
up and managed on a local state stack.
Signed-off-by: Ramsay Jones <ramsay@ramsay1.demon.co.uk>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-06-17 04:24:51 +08:00
|
|
|
strbuf_addch(&cf->value, ' ');
|
2005-10-11 07:31:08 +08:00
|
|
|
if (c == '\\') {
|
|
|
|
|
c = get_next_char();
|
|
|
|
|
switch (c) {
|
|
|
|
|
case '\n':
|
|
|
|
|
continue;
|
|
|
|
|
case 't':
|
|
|
|
|
c = '\t';
|
|
|
|
|
break;
|
|
|
|
|
case 'b':
|
|
|
|
|
c = '\b';
|
|
|
|
|
break;
|
|
|
|
|
case 'n':
|
|
|
|
|
c = '\n';
|
|
|
|
|
break;
|
2005-10-12 06:24:11 +08:00
|
|
|
/* Some characters escape as themselves */
|
|
|
|
|
case '\\': case '"':
|
|
|
|
|
break;
|
|
|
|
|
/* Reject unknown escape sequences */
|
|
|
|
|
default:
|
|
|
|
|
return NULL;
|
2005-10-11 07:31:08 +08:00
|
|
|
}
|
config.c: Make git_config() work correctly when called recursively
On Cygwin, this fixes a test failure in t3301-notes.sh (test 98,
"git notes copy --for-rewrite (disabled)").
The test failure is caused by a recursive call to git_config() which
has the effect of skipping to the end-of-file while processing the
"notes.rewriteref" config variable. Thus, any config variables that
appear after "notes.rewriteref" are simply ignored by git_config().
Also, we note that the original FILE handle is leaked as a result
of the recursive call.
The recursive call to git_config() is due to the "schizophrenic stat"
functions on cygwin, where one of two different implementations of
the l/stat functions is selected lazily, depending on some config
variables.
In this case, the init_copy_notes_for_rewrite() function calls
git_config() with the notes_rewrite_config() callback function.
This callback, while processing the "notes.rewriteref" variable,
in turn calls string_list_add_refs_by_glob() to process the
associated ref value. This eventually leads to a call to the
get_ref_dir() function, which in turn calls stat(). On cygwin,
the stat() macro leads to an indirect call to cygwin_stat_stub()
which, via init_stat(), then calls git_config() in order to
determine which l/stat implementation to bind to.
In order to solve this problem, we modify git_config() so that the
global state variables used by the config reading code is packaged
up and managed on a local state stack.
Signed-off-by: Ramsay Jones <ramsay@ramsay1.demon.co.uk>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-06-17 04:24:51 +08:00
|
|
|
strbuf_addch(&cf->value, c);
|
2005-10-11 07:31:08 +08:00
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
if (c == '"') {
|
|
|
|
|
quote = 1-quote;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
config.c: Make git_config() work correctly when called recursively
On Cygwin, this fixes a test failure in t3301-notes.sh (test 98,
"git notes copy --for-rewrite (disabled)").
The test failure is caused by a recursive call to git_config() which
has the effect of skipping to the end-of-file while processing the
"notes.rewriteref" config variable. Thus, any config variables that
appear after "notes.rewriteref" are simply ignored by git_config().
Also, we note that the original FILE handle is leaked as a result
of the recursive call.
The recursive call to git_config() is due to the "schizophrenic stat"
functions on cygwin, where one of two different implementations of
the l/stat functions is selected lazily, depending on some config
variables.
In this case, the init_copy_notes_for_rewrite() function calls
git_config() with the notes_rewrite_config() callback function.
This callback, while processing the "notes.rewriteref" variable,
in turn calls string_list_add_refs_by_glob() to process the
associated ref value. This eventually leads to a call to the
get_ref_dir() function, which in turn calls stat(). On cygwin,
the stat() macro leads to an indirect call to cygwin_stat_stub()
which, via init_stat(), then calls git_config() in order to
determine which l/stat implementation to bind to.
In order to solve this problem, we modify git_config() so that the
global state variables used by the config reading code is packaged
up and managed on a local state stack.
Signed-off-by: Ramsay Jones <ramsay@ramsay1.demon.co.uk>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-06-17 04:24:51 +08:00
|
|
|
strbuf_addch(&cf->value, c);
|
2005-10-11 07:31:08 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2012-10-01 03:44:36 +08:00
|
|
|
static int get_value(config_fn_t fn, void *data, struct strbuf *name)
|
2005-10-11 07:31:08 +08:00
|
|
|
{
|
|
|
|
|
int c;
|
|
|
|
|
char *value;
|
2014-08-07 19:59:13 +08:00
|
|
|
int ret;
|
2005-10-11 07:31:08 +08:00
|
|
|
|
|
|
|
|
/* Get the full name */
|
|
|
|
|
for (;;) {
|
|
|
|
|
c = get_next_char();
|
config.c: Make git_config() work correctly when called recursively
On Cygwin, this fixes a test failure in t3301-notes.sh (test 98,
"git notes copy --for-rewrite (disabled)").
The test failure is caused by a recursive call to git_config() which
has the effect of skipping to the end-of-file while processing the
"notes.rewriteref" config variable. Thus, any config variables that
appear after "notes.rewriteref" are simply ignored by git_config().
Also, we note that the original FILE handle is leaked as a result
of the recursive call.
The recursive call to git_config() is due to the "schizophrenic stat"
functions on cygwin, where one of two different implementations of
the l/stat functions is selected lazily, depending on some config
variables.
In this case, the init_copy_notes_for_rewrite() function calls
git_config() with the notes_rewrite_config() callback function.
This callback, while processing the "notes.rewriteref" variable,
in turn calls string_list_add_refs_by_glob() to process the
associated ref value. This eventually leads to a call to the
get_ref_dir() function, which in turn calls stat(). On cygwin,
the stat() macro leads to an indirect call to cygwin_stat_stub()
which, via init_stat(), then calls git_config() in order to
determine which l/stat implementation to bind to.
In order to solve this problem, we modify git_config() so that the
global state variables used by the config reading code is packaged
up and managed on a local state stack.
Signed-off-by: Ramsay Jones <ramsay@ramsay1.demon.co.uk>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-06-17 04:24:51 +08:00
|
|
|
if (cf->eof)
|
2005-10-11 07:31:08 +08:00
|
|
|
break;
|
2006-10-31 00:25:36 +08:00
|
|
|
if (!iskeychar(c))
|
2005-10-11 07:31:08 +08:00
|
|
|
break;
|
2012-10-01 03:44:36 +08:00
|
|
|
strbuf_addch(name, tolower(c));
|
2005-10-11 07:31:08 +08:00
|
|
|
}
|
2012-10-01 03:44:36 +08:00
|
|
|
|
2005-10-11 07:31:08 +08:00
|
|
|
while (c == ' ' || c == '\t')
|
|
|
|
|
c = get_next_char();
|
|
|
|
|
|
|
|
|
|
value = NULL;
|
|
|
|
|
if (c != '\n') {
|
|
|
|
|
if (c != '=')
|
|
|
|
|
return -1;
|
|
|
|
|
value = parse_value();
|
|
|
|
|
if (!value)
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
2014-08-07 19:59:13 +08:00
|
|
|
/*
|
|
|
|
|
* We already consumed the \n, but we need linenr to point to
|
|
|
|
|
* the line we just parsed during the call to fn to get
|
|
|
|
|
* accurate line number in error messages.
|
|
|
|
|
*/
|
|
|
|
|
cf->linenr--;
|
|
|
|
|
ret = fn(name->buf, value, data);
|
2017-06-14 19:35:46 +08:00
|
|
|
if (ret >= 0)
|
|
|
|
|
cf->linenr++;
|
2014-08-07 19:59:13 +08:00
|
|
|
return ret;
|
2005-10-11 07:31:08 +08:00
|
|
|
}
|
|
|
|
|
|
2012-10-01 03:44:36 +08:00
|
|
|
static int get_extended_base_var(struct strbuf *name, int c)
|
2006-05-10 03:24:02 +08:00
|
|
|
{
|
2018-08-09 03:50:19 +08:00
|
|
|
cf->subsection_case_sensitive = 0;
|
2006-05-10 03:24:02 +08:00
|
|
|
do {
|
|
|
|
|
if (c == '\n')
|
2012-03-10 05:57:54 +08:00
|
|
|
goto error_incomplete_line;
|
2006-05-10 03:24:02 +08:00
|
|
|
c = get_next_char();
|
|
|
|
|
} while (isspace(c));
|
|
|
|
|
|
|
|
|
|
/* We require the format to be '[base "extension"]' */
|
|
|
|
|
if (c != '"')
|
|
|
|
|
return -1;
|
2012-10-01 03:44:36 +08:00
|
|
|
strbuf_addch(name, '.');
|
2006-05-10 03:24:02 +08:00
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
|
int c = get_next_char();
|
|
|
|
|
if (c == '\n')
|
2012-03-10 05:57:54 +08:00
|
|
|
goto error_incomplete_line;
|
2006-05-10 03:24:02 +08:00
|
|
|
if (c == '"')
|
|
|
|
|
break;
|
|
|
|
|
if (c == '\\') {
|
|
|
|
|
c = get_next_char();
|
|
|
|
|
if (c == '\n')
|
2012-03-10 05:57:54 +08:00
|
|
|
goto error_incomplete_line;
|
2006-05-10 03:24:02 +08:00
|
|
|
}
|
2012-10-01 03:44:36 +08:00
|
|
|
strbuf_addch(name, c);
|
2006-05-10 03:24:02 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Final ']' */
|
|
|
|
|
if (get_next_char() != ']')
|
|
|
|
|
return -1;
|
2012-10-01 03:44:36 +08:00
|
|
|
return 0;
|
2012-03-10 05:57:54 +08:00
|
|
|
error_incomplete_line:
|
|
|
|
|
cf->linenr--;
|
|
|
|
|
return -1;
|
2006-05-10 03:24:02 +08:00
|
|
|
}
|
|
|
|
|
|
2012-10-01 03:44:36 +08:00
|
|
|
static int get_base_var(struct strbuf *name)
|
2005-10-11 07:31:08 +08:00
|
|
|
{
|
2018-08-09 03:50:19 +08:00
|
|
|
cf->subsection_case_sensitive = 1;
|
2005-10-11 07:31:08 +08:00
|
|
|
for (;;) {
|
|
|
|
|
int c = get_next_char();
|
config.c: Make git_config() work correctly when called recursively
On Cygwin, this fixes a test failure in t3301-notes.sh (test 98,
"git notes copy --for-rewrite (disabled)").
The test failure is caused by a recursive call to git_config() which
has the effect of skipping to the end-of-file while processing the
"notes.rewriteref" config variable. Thus, any config variables that
appear after "notes.rewriteref" are simply ignored by git_config().
Also, we note that the original FILE handle is leaked as a result
of the recursive call.
The recursive call to git_config() is due to the "schizophrenic stat"
functions on cygwin, where one of two different implementations of
the l/stat functions is selected lazily, depending on some config
variables.
In this case, the init_copy_notes_for_rewrite() function calls
git_config() with the notes_rewrite_config() callback function.
This callback, while processing the "notes.rewriteref" variable,
in turn calls string_list_add_refs_by_glob() to process the
associated ref value. This eventually leads to a call to the
get_ref_dir() function, which in turn calls stat(). On cygwin,
the stat() macro leads to an indirect call to cygwin_stat_stub()
which, via init_stat(), then calls git_config() in order to
determine which l/stat implementation to bind to.
In order to solve this problem, we modify git_config() so that the
global state variables used by the config reading code is packaged
up and managed on a local state stack.
Signed-off-by: Ramsay Jones <ramsay@ramsay1.demon.co.uk>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-06-17 04:24:51 +08:00
|
|
|
if (cf->eof)
|
2005-10-11 07:31:08 +08:00
|
|
|
return -1;
|
|
|
|
|
if (c == ']')
|
2012-10-01 03:44:36 +08:00
|
|
|
return 0;
|
2006-05-10 03:24:02 +08:00
|
|
|
if (isspace(c))
|
2012-10-01 03:44:36 +08:00
|
|
|
return get_extended_base_var(name, c);
|
2006-10-31 00:25:36 +08:00
|
|
|
if (!iskeychar(c) && c != '.')
|
2005-10-11 07:31:08 +08:00
|
|
|
return -1;
|
2012-10-01 03:44:36 +08:00
|
|
|
strbuf_addch(name, tolower(c));
|
2005-10-11 07:31:08 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2018-04-09 16:32:05 +08:00
|
|
|
struct parse_event_data {
|
|
|
|
|
enum config_event_t previous_type;
|
|
|
|
|
size_t previous_offset;
|
|
|
|
|
const struct config_options *opts;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static int do_event(enum config_event_t type, struct parse_event_data *data)
|
|
|
|
|
{
|
|
|
|
|
size_t offset;
|
|
|
|
|
|
|
|
|
|
if (!data->opts || !data->opts->event_fn)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
if (type == CONFIG_EVENT_WHITESPACE &&
|
|
|
|
|
data->previous_type == type)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
offset = cf->do_ftell(cf);
|
|
|
|
|
/*
|
|
|
|
|
* At EOF, the parser always "inserts" an extra '\n', therefore
|
|
|
|
|
* the end offset of the event is the current file position, otherwise
|
|
|
|
|
* we will already have advanced to the next event.
|
|
|
|
|
*/
|
|
|
|
|
if (type != CONFIG_EVENT_EOF)
|
|
|
|
|
offset--;
|
|
|
|
|
|
|
|
|
|
if (data->previous_type != CONFIG_EVENT_EOF &&
|
|
|
|
|
data->opts->event_fn(data->previous_type, data->previous_offset,
|
|
|
|
|
offset, data->opts->event_fn_data) < 0)
|
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
data->previous_type = type;
|
|
|
|
|
data->previous_offset = offset;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int git_parse_source(config_fn_t fn, void *data,
|
|
|
|
|
const struct config_options *opts)
|
2005-10-11 07:31:08 +08:00
|
|
|
{
|
|
|
|
|
int comment = 0;
|
|
|
|
|
int baselen = 0;
|
2012-10-01 03:44:36 +08:00
|
|
|
struct strbuf *var = &cf->var;
|
i18n: config: unfold error messages marked for translation
Introduced in 473166b ("config: add 'origin_type' to config_source
struct", 2016-02-19), Git can inform the user about the origin of a
config error, but the implementation does not allow translators to
translate the keywords 'file', 'blob, 'standard input', and
'submodule-blob'. Moreover, for the second message, a reason for the
error is appended to the message, not allowing translators to translate
that reason either.
Unfold the message into several templates for each known origin_type.
That would result in better translation at the expense of code
verbosity.
Add enum config_oringin_type to ease management of the various
configuration origin types (blob, file, etc). Previously origin type
was considered from command line if cf->origin_type == NULL, i.e.,
uninitialized. Now we set origin_type to CONFIG_ORIGIN_CMDLINE in
git_config_from_parameters() and configset_add_value().
For error message in git_parse_source(), use xstrfmt() function to
prepare the message string, instead of doing something like it's done
for die_bad_number(), because intelligibility and code conciseness are
improved for that instance.
Signed-off-by: Vasco Almeida <vascomalmeida@sapo.pt>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-07-28 21:14:03 +08:00
|
|
|
int error_return = 0;
|
|
|
|
|
char *error_msg = NULL;
|
2005-10-11 07:31:08 +08:00
|
|
|
|
2008-10-02 04:13:02 +08:00
|
|
|
/* U+FEFF Byte Order Mark in UTF8 */
|
2015-04-17 01:47:45 +08:00
|
|
|
const char *bomptr = utf8_bom;
|
2008-10-02 04:13:02 +08:00
|
|
|
|
2018-04-09 16:32:05 +08:00
|
|
|
/* For the parser event callback */
|
|
|
|
|
struct parse_event_data event_data = {
|
|
|
|
|
CONFIG_EVENT_EOF, 0, opts
|
|
|
|
|
};
|
|
|
|
|
|
2005-10-11 07:31:08 +08:00
|
|
|
for (;;) {
|
2018-04-09 16:32:05 +08:00
|
|
|
int c;
|
|
|
|
|
|
|
|
|
|
c = get_next_char();
|
2008-10-02 04:13:02 +08:00
|
|
|
if (bomptr && *bomptr) {
|
|
|
|
|
/* We are at the file beginning; skip UTF8-encoded BOM
|
|
|
|
|
* if present. Sane editors won't put this in on their
|
|
|
|
|
* own, but e.g. Windows Notepad will do it happily. */
|
2015-04-17 01:47:45 +08:00
|
|
|
if (c == (*bomptr & 0377)) {
|
2008-10-02 04:13:02 +08:00
|
|
|
bomptr++;
|
|
|
|
|
continue;
|
|
|
|
|
} else {
|
|
|
|
|
/* Do not tolerate partial BOM. */
|
|
|
|
|
if (bomptr != utf8_bom)
|
|
|
|
|
break;
|
|
|
|
|
/* No BOM at file beginning. Cool. */
|
|
|
|
|
bomptr = NULL;
|
|
|
|
|
}
|
|
|
|
|
}
|
2005-10-11 07:31:08 +08:00
|
|
|
if (c == '\n') {
|
2018-04-09 16:32:05 +08:00
|
|
|
if (cf->eof) {
|
|
|
|
|
if (do_event(CONFIG_EVENT_EOF, &event_data) < 0)
|
|
|
|
|
return -1;
|
2005-10-11 07:31:08 +08:00
|
|
|
return 0;
|
2018-04-09 16:32:05 +08:00
|
|
|
}
|
|
|
|
|
if (do_event(CONFIG_EVENT_WHITESPACE, &event_data) < 0)
|
|
|
|
|
return -1;
|
2005-10-11 07:31:08 +08:00
|
|
|
comment = 0;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2018-04-09 16:32:05 +08:00
|
|
|
if (comment)
|
2005-10-11 07:31:08 +08:00
|
|
|
continue;
|
2018-04-09 16:32:05 +08:00
|
|
|
if (isspace(c)) {
|
|
|
|
|
if (do_event(CONFIG_EVENT_WHITESPACE, &event_data) < 0)
|
|
|
|
|
return -1;
|
2005-10-11 07:31:08 +08:00
|
|
|
continue;
|
2018-04-09 16:32:05 +08:00
|
|
|
}
|
2005-10-11 07:31:08 +08:00
|
|
|
if (c == '#' || c == ';') {
|
2018-04-09 16:32:05 +08:00
|
|
|
if (do_event(CONFIG_EVENT_COMMENT, &event_data) < 0)
|
|
|
|
|
return -1;
|
2005-10-11 07:31:08 +08:00
|
|
|
comment = 1;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
if (c == '[') {
|
2018-04-09 16:32:05 +08:00
|
|
|
if (do_event(CONFIG_EVENT_SECTION, &event_data) < 0)
|
|
|
|
|
return -1;
|
|
|
|
|
|
2012-10-01 03:44:36 +08:00
|
|
|
/* Reset prior to determining a new stem */
|
|
|
|
|
strbuf_reset(var);
|
|
|
|
|
if (get_base_var(var) < 0 || var->len < 1)
|
2005-10-11 07:31:08 +08:00
|
|
|
break;
|
2012-10-01 03:44:36 +08:00
|
|
|
strbuf_addch(var, '.');
|
|
|
|
|
baselen = var->len;
|
2005-10-11 07:31:08 +08:00
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
if (!isalpha(c))
|
|
|
|
|
break;
|
2018-04-09 16:32:05 +08:00
|
|
|
|
|
|
|
|
if (do_event(CONFIG_EVENT_ENTRY, &event_data) < 0)
|
|
|
|
|
return -1;
|
|
|
|
|
|
2012-10-01 03:44:36 +08:00
|
|
|
/*
|
|
|
|
|
* Truncate the var name back to the section header
|
|
|
|
|
* stem prior to grabbing the suffix part of the name
|
|
|
|
|
* and the value.
|
|
|
|
|
*/
|
|
|
|
|
strbuf_setlen(var, baselen);
|
|
|
|
|
strbuf_addch(var, tolower(c));
|
|
|
|
|
if (get_value(fn, data, var) < 0)
|
2005-10-11 07:31:08 +08:00
|
|
|
break;
|
|
|
|
|
}
|
i18n: config: unfold error messages marked for translation
Introduced in 473166b ("config: add 'origin_type' to config_source
struct", 2016-02-19), Git can inform the user about the origin of a
config error, but the implementation does not allow translators to
translate the keywords 'file', 'blob, 'standard input', and
'submodule-blob'. Moreover, for the second message, a reason for the
error is appended to the message, not allowing translators to translate
that reason either.
Unfold the message into several templates for each known origin_type.
That would result in better translation at the expense of code
verbosity.
Add enum config_oringin_type to ease management of the various
configuration origin types (blob, file, etc). Previously origin type
was considered from command line if cf->origin_type == NULL, i.e.,
uninitialized. Now we set origin_type to CONFIG_ORIGIN_CMDLINE in
git_config_from_parameters() and configset_add_value().
For error message in git_parse_source(), use xstrfmt() function to
prepare the message string, instead of doing something like it's done
for die_bad_number(), because intelligibility and code conciseness are
improved for that instance.
Signed-off-by: Vasco Almeida <vascomalmeida@sapo.pt>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-07-28 21:14:03 +08:00
|
|
|
|
2018-04-09 16:32:05 +08:00
|
|
|
if (do_event(CONFIG_EVENT_ERROR, &event_data) < 0)
|
|
|
|
|
return -1;
|
|
|
|
|
|
i18n: config: unfold error messages marked for translation
Introduced in 473166b ("config: add 'origin_type' to config_source
struct", 2016-02-19), Git can inform the user about the origin of a
config error, but the implementation does not allow translators to
translate the keywords 'file', 'blob, 'standard input', and
'submodule-blob'. Moreover, for the second message, a reason for the
error is appended to the message, not allowing translators to translate
that reason either.
Unfold the message into several templates for each known origin_type.
That would result in better translation at the expense of code
verbosity.
Add enum config_oringin_type to ease management of the various
configuration origin types (blob, file, etc). Previously origin type
was considered from command line if cf->origin_type == NULL, i.e.,
uninitialized. Now we set origin_type to CONFIG_ORIGIN_CMDLINE in
git_config_from_parameters() and configset_add_value().
For error message in git_parse_source(), use xstrfmt() function to
prepare the message string, instead of doing something like it's done
for die_bad_number(), because intelligibility and code conciseness are
improved for that instance.
Signed-off-by: Vasco Almeida <vascomalmeida@sapo.pt>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-07-28 21:14:03 +08:00
|
|
|
switch (cf->origin_type) {
|
|
|
|
|
case CONFIG_ORIGIN_BLOB:
|
|
|
|
|
error_msg = xstrfmt(_("bad config line %d in blob %s"),
|
|
|
|
|
cf->linenr, cf->name);
|
|
|
|
|
break;
|
|
|
|
|
case CONFIG_ORIGIN_FILE:
|
|
|
|
|
error_msg = xstrfmt(_("bad config line %d in file %s"),
|
|
|
|
|
cf->linenr, cf->name);
|
|
|
|
|
break;
|
|
|
|
|
case CONFIG_ORIGIN_STDIN:
|
|
|
|
|
error_msg = xstrfmt(_("bad config line %d in standard input"),
|
|
|
|
|
cf->linenr);
|
|
|
|
|
break;
|
|
|
|
|
case CONFIG_ORIGIN_SUBMODULE_BLOB:
|
|
|
|
|
error_msg = xstrfmt(_("bad config line %d in submodule-blob %s"),
|
|
|
|
|
cf->linenr, cf->name);
|
|
|
|
|
break;
|
|
|
|
|
case CONFIG_ORIGIN_CMDLINE:
|
|
|
|
|
error_msg = xstrfmt(_("bad config line %d in command line %s"),
|
|
|
|
|
cf->linenr, cf->name);
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
error_msg = xstrfmt(_("bad config line %d in %s"),
|
|
|
|
|
cf->linenr, cf->name);
|
|
|
|
|
}
|
|
|
|
|
|
2018-06-29 06:05:00 +08:00
|
|
|
switch (opts && opts->error_action ?
|
|
|
|
|
opts->error_action :
|
|
|
|
|
cf->default_error_action) {
|
|
|
|
|
case CONFIG_ERROR_DIE:
|
i18n: config: unfold error messages marked for translation
Introduced in 473166b ("config: add 'origin_type' to config_source
struct", 2016-02-19), Git can inform the user about the origin of a
config error, but the implementation does not allow translators to
translate the keywords 'file', 'blob, 'standard input', and
'submodule-blob'. Moreover, for the second message, a reason for the
error is appended to the message, not allowing translators to translate
that reason either.
Unfold the message into several templates for each known origin_type.
That would result in better translation at the expense of code
verbosity.
Add enum config_oringin_type to ease management of the various
configuration origin types (blob, file, etc). Previously origin type
was considered from command line if cf->origin_type == NULL, i.e.,
uninitialized. Now we set origin_type to CONFIG_ORIGIN_CMDLINE in
git_config_from_parameters() and configset_add_value().
For error message in git_parse_source(), use xstrfmt() function to
prepare the message string, instead of doing something like it's done
for die_bad_number(), because intelligibility and code conciseness are
improved for that instance.
Signed-off-by: Vasco Almeida <vascomalmeida@sapo.pt>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-07-28 21:14:03 +08:00
|
|
|
die("%s", error_msg);
|
2018-06-29 06:05:00 +08:00
|
|
|
break;
|
|
|
|
|
case CONFIG_ERROR_ERROR:
|
i18n: config: unfold error messages marked for translation
Introduced in 473166b ("config: add 'origin_type' to config_source
struct", 2016-02-19), Git can inform the user about the origin of a
config error, but the implementation does not allow translators to
translate the keywords 'file', 'blob, 'standard input', and
'submodule-blob'. Moreover, for the second message, a reason for the
error is appended to the message, not allowing translators to translate
that reason either.
Unfold the message into several templates for each known origin_type.
That would result in better translation at the expense of code
verbosity.
Add enum config_oringin_type to ease management of the various
configuration origin types (blob, file, etc). Previously origin type
was considered from command line if cf->origin_type == NULL, i.e.,
uninitialized. Now we set origin_type to CONFIG_ORIGIN_CMDLINE in
git_config_from_parameters() and configset_add_value().
For error message in git_parse_source(), use xstrfmt() function to
prepare the message string, instead of doing something like it's done
for die_bad_number(), because intelligibility and code conciseness are
improved for that instance.
Signed-off-by: Vasco Almeida <vascomalmeida@sapo.pt>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-07-28 21:14:03 +08:00
|
|
|
error_return = error("%s", error_msg);
|
2018-06-29 06:05:00 +08:00
|
|
|
break;
|
2018-06-29 06:05:09 +08:00
|
|
|
case CONFIG_ERROR_SILENT:
|
|
|
|
|
error_return = -1;
|
|
|
|
|
break;
|
2018-06-29 06:05:00 +08:00
|
|
|
case CONFIG_ERROR_UNSET:
|
|
|
|
|
BUG("config error action unset");
|
|
|
|
|
}
|
i18n: config: unfold error messages marked for translation
Introduced in 473166b ("config: add 'origin_type' to config_source
struct", 2016-02-19), Git can inform the user about the origin of a
config error, but the implementation does not allow translators to
translate the keywords 'file', 'blob, 'standard input', and
'submodule-blob'. Moreover, for the second message, a reason for the
error is appended to the message, not allowing translators to translate
that reason either.
Unfold the message into several templates for each known origin_type.
That would result in better translation at the expense of code
verbosity.
Add enum config_oringin_type to ease management of the various
configuration origin types (blob, file, etc). Previously origin type
was considered from command line if cf->origin_type == NULL, i.e.,
uninitialized. Now we set origin_type to CONFIG_ORIGIN_CMDLINE in
git_config_from_parameters() and configset_add_value().
For error message in git_parse_source(), use xstrfmt() function to
prepare the message string, instead of doing something like it's done
for die_bad_number(), because intelligibility and code conciseness are
improved for that instance.
Signed-off-by: Vasco Almeida <vascomalmeida@sapo.pt>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-07-28 21:14:03 +08:00
|
|
|
|
|
|
|
|
free(error_msg);
|
|
|
|
|
return error_return;
|
2005-10-11 07:31:08 +08:00
|
|
|
}
|
|
|
|
|
|
2019-06-22 18:03:40 +08:00
|
|
|
static uintmax_t get_unit_factor(const char *end)
|
2007-07-12 21:32:26 +08:00
|
|
|
{
|
|
|
|
|
if (!*end)
|
|
|
|
|
return 1;
|
2019-06-22 18:03:40 +08:00
|
|
|
else if (!strcasecmp(end, "k"))
|
|
|
|
|
return 1024;
|
|
|
|
|
else if (!strcasecmp(end, "m"))
|
|
|
|
|
return 1024 * 1024;
|
|
|
|
|
else if (!strcasecmp(end, "g"))
|
|
|
|
|
return 1024 * 1024 * 1024;
|
2007-12-25 15:18:05 +08:00
|
|
|
return 0;
|
2007-07-12 21:32:26 +08:00
|
|
|
}
|
|
|
|
|
|
2013-09-08 16:29:27 +08:00
|
|
|
static int git_parse_signed(const char *value, intmax_t *ret, intmax_t max)
|
2007-07-12 21:32:26 +08:00
|
|
|
{
|
|
|
|
|
if (value && *value) {
|
|
|
|
|
char *end;
|
Support sizes >=2G in various config options accepting 'g' sizes.
The config options core.packedGitWindowSize, core.packedGitLimit,
core.deltaBaseCacheLimit, core.bigFileThreshold, pack.windowMemory and
pack.packSizeLimit all claim to support suffixes up to and including
'g'. This implies that they should accept sizes >=2G on 64-bit
systems: certainly, specifying a size of 3g should not silently be
translated to zero or transformed into a large negative value due to
integer overflow. However, due to use of git_config_int() rather than
git_config_ulong(), that is exactly what happens:
% git config core.bigFileThreshold 2g
% git gc --aggressive # with extra debugging code to print out
# core.bigfilethreshold after parsing
bigfilethreshold: -2147483648
[...]
This is probably irrelevant for core.deltaBaseCacheLimit, but is
problematic for the other values. (It is particularly problematic for
core.packedGitLimit, which can't even be set to its default value in
the config file due to this bug.)
This fixes things for 32-bit platforms as well. They get the usual bad
config error if an overlarge value is specified, e.g.:
fatal: bad config value for 'core.bigfilethreshold' in /home/nix/.gitconfig
This is detected in all cases, even if the 32-bit platform has no size
larger than 'long'. For signed integral configuration values, we also
detect the case where the value is too large for the signed type but
not the unsigned type.
Signed-off-by: Nick Alcock <nix@esperi.org.uk>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-11-02 23:46:23 +08:00
|
|
|
intmax_t val;
|
|
|
|
|
uintmax_t uval;
|
2019-06-22 18:03:36 +08:00
|
|
|
uintmax_t factor;
|
Support sizes >=2G in various config options accepting 'g' sizes.
The config options core.packedGitWindowSize, core.packedGitLimit,
core.deltaBaseCacheLimit, core.bigFileThreshold, pack.windowMemory and
pack.packSizeLimit all claim to support suffixes up to and including
'g'. This implies that they should accept sizes >=2G on 64-bit
systems: certainly, specifying a size of 3g should not silently be
translated to zero or transformed into a large negative value due to
integer overflow. However, due to use of git_config_int() rather than
git_config_ulong(), that is exactly what happens:
% git config core.bigFileThreshold 2g
% git gc --aggressive # with extra debugging code to print out
# core.bigfilethreshold after parsing
bigfilethreshold: -2147483648
[...]
This is probably irrelevant for core.deltaBaseCacheLimit, but is
problematic for the other values. (It is particularly problematic for
core.packedGitLimit, which can't even be set to its default value in
the config file due to this bug.)
This fixes things for 32-bit platforms as well. They get the usual bad
config error if an overlarge value is specified, e.g.:
fatal: bad config value for 'core.bigfilethreshold' in /home/nix/.gitconfig
This is detected in all cases, even if the 32-bit platform has no size
larger than 'long'. For signed integral configuration values, we also
detect the case where the value is too large for the signed type but
not the unsigned type.
Signed-off-by: Nick Alcock <nix@esperi.org.uk>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-11-02 23:46:23 +08:00
|
|
|
|
|
|
|
|
errno = 0;
|
|
|
|
|
val = strtoimax(value, &end, 0);
|
|
|
|
|
if (errno == ERANGE)
|
|
|
|
|
return 0;
|
2019-06-22 18:03:40 +08:00
|
|
|
factor = get_unit_factor(end);
|
|
|
|
|
if (!factor) {
|
2013-09-08 16:36:42 +08:00
|
|
|
errno = EINVAL;
|
2007-12-25 15:18:05 +08:00
|
|
|
return 0;
|
2013-09-08 16:36:42 +08:00
|
|
|
}
|
2019-06-13 19:49:47 +08:00
|
|
|
uval = val < 0 ? -val : val;
|
config: use unsigned_mult_overflows to check for overflows
parse_unit_factor() checks if a K, M or G is present after a number and
multiplies it by 2^10, 2^20 or 2^30, respectively. One of its callers
checks if the result is smaller than the number alone to detect
overflows. The other one passes 1 as the number and does multiplication
and overflow check itself in a similar manner.
This works, but is inconsistent, and it would break if we added support
for a bigger unit factor. E.g. 16777217T is 2^64 + 2^40, i.e. too big
for a 64-bit number. Modulo 2^64 we get 2^40 == 1TB, which is bigger
than the raw number 16777217 == 2^24 + 1, so the overflow would go
undetected by that method.
Let both callers pass 1 and handle overflow check and multiplication
themselves. Do the check before the multiplication, using
unsigned_mult_overflows, which is simpler and can deal with larger unit
factors.
Signed-off-by: Rene Scharfe <l.s.r@web.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-06-22 18:03:30 +08:00
|
|
|
if (unsigned_mult_overflows(factor, uval) ||
|
|
|
|
|
factor * uval > max) {
|
2013-09-08 16:36:42 +08:00
|
|
|
errno = ERANGE;
|
Support sizes >=2G in various config options accepting 'g' sizes.
The config options core.packedGitWindowSize, core.packedGitLimit,
core.deltaBaseCacheLimit, core.bigFileThreshold, pack.windowMemory and
pack.packSizeLimit all claim to support suffixes up to and including
'g'. This implies that they should accept sizes >=2G on 64-bit
systems: certainly, specifying a size of 3g should not silently be
translated to zero or transformed into a large negative value due to
integer overflow. However, due to use of git_config_int() rather than
git_config_ulong(), that is exactly what happens:
% git config core.bigFileThreshold 2g
% git gc --aggressive # with extra debugging code to print out
# core.bigfilethreshold after parsing
bigfilethreshold: -2147483648
[...]
This is probably irrelevant for core.deltaBaseCacheLimit, but is
problematic for the other values. (It is particularly problematic for
core.packedGitLimit, which can't even be set to its default value in
the config file due to this bug.)
This fixes things for 32-bit platforms as well. They get the usual bad
config error if an overlarge value is specified, e.g.:
fatal: bad config value for 'core.bigfilethreshold' in /home/nix/.gitconfig
This is detected in all cases, even if the 32-bit platform has no size
larger than 'long'. For signed integral configuration values, we also
detect the case where the value is too large for the signed type but
not the unsigned type.
Signed-off-by: Nick Alcock <nix@esperi.org.uk>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-11-02 23:46:23 +08:00
|
|
|
return 0;
|
2013-09-08 16:36:42 +08:00
|
|
|
}
|
Support sizes >=2G in various config options accepting 'g' sizes.
The config options core.packedGitWindowSize, core.packedGitLimit,
core.deltaBaseCacheLimit, core.bigFileThreshold, pack.windowMemory and
pack.packSizeLimit all claim to support suffixes up to and including
'g'. This implies that they should accept sizes >=2G on 64-bit
systems: certainly, specifying a size of 3g should not silently be
translated to zero or transformed into a large negative value due to
integer overflow. However, due to use of git_config_int() rather than
git_config_ulong(), that is exactly what happens:
% git config core.bigFileThreshold 2g
% git gc --aggressive # with extra debugging code to print out
# core.bigfilethreshold after parsing
bigfilethreshold: -2147483648
[...]
This is probably irrelevant for core.deltaBaseCacheLimit, but is
problematic for the other values. (It is particularly problematic for
core.packedGitLimit, which can't even be set to its default value in
the config file due to this bug.)
This fixes things for 32-bit platforms as well. They get the usual bad
config error if an overlarge value is specified, e.g.:
fatal: bad config value for 'core.bigfilethreshold' in /home/nix/.gitconfig
This is detected in all cases, even if the 32-bit platform has no size
larger than 'long'. For signed integral configuration values, we also
detect the case where the value is too large for the signed type but
not the unsigned type.
Signed-off-by: Nick Alcock <nix@esperi.org.uk>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-11-02 23:46:23 +08:00
|
|
|
val *= factor;
|
|
|
|
|
*ret = val;
|
2007-07-12 21:32:26 +08:00
|
|
|
return 1;
|
|
|
|
|
}
|
2013-09-08 16:36:42 +08:00
|
|
|
errno = EINVAL;
|
2007-07-12 21:32:26 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2013-10-07 04:48:29 +08:00
|
|
|
static int git_parse_unsigned(const char *value, uintmax_t *ret, uintmax_t max)
|
2005-10-11 07:31:08 +08:00
|
|
|
{
|
|
|
|
|
if (value && *value) {
|
|
|
|
|
char *end;
|
Support sizes >=2G in various config options accepting 'g' sizes.
The config options core.packedGitWindowSize, core.packedGitLimit,
core.deltaBaseCacheLimit, core.bigFileThreshold, pack.windowMemory and
pack.packSizeLimit all claim to support suffixes up to and including
'g'. This implies that they should accept sizes >=2G on 64-bit
systems: certainly, specifying a size of 3g should not silently be
translated to zero or transformed into a large negative value due to
integer overflow. However, due to use of git_config_int() rather than
git_config_ulong(), that is exactly what happens:
% git config core.bigFileThreshold 2g
% git gc --aggressive # with extra debugging code to print out
# core.bigfilethreshold after parsing
bigfilethreshold: -2147483648
[...]
This is probably irrelevant for core.deltaBaseCacheLimit, but is
problematic for the other values. (It is particularly problematic for
core.packedGitLimit, which can't even be set to its default value in
the config file due to this bug.)
This fixes things for 32-bit platforms as well. They get the usual bad
config error if an overlarge value is specified, e.g.:
fatal: bad config value for 'core.bigfilethreshold' in /home/nix/.gitconfig
This is detected in all cases, even if the 32-bit platform has no size
larger than 'long'. For signed integral configuration values, we also
detect the case where the value is too large for the signed type but
not the unsigned type.
Signed-off-by: Nick Alcock <nix@esperi.org.uk>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-11-02 23:46:23 +08:00
|
|
|
uintmax_t val;
|
2019-06-22 18:03:36 +08:00
|
|
|
uintmax_t factor;
|
Support sizes >=2G in various config options accepting 'g' sizes.
The config options core.packedGitWindowSize, core.packedGitLimit,
core.deltaBaseCacheLimit, core.bigFileThreshold, pack.windowMemory and
pack.packSizeLimit all claim to support suffixes up to and including
'g'. This implies that they should accept sizes >=2G on 64-bit
systems: certainly, specifying a size of 3g should not silently be
translated to zero or transformed into a large negative value due to
integer overflow. However, due to use of git_config_int() rather than
git_config_ulong(), that is exactly what happens:
% git config core.bigFileThreshold 2g
% git gc --aggressive # with extra debugging code to print out
# core.bigfilethreshold after parsing
bigfilethreshold: -2147483648
[...]
This is probably irrelevant for core.deltaBaseCacheLimit, but is
problematic for the other values. (It is particularly problematic for
core.packedGitLimit, which can't even be set to its default value in
the config file due to this bug.)
This fixes things for 32-bit platforms as well. They get the usual bad
config error if an overlarge value is specified, e.g.:
fatal: bad config value for 'core.bigfilethreshold' in /home/nix/.gitconfig
This is detected in all cases, even if the 32-bit platform has no size
larger than 'long'. For signed integral configuration values, we also
detect the case where the value is too large for the signed type but
not the unsigned type.
Signed-off-by: Nick Alcock <nix@esperi.org.uk>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-11-02 23:46:23 +08:00
|
|
|
|
|
|
|
|
errno = 0;
|
|
|
|
|
val = strtoumax(value, &end, 0);
|
|
|
|
|
if (errno == ERANGE)
|
|
|
|
|
return 0;
|
2019-06-22 18:03:40 +08:00
|
|
|
factor = get_unit_factor(end);
|
|
|
|
|
if (!factor) {
|
2013-09-08 16:36:42 +08:00
|
|
|
errno = EINVAL;
|
2007-12-25 15:18:05 +08:00
|
|
|
return 0;
|
2013-09-08 16:36:42 +08:00
|
|
|
}
|
config: use unsigned_mult_overflows to check for overflows
parse_unit_factor() checks if a K, M or G is present after a number and
multiplies it by 2^10, 2^20 or 2^30, respectively. One of its callers
checks if the result is smaller than the number alone to detect
overflows. The other one passes 1 as the number and does multiplication
and overflow check itself in a similar manner.
This works, but is inconsistent, and it would break if we added support
for a bigger unit factor. E.g. 16777217T is 2^64 + 2^40, i.e. too big
for a 64-bit number. Modulo 2^64 we get 2^40 == 1TB, which is bigger
than the raw number 16777217 == 2^24 + 1, so the overflow would go
undetected by that method.
Let both callers pass 1 and handle overflow check and multiplication
themselves. Do the check before the multiplication, using
unsigned_mult_overflows, which is simpler and can deal with larger unit
factors.
Signed-off-by: Rene Scharfe <l.s.r@web.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-06-22 18:03:30 +08:00
|
|
|
if (unsigned_mult_overflows(factor, val) ||
|
|
|
|
|
factor * val > max) {
|
2013-09-08 16:36:42 +08:00
|
|
|
errno = ERANGE;
|
Support sizes >=2G in various config options accepting 'g' sizes.
The config options core.packedGitWindowSize, core.packedGitLimit,
core.deltaBaseCacheLimit, core.bigFileThreshold, pack.windowMemory and
pack.packSizeLimit all claim to support suffixes up to and including
'g'. This implies that they should accept sizes >=2G on 64-bit
systems: certainly, specifying a size of 3g should not silently be
translated to zero or transformed into a large negative value due to
integer overflow. However, due to use of git_config_int() rather than
git_config_ulong(), that is exactly what happens:
% git config core.bigFileThreshold 2g
% git gc --aggressive # with extra debugging code to print out
# core.bigfilethreshold after parsing
bigfilethreshold: -2147483648
[...]
This is probably irrelevant for core.deltaBaseCacheLimit, but is
problematic for the other values. (It is particularly problematic for
core.packedGitLimit, which can't even be set to its default value in
the config file due to this bug.)
This fixes things for 32-bit platforms as well. They get the usual bad
config error if an overlarge value is specified, e.g.:
fatal: bad config value for 'core.bigfilethreshold' in /home/nix/.gitconfig
This is detected in all cases, even if the 32-bit platform has no size
larger than 'long'. For signed integral configuration values, we also
detect the case where the value is too large for the signed type but
not the unsigned type.
Signed-off-by: Nick Alcock <nix@esperi.org.uk>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-11-02 23:46:23 +08:00
|
|
|
return 0;
|
2013-09-08 16:36:42 +08:00
|
|
|
}
|
config: use unsigned_mult_overflows to check for overflows
parse_unit_factor() checks if a K, M or G is present after a number and
multiplies it by 2^10, 2^20 or 2^30, respectively. One of its callers
checks if the result is smaller than the number alone to detect
overflows. The other one passes 1 as the number and does multiplication
and overflow check itself in a similar manner.
This works, but is inconsistent, and it would break if we added support
for a bigger unit factor. E.g. 16777217T is 2^64 + 2^40, i.e. too big
for a 64-bit number. Modulo 2^64 we get 2^40 == 1TB, which is bigger
than the raw number 16777217 == 2^24 + 1, so the overflow would go
undetected by that method.
Let both callers pass 1 and handle overflow check and multiplication
themselves. Do the check before the multiplication, using
unsigned_mult_overflows, which is simpler and can deal with larger unit
factors.
Signed-off-by: Rene Scharfe <l.s.r@web.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-06-22 18:03:30 +08:00
|
|
|
val *= factor;
|
2007-12-25 15:18:05 +08:00
|
|
|
*ret = val;
|
2007-07-12 21:32:26 +08:00
|
|
|
return 1;
|
2005-10-11 07:31:08 +08:00
|
|
|
}
|
2013-09-08 16:36:42 +08:00
|
|
|
errno = EINVAL;
|
2007-07-12 21:32:26 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2013-09-08 16:33:08 +08:00
|
|
|
static int git_parse_int(const char *value, int *ret)
|
2008-02-21 08:00:32 +08:00
|
|
|
{
|
2013-09-08 16:29:27 +08:00
|
|
|
intmax_t tmp;
|
2013-09-08 16:33:08 +08:00
|
|
|
if (!git_parse_signed(value, &tmp, maximum_signed_value_of_type(int)))
|
2013-09-08 16:29:27 +08:00
|
|
|
return 0;
|
|
|
|
|
*ret = tmp;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
git-config: always treat --int as 64-bit internally
When you run "git config --int", the maximum size of integer
you get depends on how git was compiled, and what it
considers to be an "int".
This is almost useful, because your scripts calling "git
config" will behave similarly to git internally. But relying
on this is dubious; you have to actually know how git treats
each value internally (e.g., int versus unsigned long),
which is not documented and is subject to change. And even
if you know it is "unsigned long", we do not have a
git-config option to match that behavior.
Furthermore, you may simply be asking git to store a value
on your behalf (e.g., configuration for a hook). In that
case, the relevant range check has nothing at all to do with
git, but rather with whatever scripting tools you are using
(and git has no way of knowing what the appropriate range is
there).
Not only is the range check useless, but it is actively
harmful, as there is no way at all for scripts to look
at config variables with large values. For instance, one
cannot reliably get the value of pack.packSizeLimit via
git-config. On an LP64 system, git happily uses a 64-bit
"unsigned long" internally to represent the value, but the
script cannot read any value over 2G.
Ideally, the "--int" option would simply represent an
arbitrarily large integer. For practical purposes, however,
a 64-bit integer is large enough, and is much easier to
implement (and if somebody overflows it, we will still
notice the problem, and not simply return garbage).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-09-08 16:40:02 +08:00
|
|
|
static int git_parse_int64(const char *value, int64_t *ret)
|
|
|
|
|
{
|
|
|
|
|
intmax_t tmp;
|
|
|
|
|
if (!git_parse_signed(value, &tmp, maximum_signed_value_of_type(int64_t)))
|
|
|
|
|
return 0;
|
|
|
|
|
*ret = tmp;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
2013-09-08 16:29:27 +08:00
|
|
|
int git_parse_ulong(const char *value, unsigned long *ret)
|
|
|
|
|
{
|
|
|
|
|
uintmax_t tmp;
|
|
|
|
|
if (!git_parse_unsigned(value, &tmp, maximum_unsigned_value_of_type(long)))
|
|
|
|
|
return 0;
|
|
|
|
|
*ret = tmp;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
2018-06-10 23:05:20 +08:00
|
|
|
int git_parse_ssize_t(const char *value, ssize_t *ret)
|
2017-04-12 02:13:57 +08:00
|
|
|
{
|
|
|
|
|
intmax_t tmp;
|
|
|
|
|
if (!git_parse_signed(value, &tmp, maximum_signed_value_of_type(ssize_t)))
|
|
|
|
|
return 0;
|
|
|
|
|
*ret = tmp;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
2014-04-17 00:51:47 +08:00
|
|
|
NORETURN
|
2013-09-08 16:38:22 +08:00
|
|
|
static void die_bad_number(const char *name, const char *value)
|
2008-02-21 08:00:32 +08:00
|
|
|
{
|
2019-06-21 18:18:07 +08:00
|
|
|
const char *error_type = (errno == ERANGE) ?
|
|
|
|
|
N_("out of range") : N_("invalid unit");
|
|
|
|
|
const char *bad_numeric = N_("bad numeric config value '%s' for '%s': %s");
|
2016-08-21 22:50:39 +08:00
|
|
|
|
2013-09-08 16:38:22 +08:00
|
|
|
if (!value)
|
|
|
|
|
value = "";
|
|
|
|
|
|
2019-06-21 18:18:09 +08:00
|
|
|
if (!strcmp(name, "GIT_TEST_GETTEXT_POISON"))
|
|
|
|
|
/*
|
|
|
|
|
* We explicitly *don't* use _() here since it would
|
|
|
|
|
* cause an infinite loop with _() needing to call
|
|
|
|
|
* use_gettext_poison(). This is why marked up
|
|
|
|
|
* translations with N_() above.
|
|
|
|
|
*/
|
|
|
|
|
die(bad_numeric, value, name, error_type);
|
|
|
|
|
|
i18n: config: unfold error messages marked for translation
Introduced in 473166b ("config: add 'origin_type' to config_source
struct", 2016-02-19), Git can inform the user about the origin of a
config error, but the implementation does not allow translators to
translate the keywords 'file', 'blob, 'standard input', and
'submodule-blob'. Moreover, for the second message, a reason for the
error is appended to the message, not allowing translators to translate
that reason either.
Unfold the message into several templates for each known origin_type.
That would result in better translation at the expense of code
verbosity.
Add enum config_oringin_type to ease management of the various
configuration origin types (blob, file, etc). Previously origin type
was considered from command line if cf->origin_type == NULL, i.e.,
uninitialized. Now we set origin_type to CONFIG_ORIGIN_CMDLINE in
git_config_from_parameters() and configset_add_value().
For error message in git_parse_source(), use xstrfmt() function to
prepare the message string, instead of doing something like it's done
for die_bad_number(), because intelligibility and code conciseness are
improved for that instance.
Signed-off-by: Vasco Almeida <vascomalmeida@sapo.pt>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-07-28 21:14:03 +08:00
|
|
|
if (!(cf && cf->name))
|
2019-06-21 18:18:07 +08:00
|
|
|
die(_(bad_numeric), value, name, _(error_type));
|
i18n: config: unfold error messages marked for translation
Introduced in 473166b ("config: add 'origin_type' to config_source
struct", 2016-02-19), Git can inform the user about the origin of a
config error, but the implementation does not allow translators to
translate the keywords 'file', 'blob, 'standard input', and
'submodule-blob'. Moreover, for the second message, a reason for the
error is appended to the message, not allowing translators to translate
that reason either.
Unfold the message into several templates for each known origin_type.
That would result in better translation at the expense of code
verbosity.
Add enum config_oringin_type to ease management of the various
configuration origin types (blob, file, etc). Previously origin type
was considered from command line if cf->origin_type == NULL, i.e.,
uninitialized. Now we set origin_type to CONFIG_ORIGIN_CMDLINE in
git_config_from_parameters() and configset_add_value().
For error message in git_parse_source(), use xstrfmt() function to
prepare the message string, instead of doing something like it's done
for die_bad_number(), because intelligibility and code conciseness are
improved for that instance.
Signed-off-by: Vasco Almeida <vascomalmeida@sapo.pt>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-07-28 21:14:03 +08:00
|
|
|
|
|
|
|
|
switch (cf->origin_type) {
|
|
|
|
|
case CONFIG_ORIGIN_BLOB:
|
2016-08-21 22:50:39 +08:00
|
|
|
die(_("bad numeric config value '%s' for '%s' in blob %s: %s"),
|
2019-06-21 18:18:07 +08:00
|
|
|
value, name, cf->name, _(error_type));
|
i18n: config: unfold error messages marked for translation
Introduced in 473166b ("config: add 'origin_type' to config_source
struct", 2016-02-19), Git can inform the user about the origin of a
config error, but the implementation does not allow translators to
translate the keywords 'file', 'blob, 'standard input', and
'submodule-blob'. Moreover, for the second message, a reason for the
error is appended to the message, not allowing translators to translate
that reason either.
Unfold the message into several templates for each known origin_type.
That would result in better translation at the expense of code
verbosity.
Add enum config_oringin_type to ease management of the various
configuration origin types (blob, file, etc). Previously origin type
was considered from command line if cf->origin_type == NULL, i.e.,
uninitialized. Now we set origin_type to CONFIG_ORIGIN_CMDLINE in
git_config_from_parameters() and configset_add_value().
For error message in git_parse_source(), use xstrfmt() function to
prepare the message string, instead of doing something like it's done
for die_bad_number(), because intelligibility and code conciseness are
improved for that instance.
Signed-off-by: Vasco Almeida <vascomalmeida@sapo.pt>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-07-28 21:14:03 +08:00
|
|
|
case CONFIG_ORIGIN_FILE:
|
2016-08-21 22:50:39 +08:00
|
|
|
die(_("bad numeric config value '%s' for '%s' in file %s: %s"),
|
2019-06-21 18:18:07 +08:00
|
|
|
value, name, cf->name, _(error_type));
|
i18n: config: unfold error messages marked for translation
Introduced in 473166b ("config: add 'origin_type' to config_source
struct", 2016-02-19), Git can inform the user about the origin of a
config error, but the implementation does not allow translators to
translate the keywords 'file', 'blob, 'standard input', and
'submodule-blob'. Moreover, for the second message, a reason for the
error is appended to the message, not allowing translators to translate
that reason either.
Unfold the message into several templates for each known origin_type.
That would result in better translation at the expense of code
verbosity.
Add enum config_oringin_type to ease management of the various
configuration origin types (blob, file, etc). Previously origin type
was considered from command line if cf->origin_type == NULL, i.e.,
uninitialized. Now we set origin_type to CONFIG_ORIGIN_CMDLINE in
git_config_from_parameters() and configset_add_value().
For error message in git_parse_source(), use xstrfmt() function to
prepare the message string, instead of doing something like it's done
for die_bad_number(), because intelligibility and code conciseness are
improved for that instance.
Signed-off-by: Vasco Almeida <vascomalmeida@sapo.pt>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-07-28 21:14:03 +08:00
|
|
|
case CONFIG_ORIGIN_STDIN:
|
2016-08-21 22:50:39 +08:00
|
|
|
die(_("bad numeric config value '%s' for '%s' in standard input: %s"),
|
2019-06-21 18:18:07 +08:00
|
|
|
value, name, _(error_type));
|
i18n: config: unfold error messages marked for translation
Introduced in 473166b ("config: add 'origin_type' to config_source
struct", 2016-02-19), Git can inform the user about the origin of a
config error, but the implementation does not allow translators to
translate the keywords 'file', 'blob, 'standard input', and
'submodule-blob'. Moreover, for the second message, a reason for the
error is appended to the message, not allowing translators to translate
that reason either.
Unfold the message into several templates for each known origin_type.
That would result in better translation at the expense of code
verbosity.
Add enum config_oringin_type to ease management of the various
configuration origin types (blob, file, etc). Previously origin type
was considered from command line if cf->origin_type == NULL, i.e.,
uninitialized. Now we set origin_type to CONFIG_ORIGIN_CMDLINE in
git_config_from_parameters() and configset_add_value().
For error message in git_parse_source(), use xstrfmt() function to
prepare the message string, instead of doing something like it's done
for die_bad_number(), because intelligibility and code conciseness are
improved for that instance.
Signed-off-by: Vasco Almeida <vascomalmeida@sapo.pt>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-07-28 21:14:03 +08:00
|
|
|
case CONFIG_ORIGIN_SUBMODULE_BLOB:
|
2016-08-21 22:50:39 +08:00
|
|
|
die(_("bad numeric config value '%s' for '%s' in submodule-blob %s: %s"),
|
2019-06-21 18:18:07 +08:00
|
|
|
value, name, cf->name, _(error_type));
|
i18n: config: unfold error messages marked for translation
Introduced in 473166b ("config: add 'origin_type' to config_source
struct", 2016-02-19), Git can inform the user about the origin of a
config error, but the implementation does not allow translators to
translate the keywords 'file', 'blob, 'standard input', and
'submodule-blob'. Moreover, for the second message, a reason for the
error is appended to the message, not allowing translators to translate
that reason either.
Unfold the message into several templates for each known origin_type.
That would result in better translation at the expense of code
verbosity.
Add enum config_oringin_type to ease management of the various
configuration origin types (blob, file, etc). Previously origin type
was considered from command line if cf->origin_type == NULL, i.e.,
uninitialized. Now we set origin_type to CONFIG_ORIGIN_CMDLINE in
git_config_from_parameters() and configset_add_value().
For error message in git_parse_source(), use xstrfmt() function to
prepare the message string, instead of doing something like it's done
for die_bad_number(), because intelligibility and code conciseness are
improved for that instance.
Signed-off-by: Vasco Almeida <vascomalmeida@sapo.pt>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-07-28 21:14:03 +08:00
|
|
|
case CONFIG_ORIGIN_CMDLINE:
|
2016-08-21 22:50:39 +08:00
|
|
|
die(_("bad numeric config value '%s' for '%s' in command line %s: %s"),
|
2019-06-21 18:18:07 +08:00
|
|
|
value, name, cf->name, _(error_type));
|
i18n: config: unfold error messages marked for translation
Introduced in 473166b ("config: add 'origin_type' to config_source
struct", 2016-02-19), Git can inform the user about the origin of a
config error, but the implementation does not allow translators to
translate the keywords 'file', 'blob, 'standard input', and
'submodule-blob'. Moreover, for the second message, a reason for the
error is appended to the message, not allowing translators to translate
that reason either.
Unfold the message into several templates for each known origin_type.
That would result in better translation at the expense of code
verbosity.
Add enum config_oringin_type to ease management of the various
configuration origin types (blob, file, etc). Previously origin type
was considered from command line if cf->origin_type == NULL, i.e.,
uninitialized. Now we set origin_type to CONFIG_ORIGIN_CMDLINE in
git_config_from_parameters() and configset_add_value().
For error message in git_parse_source(), use xstrfmt() function to
prepare the message string, instead of doing something like it's done
for die_bad_number(), because intelligibility and code conciseness are
improved for that instance.
Signed-off-by: Vasco Almeida <vascomalmeida@sapo.pt>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-07-28 21:14:03 +08:00
|
|
|
default:
|
2016-08-21 22:50:39 +08:00
|
|
|
die(_("bad numeric config value '%s' for '%s' in %s: %s"),
|
2019-06-21 18:18:07 +08:00
|
|
|
value, name, cf->name, _(error_type));
|
i18n: config: unfold error messages marked for translation
Introduced in 473166b ("config: add 'origin_type' to config_source
struct", 2016-02-19), Git can inform the user about the origin of a
config error, but the implementation does not allow translators to
translate the keywords 'file', 'blob, 'standard input', and
'submodule-blob'. Moreover, for the second message, a reason for the
error is appended to the message, not allowing translators to translate
that reason either.
Unfold the message into several templates for each known origin_type.
That would result in better translation at the expense of code
verbosity.
Add enum config_oringin_type to ease management of the various
configuration origin types (blob, file, etc). Previously origin type
was considered from command line if cf->origin_type == NULL, i.e.,
uninitialized. Now we set origin_type to CONFIG_ORIGIN_CMDLINE in
git_config_from_parameters() and configset_add_value().
For error message in git_parse_source(), use xstrfmt() function to
prepare the message string, instead of doing something like it's done
for die_bad_number(), because intelligibility and code conciseness are
improved for that instance.
Signed-off-by: Vasco Almeida <vascomalmeida@sapo.pt>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-07-28 21:14:03 +08:00
|
|
|
}
|
2008-02-21 08:00:32 +08:00
|
|
|
}
|
|
|
|
|
|
2007-07-12 21:32:26 +08:00
|
|
|
int git_config_int(const char *name, const char *value)
|
|
|
|
|
{
|
2013-09-08 16:33:08 +08:00
|
|
|
int ret;
|
|
|
|
|
if (!git_parse_int(value, &ret))
|
2013-09-08 16:38:22 +08:00
|
|
|
die_bad_number(name, value);
|
2007-07-12 21:32:26 +08:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
git-config: always treat --int as 64-bit internally
When you run "git config --int", the maximum size of integer
you get depends on how git was compiled, and what it
considers to be an "int".
This is almost useful, because your scripts calling "git
config" will behave similarly to git internally. But relying
on this is dubious; you have to actually know how git treats
each value internally (e.g., int versus unsigned long),
which is not documented and is subject to change. And even
if you know it is "unsigned long", we do not have a
git-config option to match that behavior.
Furthermore, you may simply be asking git to store a value
on your behalf (e.g., configuration for a hook). In that
case, the relevant range check has nothing at all to do with
git, but rather with whatever scripting tools you are using
(and git has no way of knowing what the appropriate range is
there).
Not only is the range check useless, but it is actively
harmful, as there is no way at all for scripts to look
at config variables with large values. For instance, one
cannot reliably get the value of pack.packSizeLimit via
git-config. On an LP64 system, git happily uses a 64-bit
"unsigned long" internally to represent the value, but the
script cannot read any value over 2G.
Ideally, the "--int" option would simply represent an
arbitrarily large integer. For practical purposes, however,
a 64-bit integer is large enough, and is much easier to
implement (and if somebody overflows it, we will still
notice the problem, and not simply return garbage).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-09-08 16:40:02 +08:00
|
|
|
int64_t git_config_int64(const char *name, const char *value)
|
|
|
|
|
{
|
|
|
|
|
int64_t ret;
|
|
|
|
|
if (!git_parse_int64(value, &ret))
|
|
|
|
|
die_bad_number(name, value);
|
2007-07-12 21:32:26 +08:00
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
unsigned long git_config_ulong(const char *name, const char *value)
|
|
|
|
|
{
|
|
|
|
|
unsigned long ret;
|
|
|
|
|
if (!git_parse_ulong(value, &ret))
|
2013-09-08 16:38:22 +08:00
|
|
|
die_bad_number(name, value);
|
2007-07-12 21:32:26 +08:00
|
|
|
return ret;
|
2005-10-11 07:31:08 +08:00
|
|
|
}
|
|
|
|
|
|
2017-04-12 02:13:57 +08:00
|
|
|
ssize_t git_config_ssize_t(const char *name, const char *value)
|
|
|
|
|
{
|
|
|
|
|
ssize_t ret;
|
|
|
|
|
if (!git_parse_ssize_t(value, &ret))
|
|
|
|
|
die_bad_number(name, value);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2017-08-08 02:20:47 +08:00
|
|
|
static int git_parse_maybe_bool_text(const char *value)
|
2005-10-11 07:31:08 +08:00
|
|
|
{
|
|
|
|
|
if (!value)
|
|
|
|
|
return 1;
|
|
|
|
|
if (!*value)
|
|
|
|
|
return 0;
|
2010-02-17 15:59:46 +08:00
|
|
|
if (!strcasecmp(value, "true")
|
|
|
|
|
|| !strcasecmp(value, "yes")
|
|
|
|
|
|| !strcasecmp(value, "on"))
|
2005-10-11 07:31:08 +08:00
|
|
|
return 1;
|
2010-02-17 15:59:46 +08:00
|
|
|
if (!strcasecmp(value, "false")
|
|
|
|
|
|| !strcasecmp(value, "no")
|
|
|
|
|
|| !strcasecmp(value, "off"))
|
2005-10-11 07:31:08 +08:00
|
|
|
return 0;
|
2010-02-17 15:59:46 +08:00
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
2017-08-08 02:20:47 +08:00
|
|
|
int git_parse_maybe_bool(const char *value)
|
2010-11-18 01:00:45 +08:00
|
|
|
{
|
2017-08-08 02:20:47 +08:00
|
|
|
int v = git_parse_maybe_bool_text(value);
|
2010-11-18 01:00:45 +08:00
|
|
|
if (0 <= v)
|
|
|
|
|
return v;
|
2013-09-08 16:33:08 +08:00
|
|
|
if (git_parse_int(value, &v))
|
2010-12-19 11:36:41 +08:00
|
|
|
return !!v;
|
2010-11-18 01:00:45 +08:00
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
2010-02-17 15:59:46 +08:00
|
|
|
int git_config_bool_or_int(const char *name, const char *value, int *is_bool)
|
|
|
|
|
{
|
2017-08-08 02:20:47 +08:00
|
|
|
int v = git_parse_maybe_bool_text(value);
|
2010-02-17 15:59:46 +08:00
|
|
|
if (0 <= v) {
|
|
|
|
|
*is_bool = 1;
|
|
|
|
|
return v;
|
|
|
|
|
}
|
2008-04-13 09:33:31 +08:00
|
|
|
*is_bool = 0;
|
2008-04-14 03:11:11 +08:00
|
|
|
return git_config_int(name, value);
|
2005-10-11 07:31:08 +08:00
|
|
|
}
|
|
|
|
|
|
2008-04-13 09:33:31 +08:00
|
|
|
int git_config_bool(const char *name, const char *value)
|
|
|
|
|
{
|
|
|
|
|
int discard;
|
2008-04-14 03:11:11 +08:00
|
|
|
return !!git_config_bool_or_int(name, value, &discard);
|
2008-04-13 09:33:31 +08:00
|
|
|
}
|
|
|
|
|
|
2008-02-16 13:00:24 +08:00
|
|
|
int git_config_string(const char **dest, const char *var, const char *value)
|
|
|
|
|
{
|
|
|
|
|
if (!value)
|
|
|
|
|
return config_error_nonbool(var);
|
|
|
|
|
*dest = xstrdup(value);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2009-11-18 01:24:25 +08:00
|
|
|
int git_config_pathname(const char **dest, const char *var, const char *value)
|
|
|
|
|
{
|
|
|
|
|
if (!value)
|
|
|
|
|
return config_error_nonbool(var);
|
2017-04-05 18:24:38 +08:00
|
|
|
*dest = expand_user_path(value, 0);
|
2009-11-18 01:24:25 +08:00
|
|
|
if (!*dest)
|
2014-08-07 19:59:12 +08:00
|
|
|
die(_("failed to expand user dir in: '%s'"), value);
|
2009-11-18 01:24:25 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2017-11-18 10:27:27 +08:00
|
|
|
int git_config_expiry_date(timestamp_t *timestamp, const char *var, const char *value)
|
|
|
|
|
{
|
|
|
|
|
if (!value)
|
|
|
|
|
return config_error_nonbool(var);
|
|
|
|
|
if (parse_expiry_date(value, timestamp))
|
|
|
|
|
return error(_("'%s' for '%s' is not a valid timestamp"),
|
|
|
|
|
value, var);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2018-04-10 08:18:28 +08:00
|
|
|
int git_config_color(char *dest, const char *var, const char *value)
|
|
|
|
|
{
|
|
|
|
|
if (!value)
|
|
|
|
|
return config_error_nonbool(var);
|
|
|
|
|
if (color_parse(value, dest) < 0)
|
|
|
|
|
return -1;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2018-10-31 02:40:04 +08:00
|
|
|
static int git_default_core_config(const char *var, const char *value, void *cb)
|
2005-10-11 07:31:08 +08:00
|
|
|
{
|
|
|
|
|
/* This needs a better name */
|
|
|
|
|
if (!strcmp(var, "core.filemode")) {
|
|
|
|
|
trust_executable_bit = git_config_bool(var, value);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2008-07-28 14:31:28 +08:00
|
|
|
if (!strcmp(var, "core.trustctime")) {
|
|
|
|
|
trust_ctime = git_config_bool(var, value);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2013-05-07 13:32:58 +08:00
|
|
|
if (!strcmp(var, "core.checkstat")) {
|
2013-01-22 15:49:22 +08:00
|
|
|
if (!strcasecmp(value, "default"))
|
|
|
|
|
check_stat = 1;
|
|
|
|
|
else if (!strcasecmp(value, "minimal"))
|
|
|
|
|
check_stat = 0;
|
|
|
|
|
}
|
2005-10-11 07:31:08 +08:00
|
|
|
|
2007-06-25 06:11:24 +08:00
|
|
|
if (!strcmp(var, "core.quotepath")) {
|
|
|
|
|
quote_path_fully = git_config_bool(var, value);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2007-03-03 05:11:30 +08:00
|
|
|
if (!strcmp(var, "core.symlinks")) {
|
|
|
|
|
has_symlinks = git_config_bool(var, value);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2008-03-22 07:52:46 +08:00
|
|
|
if (!strcmp(var, "core.ignorecase")) {
|
|
|
|
|
ignore_case = git_config_bool(var, value);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2011-10-07 02:22:24 +08:00
|
|
|
if (!strcmp(var, "core.attributesfile"))
|
|
|
|
|
return git_config_pathname(&git_attributes_file, var, value);
|
|
|
|
|
|
2016-05-05 06:58:12 +08:00
|
|
|
if (!strcmp(var, "core.hookspath"))
|
|
|
|
|
return git_config_pathname(&git_hooks_path, var, value);
|
|
|
|
|
|
2007-01-07 18:00:28 +08:00
|
|
|
if (!strcmp(var, "core.bare")) {
|
|
|
|
|
is_bare_repository_cfg = git_config_bool(var, value);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2006-02-09 13:15:24 +08:00
|
|
|
if (!strcmp(var, "core.ignorestat")) {
|
|
|
|
|
assume_unchanged = git_config_bool(var, value);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2006-05-02 15:40:24 +08:00
|
|
|
if (!strcmp(var, "core.prefersymlinkrefs")) {
|
|
|
|
|
prefer_symlink_refs = git_config_bool(var, value);
|
2005-11-16 02:24:19 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2006-05-17 17:55:40 +08:00
|
|
|
if (!strcmp(var, "core.logallrefupdates")) {
|
2017-01-27 18:09:47 +08:00
|
|
|
if (value && !strcasecmp(value, "always"))
|
|
|
|
|
log_all_ref_updates = LOG_REFS_ALWAYS;
|
|
|
|
|
else if (git_config_bool(var, value))
|
|
|
|
|
log_all_ref_updates = LOG_REFS_NORMAL;
|
|
|
|
|
else
|
|
|
|
|
log_all_ref_updates = LOG_REFS_NONE;
|
2006-05-17 17:55:40 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2006-03-21 10:45:47 +08:00
|
|
|
if (!strcmp(var, "core.warnambiguousrefs")) {
|
|
|
|
|
warn_ambiguous_refs = git_config_bool(var, value);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2011-03-21 13:26:24 +08:00
|
|
|
if (!strcmp(var, "core.abbrev")) {
|
2016-11-02 09:34:07 +08:00
|
|
|
if (!value)
|
|
|
|
|
return config_error_nonbool(var);
|
|
|
|
|
if (!strcasecmp(value, "auto"))
|
|
|
|
|
default_abbrev = -1;
|
|
|
|
|
else {
|
|
|
|
|
int abbrev = git_config_int(var, value);
|
2019-08-19 04:04:13 +08:00
|
|
|
if (abbrev < minimum_abbrev || abbrev > the_hash_algo->hexsz)
|
2018-07-21 15:49:27 +08:00
|
|
|
return error(_("abbrev length out of range: %d"), abbrev);
|
2016-11-02 09:34:07 +08:00
|
|
|
default_abbrev = abbrev;
|
|
|
|
|
}
|
2010-10-29 02:28:04 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2016-09-27 20:38:01 +08:00
|
|
|
if (!strcmp(var, "core.disambiguate"))
|
|
|
|
|
return set_disambiguate_hint_config(var, value);
|
|
|
|
|
|
Custom compression levels for objects and packs
Add config variables pack.compression and core.loosecompression ,
and switch --compression=level to pack-objects.
Loose objects will be compressed using core.loosecompression if set,
else core.compression if set, else Z_BEST_SPEED.
Packed objects will be compressed using --compression=level if seen,
else pack.compression if set, else core.compression if set,
else Z_DEFAULT_COMPRESSION. This is the "pack compression level".
Loose objects added to a pack undeltified will be recompressed
to the pack compression level if it is unequal to the current
loose compression level by the preceding rules, or if the loose
object was written while core.legacyheaders = true. Newly
deltified loose objects are always compressed to the current
pack compression level.
Previously packed objects added to a pack are recompressed
to the current pack compression level exactly when their
deltification status changes, since the previous pack data
cannot be reused.
In either case, the --no-reuse-object switch from the first
patch below will always force recompression to the current pack
compression level, instead of assuming the pack compression level
hasn't changed and pack data can be reused when possible.
This applies on top of the following patches from Nicolas Pitre:
[PATCH] allow for undeltified objects not to be reused
[PATCH] make "repack -f" imply "pack-objects --no-reuse-object"
Signed-off-by: Dana L. How <danahow@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-05-10 04:56:50 +08:00
|
|
|
if (!strcmp(var, "core.loosecompression")) {
|
2006-07-04 04:11:47 +08:00
|
|
|
int level = git_config_int(var, value);
|
|
|
|
|
if (level == -1)
|
|
|
|
|
level = Z_DEFAULT_COMPRESSION;
|
|
|
|
|
else if (level < 0 || level > Z_BEST_COMPRESSION)
|
2014-08-07 19:59:12 +08:00
|
|
|
die(_("bad zlib compression level %d"), level);
|
2006-07-04 04:11:47 +08:00
|
|
|
zlib_compression_level = level;
|
Custom compression levels for objects and packs
Add config variables pack.compression and core.loosecompression ,
and switch --compression=level to pack-objects.
Loose objects will be compressed using core.loosecompression if set,
else core.compression if set, else Z_BEST_SPEED.
Packed objects will be compressed using --compression=level if seen,
else pack.compression if set, else core.compression if set,
else Z_DEFAULT_COMPRESSION. This is the "pack compression level".
Loose objects added to a pack undeltified will be recompressed
to the pack compression level if it is unequal to the current
loose compression level by the preceding rules, or if the loose
object was written while core.legacyheaders = true. Newly
deltified loose objects are always compressed to the current
pack compression level.
Previously packed objects added to a pack are recompressed
to the current pack compression level exactly when their
deltification status changes, since the previous pack data
cannot be reused.
In either case, the --no-reuse-object switch from the first
patch below will always force recompression to the current pack
compression level, instead of assuming the pack compression level
hasn't changed and pack data can be reused when possible.
This applies on top of the following patches from Nicolas Pitre:
[PATCH] allow for undeltified objects not to be reused
[PATCH] make "repack -f" imply "pack-objects --no-reuse-object"
Signed-off-by: Dana L. How <danahow@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-05-10 04:56:50 +08:00
|
|
|
zlib_compression_seen = 1;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!strcmp(var, "core.compression")) {
|
|
|
|
|
int level = git_config_int(var, value);
|
|
|
|
|
if (level == -1)
|
|
|
|
|
level = Z_DEFAULT_COMPRESSION;
|
|
|
|
|
else if (level < 0 || level > Z_BEST_COMPRESSION)
|
2014-08-07 19:59:12 +08:00
|
|
|
die(_("bad zlib compression level %d"), level);
|
Custom compression levels for objects and packs
Add config variables pack.compression and core.loosecompression ,
and switch --compression=level to pack-objects.
Loose objects will be compressed using core.loosecompression if set,
else core.compression if set, else Z_BEST_SPEED.
Packed objects will be compressed using --compression=level if seen,
else pack.compression if set, else core.compression if set,
else Z_DEFAULT_COMPRESSION. This is the "pack compression level".
Loose objects added to a pack undeltified will be recompressed
to the pack compression level if it is unequal to the current
loose compression level by the preceding rules, or if the loose
object was written while core.legacyheaders = true. Newly
deltified loose objects are always compressed to the current
pack compression level.
Previously packed objects added to a pack are recompressed
to the current pack compression level exactly when their
deltification status changes, since the previous pack data
cannot be reused.
In either case, the --no-reuse-object switch from the first
patch below will always force recompression to the current pack
compression level, instead of assuming the pack compression level
hasn't changed and pack data can be reused when possible.
This applies on top of the following patches from Nicolas Pitre:
[PATCH] allow for undeltified objects not to be reused
[PATCH] make "repack -f" imply "pack-objects --no-reuse-object"
Signed-off-by: Dana L. How <danahow@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-05-10 04:56:50 +08:00
|
|
|
core_compression_level = level;
|
|
|
|
|
core_compression_seen = 1;
|
|
|
|
|
if (!zlib_compression_seen)
|
|
|
|
|
zlib_compression_level = level;
|
2016-11-16 09:42:40 +08:00
|
|
|
if (!pack_compression_seen)
|
|
|
|
|
pack_compression_level = level;
|
2006-07-04 04:11:47 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-23 15:34:28 +08:00
|
|
|
if (!strcmp(var, "core.packedgitwindowsize")) {
|
2007-02-15 05:20:41 +08:00
|
|
|
int pgsz_x2 = getpagesize() * 2;
|
Support sizes >=2G in various config options accepting 'g' sizes.
The config options core.packedGitWindowSize, core.packedGitLimit,
core.deltaBaseCacheLimit, core.bigFileThreshold, pack.windowMemory and
pack.packSizeLimit all claim to support suffixes up to and including
'g'. This implies that they should accept sizes >=2G on 64-bit
systems: certainly, specifying a size of 3g should not silently be
translated to zero or transformed into a large negative value due to
integer overflow. However, due to use of git_config_int() rather than
git_config_ulong(), that is exactly what happens:
% git config core.bigFileThreshold 2g
% git gc --aggressive # with extra debugging code to print out
# core.bigfilethreshold after parsing
bigfilethreshold: -2147483648
[...]
This is probably irrelevant for core.deltaBaseCacheLimit, but is
problematic for the other values. (It is particularly problematic for
core.packedGitLimit, which can't even be set to its default value in
the config file due to this bug.)
This fixes things for 32-bit platforms as well. They get the usual bad
config error if an overlarge value is specified, e.g.:
fatal: bad config value for 'core.bigfilethreshold' in /home/nix/.gitconfig
This is detected in all cases, even if the 32-bit platform has no size
larger than 'long'. For signed integral configuration values, we also
detect the case where the value is too large for the signed type but
not the unsigned type.
Signed-off-by: Nick Alcock <nix@esperi.org.uk>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-11-02 23:46:23 +08:00
|
|
|
packed_git_window_size = git_config_ulong(var, value);
|
2007-02-15 05:20:41 +08:00
|
|
|
|
|
|
|
|
/* This value must be multiple of (pagesize * 2) */
|
|
|
|
|
packed_git_window_size /= pgsz_x2;
|
|
|
|
|
if (packed_git_window_size < 1)
|
|
|
|
|
packed_git_window_size = 1;
|
|
|
|
|
packed_git_window_size *= pgsz_x2;
|
2006-12-23 15:34:28 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2011-04-06 01:44:11 +08:00
|
|
|
if (!strcmp(var, "core.bigfilethreshold")) {
|
Support sizes >=2G in various config options accepting 'g' sizes.
The config options core.packedGitWindowSize, core.packedGitLimit,
core.deltaBaseCacheLimit, core.bigFileThreshold, pack.windowMemory and
pack.packSizeLimit all claim to support suffixes up to and including
'g'. This implies that they should accept sizes >=2G on 64-bit
systems: certainly, specifying a size of 3g should not silently be
translated to zero or transformed into a large negative value due to
integer overflow. However, due to use of git_config_int() rather than
git_config_ulong(), that is exactly what happens:
% git config core.bigFileThreshold 2g
% git gc --aggressive # with extra debugging code to print out
# core.bigfilethreshold after parsing
bigfilethreshold: -2147483648
[...]
This is probably irrelevant for core.deltaBaseCacheLimit, but is
problematic for the other values. (It is particularly problematic for
core.packedGitLimit, which can't even be set to its default value in
the config file due to this bug.)
This fixes things for 32-bit platforms as well. They get the usual bad
config error if an overlarge value is specified, e.g.:
fatal: bad config value for 'core.bigfilethreshold' in /home/nix/.gitconfig
This is detected in all cases, even if the 32-bit platform has no size
larger than 'long'. For signed integral configuration values, we also
detect the case where the value is too large for the signed type but
not the unsigned type.
Signed-off-by: Nick Alcock <nix@esperi.org.uk>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-11-02 23:46:23 +08:00
|
|
|
big_file_threshold = git_config_ulong(var, value);
|
2011-04-06 01:44:11 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-23 15:33:35 +08:00
|
|
|
if (!strcmp(var, "core.packedgitlimit")) {
|
Support sizes >=2G in various config options accepting 'g' sizes.
The config options core.packedGitWindowSize, core.packedGitLimit,
core.deltaBaseCacheLimit, core.bigFileThreshold, pack.windowMemory and
pack.packSizeLimit all claim to support suffixes up to and including
'g'. This implies that they should accept sizes >=2G on 64-bit
systems: certainly, specifying a size of 3g should not silently be
translated to zero or transformed into a large negative value due to
integer overflow. However, due to use of git_config_int() rather than
git_config_ulong(), that is exactly what happens:
% git config core.bigFileThreshold 2g
% git gc --aggressive # with extra debugging code to print out
# core.bigfilethreshold after parsing
bigfilethreshold: -2147483648
[...]
This is probably irrelevant for core.deltaBaseCacheLimit, but is
problematic for the other values. (It is particularly problematic for
core.packedGitLimit, which can't even be set to its default value in
the config file due to this bug.)
This fixes things for 32-bit platforms as well. They get the usual bad
config error if an overlarge value is specified, e.g.:
fatal: bad config value for 'core.bigfilethreshold' in /home/nix/.gitconfig
This is detected in all cases, even if the 32-bit platform has no size
larger than 'long'. For signed integral configuration values, we also
detect the case where the value is too large for the signed type but
not the unsigned type.
Signed-off-by: Nick Alcock <nix@esperi.org.uk>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-11-02 23:46:23 +08:00
|
|
|
packed_git_limit = git_config_ulong(var, value);
|
2006-12-23 15:33:35 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2007-03-19 13:14:37 +08:00
|
|
|
if (!strcmp(var, "core.deltabasecachelimit")) {
|
Support sizes >=2G in various config options accepting 'g' sizes.
The config options core.packedGitWindowSize, core.packedGitLimit,
core.deltaBaseCacheLimit, core.bigFileThreshold, pack.windowMemory and
pack.packSizeLimit all claim to support suffixes up to and including
'g'. This implies that they should accept sizes >=2G on 64-bit
systems: certainly, specifying a size of 3g should not silently be
translated to zero or transformed into a large negative value due to
integer overflow. However, due to use of git_config_int() rather than
git_config_ulong(), that is exactly what happens:
% git config core.bigFileThreshold 2g
% git gc --aggressive # with extra debugging code to print out
# core.bigfilethreshold after parsing
bigfilethreshold: -2147483648
[...]
This is probably irrelevant for core.deltaBaseCacheLimit, but is
problematic for the other values. (It is particularly problematic for
core.packedGitLimit, which can't even be set to its default value in
the config file due to this bug.)
This fixes things for 32-bit platforms as well. They get the usual bad
config error if an overlarge value is specified, e.g.:
fatal: bad config value for 'core.bigfilethreshold' in /home/nix/.gitconfig
This is detected in all cases, even if the 32-bit platform has no size
larger than 'long'. For signed integral configuration values, we also
detect the case where the value is too large for the signed type but
not the unsigned type.
Signed-off-by: Nick Alcock <nix@esperi.org.uk>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-11-02 23:46:23 +08:00
|
|
|
delta_base_cache_limit = git_config_ulong(var, value);
|
2007-03-19 13:14:37 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
Lazy man's auto-CRLF
It currently does NOT know about file attributes, so it does its
conversion purely based on content. Maybe that is more in the "git
philosophy" anyway, since content is king, but I think we should try to do
the file attributes to turn it off on demand.
Anyway, BY DEFAULT it is off regardless, because it requires a
[core]
AutoCRLF = true
in your config file to be enabled. We could make that the default for
Windows, of course, the same way we do some other things (filemode etc).
But you can actually enable it on UNIX, and it will cause:
- "git update-index" will write blobs without CRLF
- "git diff" will diff working tree files without CRLF
- "git checkout" will write files to the working tree _with_ CRLF
and things work fine.
Funnily, it actually shows an odd file in git itself:
git clone -n git test-crlf
cd test-crlf
git config core.autocrlf true
git checkout
git diff
shows a diff for "Documentation/docbook-xsl.css". Why? Because we have
actually checked in that file *with* CRLF! So when "core.autocrlf" is
true, we'll always generate a *different* hash for it in the index,
because the index hash will be for the content _without_ CRLF.
Is this complete? I dunno. It seems to work for me. It doesn't use the
filename at all right now, and that's probably a deficiency (we could
certainly make the "is_binary()" heuristics also take standard filename
heuristics into account).
I don't pass in the filename at all for the "index_fd()" case
(git-update-index), so that would need to be passed around, but this
actually works fine.
NOTE NOTE NOTE! The "is_binary()" heuristics are totally made-up by yours
truly. I will not guarantee that they work at all reasonable. Caveat
emptor. But it _is_ simple, and it _is_ safe, since it's all off by
default.
The patch is pretty simple - the biggest part is the new "convert.c" file,
but even that is really just basic stuff that anybody can write in
"Teaching C 101" as a final project for their first class in programming.
Not to say that it's bug-free, of course - but at least we're not talking
about rocket surgery here.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-14 03:07:23 +08:00
|
|
|
if (!strcmp(var, "core.autocrlf")) {
|
2007-02-14 10:16:12 +08:00
|
|
|
if (value && !strcasecmp(value, "input")) {
|
2010-05-20 04:43:10 +08:00
|
|
|
auto_crlf = AUTO_CRLF_INPUT;
|
2007-02-14 10:16:12 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
Lazy man's auto-CRLF
It currently does NOT know about file attributes, so it does its
conversion purely based on content. Maybe that is more in the "git
philosophy" anyway, since content is king, but I think we should try to do
the file attributes to turn it off on demand.
Anyway, BY DEFAULT it is off regardless, because it requires a
[core]
AutoCRLF = true
in your config file to be enabled. We could make that the default for
Windows, of course, the same way we do some other things (filemode etc).
But you can actually enable it on UNIX, and it will cause:
- "git update-index" will write blobs without CRLF
- "git diff" will diff working tree files without CRLF
- "git checkout" will write files to the working tree _with_ CRLF
and things work fine.
Funnily, it actually shows an odd file in git itself:
git clone -n git test-crlf
cd test-crlf
git config core.autocrlf true
git checkout
git diff
shows a diff for "Documentation/docbook-xsl.css". Why? Because we have
actually checked in that file *with* CRLF! So when "core.autocrlf" is
true, we'll always generate a *different* hash for it in the index,
because the index hash will be for the content _without_ CRLF.
Is this complete? I dunno. It seems to work for me. It doesn't use the
filename at all right now, and that's probably a deficiency (we could
certainly make the "is_binary()" heuristics also take standard filename
heuristics into account).
I don't pass in the filename at all for the "index_fd()" case
(git-update-index), so that would need to be passed around, but this
actually works fine.
NOTE NOTE NOTE! The "is_binary()" heuristics are totally made-up by yours
truly. I will not guarantee that they work at all reasonable. Caveat
emptor. But it _is_ simple, and it _is_ safe, since it's all off by
default.
The patch is pretty simple - the biggest part is the new "convert.c" file,
but even that is really just basic stuff that anybody can write in
"Teaching C 101" as a final project for their first class in programming.
Not to say that it's bug-free, of course - but at least we're not talking
about rocket surgery here.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-14 03:07:23 +08:00
|
|
|
auto_crlf = git_config_bool(var, value);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
safecrlf: Add mechanism to warn about irreversible crlf conversions
CRLF conversion bears a slight chance of corrupting data.
autocrlf=true will convert CRLF to LF during commit and LF to
CRLF during checkout. A file that contains a mixture of LF and
CRLF before the commit cannot be recreated by git. For text
files this is the right thing to do: it corrects line endings
such that we have only LF line endings in the repository.
But for binary files that are accidentally classified as text the
conversion can corrupt data.
If you recognize such corruption early you can easily fix it by
setting the conversion type explicitly in .gitattributes. Right
after committing you still have the original file in your work
tree and this file is not yet corrupted. You can explicitly tell
git that this file is binary and git will handle the file
appropriately.
Unfortunately, the desired effect of cleaning up text files with
mixed line endings and the undesired effect of corrupting binary
files cannot be distinguished. In both cases CRLFs are removed
in an irreversible way. For text files this is the right thing
to do because CRLFs are line endings, while for binary files
converting CRLFs corrupts data.
This patch adds a mechanism that can either warn the user about
an irreversible conversion or can even refuse to convert. The
mechanism is controlled by the variable core.safecrlf, with the
following values:
- false: disable safecrlf mechanism
- warn: warn about irreversible conversions
- true: refuse irreversible conversions
The default is to warn. Users are only affected by this default
if core.autocrlf is set. But the current default of git is to
leave core.autocrlf unset, so users will not see warnings unless
they deliberately chose to activate the autocrlf mechanism.
The safecrlf mechanism's details depend on the git command. The
general principles when safecrlf is active (not false) are:
- we warn/error out if files in the work tree can modified in an
irreversible way without giving the user a chance to backup the
original file.
- for read-only operations that do not modify files in the work tree
we do not not print annoying warnings.
There are exceptions. Even though...
- "git add" itself does not touch the files in the work tree, the
next checkout would, so the safety triggers;
- "git apply" to update a text file with a patch does touch the files
in the work tree, but the operation is about text files and CRLF
conversion is about fixing the line ending inconsistencies, so the
safety does not trigger;
- "git diff" itself does not touch the files in the work tree, it is
often run to inspect the changes you intend to next "git add". To
catch potential problems early, safety triggers.
The concept of a safety check was originally proposed in a similar
way by Linus Torvalds. Thanks to Dimitry Potapov for insisting
on getting the naked LF/autocrlf=true case right.
Signed-off-by: Steffen Prohaska <prohaska@zib.de>
2008-02-06 19:25:58 +08:00
|
|
|
if (!strcmp(var, "core.safecrlf")) {
|
2018-01-14 06:49:31 +08:00
|
|
|
int eol_rndtrp_die;
|
safecrlf: Add mechanism to warn about irreversible crlf conversions
CRLF conversion bears a slight chance of corrupting data.
autocrlf=true will convert CRLF to LF during commit and LF to
CRLF during checkout. A file that contains a mixture of LF and
CRLF before the commit cannot be recreated by git. For text
files this is the right thing to do: it corrects line endings
such that we have only LF line endings in the repository.
But for binary files that are accidentally classified as text the
conversion can corrupt data.
If you recognize such corruption early you can easily fix it by
setting the conversion type explicitly in .gitattributes. Right
after committing you still have the original file in your work
tree and this file is not yet corrupted. You can explicitly tell
git that this file is binary and git will handle the file
appropriately.
Unfortunately, the desired effect of cleaning up text files with
mixed line endings and the undesired effect of corrupting binary
files cannot be distinguished. In both cases CRLFs are removed
in an irreversible way. For text files this is the right thing
to do because CRLFs are line endings, while for binary files
converting CRLFs corrupts data.
This patch adds a mechanism that can either warn the user about
an irreversible conversion or can even refuse to convert. The
mechanism is controlled by the variable core.safecrlf, with the
following values:
- false: disable safecrlf mechanism
- warn: warn about irreversible conversions
- true: refuse irreversible conversions
The default is to warn. Users are only affected by this default
if core.autocrlf is set. But the current default of git is to
leave core.autocrlf unset, so users will not see warnings unless
they deliberately chose to activate the autocrlf mechanism.
The safecrlf mechanism's details depend on the git command. The
general principles when safecrlf is active (not false) are:
- we warn/error out if files in the work tree can modified in an
irreversible way without giving the user a chance to backup the
original file.
- for read-only operations that do not modify files in the work tree
we do not not print annoying warnings.
There are exceptions. Even though...
- "git add" itself does not touch the files in the work tree, the
next checkout would, so the safety triggers;
- "git apply" to update a text file with a patch does touch the files
in the work tree, but the operation is about text files and CRLF
conversion is about fixing the line ending inconsistencies, so the
safety does not trigger;
- "git diff" itself does not touch the files in the work tree, it is
often run to inspect the changes you intend to next "git add". To
catch potential problems early, safety triggers.
The concept of a safety check was originally proposed in a similar
way by Linus Torvalds. Thanks to Dimitry Potapov for insisting
on getting the naked LF/autocrlf=true case right.
Signed-off-by: Steffen Prohaska <prohaska@zib.de>
2008-02-06 19:25:58 +08:00
|
|
|
if (value && !strcasecmp(value, "warn")) {
|
2018-01-14 06:49:31 +08:00
|
|
|
global_conv_flags_eol = CONV_EOL_RNDTRP_WARN;
|
safecrlf: Add mechanism to warn about irreversible crlf conversions
CRLF conversion bears a slight chance of corrupting data.
autocrlf=true will convert CRLF to LF during commit and LF to
CRLF during checkout. A file that contains a mixture of LF and
CRLF before the commit cannot be recreated by git. For text
files this is the right thing to do: it corrects line endings
such that we have only LF line endings in the repository.
But for binary files that are accidentally classified as text the
conversion can corrupt data.
If you recognize such corruption early you can easily fix it by
setting the conversion type explicitly in .gitattributes. Right
after committing you still have the original file in your work
tree and this file is not yet corrupted. You can explicitly tell
git that this file is binary and git will handle the file
appropriately.
Unfortunately, the desired effect of cleaning up text files with
mixed line endings and the undesired effect of corrupting binary
files cannot be distinguished. In both cases CRLFs are removed
in an irreversible way. For text files this is the right thing
to do because CRLFs are line endings, while for binary files
converting CRLFs corrupts data.
This patch adds a mechanism that can either warn the user about
an irreversible conversion or can even refuse to convert. The
mechanism is controlled by the variable core.safecrlf, with the
following values:
- false: disable safecrlf mechanism
- warn: warn about irreversible conversions
- true: refuse irreversible conversions
The default is to warn. Users are only affected by this default
if core.autocrlf is set. But the current default of git is to
leave core.autocrlf unset, so users will not see warnings unless
they deliberately chose to activate the autocrlf mechanism.
The safecrlf mechanism's details depend on the git command. The
general principles when safecrlf is active (not false) are:
- we warn/error out if files in the work tree can modified in an
irreversible way without giving the user a chance to backup the
original file.
- for read-only operations that do not modify files in the work tree
we do not not print annoying warnings.
There are exceptions. Even though...
- "git add" itself does not touch the files in the work tree, the
next checkout would, so the safety triggers;
- "git apply" to update a text file with a patch does touch the files
in the work tree, but the operation is about text files and CRLF
conversion is about fixing the line ending inconsistencies, so the
safety does not trigger;
- "git diff" itself does not touch the files in the work tree, it is
often run to inspect the changes you intend to next "git add". To
catch potential problems early, safety triggers.
The concept of a safety check was originally proposed in a similar
way by Linus Torvalds. Thanks to Dimitry Potapov for insisting
on getting the naked LF/autocrlf=true case right.
Signed-off-by: Steffen Prohaska <prohaska@zib.de>
2008-02-06 19:25:58 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
2018-01-14 06:49:31 +08:00
|
|
|
eol_rndtrp_die = git_config_bool(var, value);
|
|
|
|
|
global_conv_flags_eol = eol_rndtrp_die ?
|
2018-06-05 04:17:42 +08:00
|
|
|
CONV_EOL_RNDTRP_DIE : 0;
|
safecrlf: Add mechanism to warn about irreversible crlf conversions
CRLF conversion bears a slight chance of corrupting data.
autocrlf=true will convert CRLF to LF during commit and LF to
CRLF during checkout. A file that contains a mixture of LF and
CRLF before the commit cannot be recreated by git. For text
files this is the right thing to do: it corrects line endings
such that we have only LF line endings in the repository.
But for binary files that are accidentally classified as text the
conversion can corrupt data.
If you recognize such corruption early you can easily fix it by
setting the conversion type explicitly in .gitattributes. Right
after committing you still have the original file in your work
tree and this file is not yet corrupted. You can explicitly tell
git that this file is binary and git will handle the file
appropriately.
Unfortunately, the desired effect of cleaning up text files with
mixed line endings and the undesired effect of corrupting binary
files cannot be distinguished. In both cases CRLFs are removed
in an irreversible way. For text files this is the right thing
to do because CRLFs are line endings, while for binary files
converting CRLFs corrupts data.
This patch adds a mechanism that can either warn the user about
an irreversible conversion or can even refuse to convert. The
mechanism is controlled by the variable core.safecrlf, with the
following values:
- false: disable safecrlf mechanism
- warn: warn about irreversible conversions
- true: refuse irreversible conversions
The default is to warn. Users are only affected by this default
if core.autocrlf is set. But the current default of git is to
leave core.autocrlf unset, so users will not see warnings unless
they deliberately chose to activate the autocrlf mechanism.
The safecrlf mechanism's details depend on the git command. The
general principles when safecrlf is active (not false) are:
- we warn/error out if files in the work tree can modified in an
irreversible way without giving the user a chance to backup the
original file.
- for read-only operations that do not modify files in the work tree
we do not not print annoying warnings.
There are exceptions. Even though...
- "git add" itself does not touch the files in the work tree, the
next checkout would, so the safety triggers;
- "git apply" to update a text file with a patch does touch the files
in the work tree, but the operation is about text files and CRLF
conversion is about fixing the line ending inconsistencies, so the
safety does not trigger;
- "git diff" itself does not touch the files in the work tree, it is
often run to inspect the changes you intend to next "git add". To
catch potential problems early, safety triggers.
The concept of a safety check was originally proposed in a similar
way by Linus Torvalds. Thanks to Dimitry Potapov for insisting
on getting the naked LF/autocrlf=true case right.
Signed-off-by: Steffen Prohaska <prohaska@zib.de>
2008-02-06 19:25:58 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2010-06-05 03:29:08 +08:00
|
|
|
if (!strcmp(var, "core.eol")) {
|
|
|
|
|
if (value && !strcasecmp(value, "lf"))
|
2011-05-10 03:52:12 +08:00
|
|
|
core_eol = EOL_LF;
|
2010-06-05 03:29:08 +08:00
|
|
|
else if (value && !strcasecmp(value, "crlf"))
|
2011-05-10 03:52:12 +08:00
|
|
|
core_eol = EOL_CRLF;
|
2010-06-05 03:29:08 +08:00
|
|
|
else if (value && !strcasecmp(value, "native"))
|
2011-05-10 03:52:12 +08:00
|
|
|
core_eol = EOL_NATIVE;
|
2010-06-05 03:29:08 +08:00
|
|
|
else
|
2011-05-10 03:52:12 +08:00
|
|
|
core_eol = EOL_UNSET;
|
2010-06-05 03:29:08 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2018-04-16 02:16:10 +08:00
|
|
|
if (!strcmp(var, "core.checkroundtripencoding")) {
|
|
|
|
|
check_roundtrip_encoding = xstrdup(value);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2009-10-09 18:21:57 +08:00
|
|
|
if (!strcmp(var, "core.notesref")) {
|
|
|
|
|
notes_ref_name = xstrdup(value);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2008-06-19 05:37:18 +08:00
|
|
|
if (!strcmp(var, "core.editor"))
|
|
|
|
|
return git_config_string(&editor_program, var, value);
|
|
|
|
|
|
2013-01-17 03:18:48 +08:00
|
|
|
if (!strcmp(var, "core.commentchar")) {
|
2014-07-24 12:42:39 +08:00
|
|
|
if (!value)
|
|
|
|
|
return config_error_nonbool(var);
|
2014-07-29 02:30:41 +08:00
|
|
|
else if (!strcasecmp(value, "auto"))
|
2014-05-17 09:52:23 +08:00
|
|
|
auto_comment_line_char = 1;
|
2014-07-29 02:30:41 +08:00
|
|
|
else if (value[0] && !value[1]) {
|
2014-07-24 12:42:39 +08:00
|
|
|
comment_line_char = value[0];
|
2014-05-17 09:52:23 +08:00
|
|
|
auto_comment_line_char = 0;
|
2014-05-17 09:52:22 +08:00
|
|
|
} else
|
2018-07-21 15:49:27 +08:00
|
|
|
return error(_("core.commentChar should only be one character"));
|
2014-05-17 09:52:22 +08:00
|
|
|
return 0;
|
2013-01-17 03:18:48 +08:00
|
|
|
}
|
|
|
|
|
|
2010-08-30 21:38:38 +08:00
|
|
|
if (!strcmp(var, "core.askpass"))
|
|
|
|
|
return git_config_string(&askpass_program, var, value);
|
|
|
|
|
|
2008-06-19 05:37:18 +08:00
|
|
|
if (!strcmp(var, "core.excludesfile"))
|
2009-11-18 01:24:25 +08:00
|
|
|
return git_config_pathname(&excludes_file, var, value);
|
2008-06-19 05:37:18 +08:00
|
|
|
|
|
|
|
|
if (!strcmp(var, "core.whitespace")) {
|
|
|
|
|
if (!value)
|
|
|
|
|
return config_error_nonbool(var);
|
|
|
|
|
whitespace_rule_cfg = parse_whitespace_rule(value);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2008-06-19 06:18:44 +08:00
|
|
|
if (!strcmp(var, "core.fsyncobjectfiles")) {
|
|
|
|
|
fsync_object_files = git_config_bool(var, value);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2008-11-14 08:36:30 +08:00
|
|
|
if (!strcmp(var, "core.preloadindex")) {
|
|
|
|
|
core_preload_index = git_config_bool(var, value);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2009-04-28 06:32:25 +08:00
|
|
|
if (!strcmp(var, "core.createobject")) {
|
|
|
|
|
if (!strcmp(value, "rename"))
|
|
|
|
|
object_creation_mode = OBJECT_CREATION_USES_RENAMES;
|
|
|
|
|
else if (!strcmp(value, "link"))
|
|
|
|
|
object_creation_mode = OBJECT_CREATION_USES_HARDLINKS;
|
|
|
|
|
else
|
2014-08-07 19:59:12 +08:00
|
|
|
die(_("invalid mode for object creation: %s"), value);
|
2009-04-25 17:57:14 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2009-08-20 21:47:08 +08:00
|
|
|
if (!strcmp(var, "core.sparsecheckout")) {
|
|
|
|
|
core_apply_sparse_checkout = git_config_bool(var, value);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2019-11-22 06:04:40 +08:00
|
|
|
if (!strcmp(var, "core.sparsecheckoutcone")) {
|
|
|
|
|
core_sparse_checkout_cone = git_config_bool(var, value);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
git on Mac OS and precomposed unicode
Mac OS X mangles file names containing unicode on file systems HFS+,
VFAT or SAMBA. When a file using unicode code points outside ASCII
is created on a HFS+ drive, the file name is converted into
decomposed unicode and written to disk. No conversion is done if
the file name is already decomposed unicode.
Calling open("\xc3\x84", ...) with a precomposed "Ä" yields the same
result as open("\x41\xcc\x88",...) with a decomposed "Ä".
As a consequence, readdir() returns the file names in decomposed
unicode, even if the user expects precomposed unicode. Unlike on
HFS+, Mac OS X stores files on a VFAT drive (e.g. an USB drive) in
precomposed unicode, but readdir() still returns file names in
decomposed unicode. When a git repository is stored on a network
share using SAMBA, file names are send over the wire and written to
disk on the remote system in precomposed unicode, but Mac OS X
readdir() returns decomposed unicode to be compatible with its
behaviour on HFS+ and VFAT.
The unicode decomposition causes many problems:
- The names "git add" and other commands get from the end user may
often be precomposed form (the decomposed form is not easily input
from the keyboard), but when the commands read from the filesystem
to see what it is going to update the index with already is on the
filesystem, readdir() will give decomposed form, which is different.
- Similarly "git log", "git mv" and all other commands that need to
compare pathnames found on the command line (often but not always
precomposed form; a command line input resulting from globbing may
be in decomposed) with pathnames found in the tree objects (should
be precomposed form to be compatible with other systems and for
consistency in general).
- The same for names stored in the index, which should be
precomposed, that may need to be compared with the names read from
readdir().
NFS mounted from Linux is fully transparent and does not suffer from
the above.
As Mac OS X treats precomposed and decomposed file names as equal,
we can
- wrap readdir() on Mac OS X to return the precomposed form, and
- normalize decomposed form given from the command line also to the
precomposed form,
to ensure that all pathnames used in Git are always in the
precomposed form. This behaviour can be requested by setting
"core.precomposedunicode" configuration variable to true.
The code in compat/precomposed_utf8.c implements basically 4 new
functions: precomposed_utf8_opendir(), precomposed_utf8_readdir(),
precomposed_utf8_closedir() and precompose_argv(). The first three
are to wrap opendir(3), readdir(3), and closedir(3) functions.
The argv[] conversion allows to use the TAB filename completion done
by the shell on command line. It tolerates other tools which use
readdir() to feed decomposed file names into git.
When creating a new git repository with "git init" or "git clone",
"core.precomposedunicode" will be set "false".
The user needs to activate this feature manually. She typically
sets core.precomposedunicode to "true" on HFS and VFAT, or file
systems mounted via SAMBA.
Helped-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-07-08 21:50:25 +08:00
|
|
|
if (!strcmp(var, "core.precomposeunicode")) {
|
|
|
|
|
precomposed_unicode = git_config_bool(var, value);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2014-12-16 07:15:20 +08:00
|
|
|
if (!strcmp(var, "core.protecthfs")) {
|
|
|
|
|
protect_hfs = git_config_bool(var, value);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2014-12-17 06:46:59 +08:00
|
|
|
if (!strcmp(var, "core.protectntfs")) {
|
|
|
|
|
protect_ntfs = git_config_bool(var, value);
|
|
|
|
|
return 0;
|
git on Mac OS and precomposed unicode
Mac OS X mangles file names containing unicode on file systems HFS+,
VFAT or SAMBA. When a file using unicode code points outside ASCII
is created on a HFS+ drive, the file name is converted into
decomposed unicode and written to disk. No conversion is done if
the file name is already decomposed unicode.
Calling open("\xc3\x84", ...) with a precomposed "Ä" yields the same
result as open("\x41\xcc\x88",...) with a decomposed "Ä".
As a consequence, readdir() returns the file names in decomposed
unicode, even if the user expects precomposed unicode. Unlike on
HFS+, Mac OS X stores files on a VFAT drive (e.g. an USB drive) in
precomposed unicode, but readdir() still returns file names in
decomposed unicode. When a git repository is stored on a network
share using SAMBA, file names are send over the wire and written to
disk on the remote system in precomposed unicode, but Mac OS X
readdir() returns decomposed unicode to be compatible with its
behaviour on HFS+ and VFAT.
The unicode decomposition causes many problems:
- The names "git add" and other commands get from the end user may
often be precomposed form (the decomposed form is not easily input
from the keyboard), but when the commands read from the filesystem
to see what it is going to update the index with already is on the
filesystem, readdir() will give decomposed form, which is different.
- Similarly "git log", "git mv" and all other commands that need to
compare pathnames found on the command line (often but not always
precomposed form; a command line input resulting from globbing may
be in decomposed) with pathnames found in the tree objects (should
be precomposed form to be compatible with other systems and for
consistency in general).
- The same for names stored in the index, which should be
precomposed, that may need to be compared with the names read from
readdir().
NFS mounted from Linux is fully transparent and does not suffer from
the above.
As Mac OS X treats precomposed and decomposed file names as equal,
we can
- wrap readdir() on Mac OS X to return the precomposed form, and
- normalize decomposed form given from the command line also to the
precomposed form,
to ensure that all pathnames used in Git are always in the
precomposed form. This behaviour can be requested by setting
"core.precomposedunicode" configuration variable to true.
The code in compat/precomposed_utf8.c implements basically 4 new
functions: precomposed_utf8_opendir(), precomposed_utf8_readdir(),
precomposed_utf8_closedir() and precompose_argv(). The first three
are to wrap opendir(3), readdir(3), and closedir(3) functions.
The argv[] conversion allows to use the TAB filename completion done
by the shell on command line. It tolerates other tools which use
readdir() to feed decomposed file names into git.
When creating a new git repository with "git init" or "git clone",
"core.precomposedunicode" will be set "false".
The user needs to activate this feature manually. She typically
sets core.precomposedunicode to "true" on HFS and VFAT, or file
systems mounted via SAMBA.
Helped-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Torsten Bögershausen <tboegi@web.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-07-08 21:50:25 +08:00
|
|
|
}
|
|
|
|
|
|
2018-07-19 04:45:25 +08:00
|
|
|
if (!strcmp(var, "core.usereplacerefs")) {
|
|
|
|
|
read_replace_refs = git_config_bool(var, value);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2008-06-19 05:37:18 +08:00
|
|
|
/* Add other config variables here and to Documentation/config.txt. */
|
2018-10-31 02:40:04 +08:00
|
|
|
return platform_core_config(var, value, cb);
|
2008-06-19 05:37:18 +08:00
|
|
|
}
|
|
|
|
|
|
2008-06-19 06:00:11 +08:00
|
|
|
static int git_default_i18n_config(const char *var, const char *value)
|
2008-06-19 05:40:35 +08:00
|
|
|
{
|
2008-02-16 13:00:24 +08:00
|
|
|
if (!strcmp(var, "i18n.commitencoding"))
|
|
|
|
|
return git_config_string(&git_commit_encoding, var, value);
|
2006-12-28 08:41:33 +08:00
|
|
|
|
2008-02-16 13:00:24 +08:00
|
|
|
if (!strcmp(var, "i18n.logoutputencoding"))
|
|
|
|
|
return git_config_string(&git_log_output_encoding, var, value);
|
2006-12-28 08:41:33 +08:00
|
|
|
|
2008-06-19 06:00:11 +08:00
|
|
|
/* Add other config variables here and to Documentation/config.txt. */
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
core.excludesfile clean-up
There are inconsistencies in the way commands currently handle
the core.excludesfile configuration variable. The problem is
the variable is too new to be noticed by anything other than
git-add and git-status.
* git-ls-files does not notice any of the "ignore" files by
default, as it predates the standardized set of ignore files.
The calling scripts established the convention to use
.git/info/exclude, .gitignore, and later core.excludesfile.
* git-add and git-status know about it because they call
add_excludes_from_file() directly with their own notion of
which standard set of ignore files to use. This is just a
stupid duplication of code that need to be updated every time
the definition of the standard set of ignore files is
changed.
* git-read-tree takes --exclude-per-directory=<gitignore>,
not because the flexibility was needed. Again, this was
because the option predates the standardization of the ignore
files.
* git-merge-recursive uses hardcoded per-directory .gitignore
and nothing else. git-clean (scripted version) does not
honor core.* because its call to underlying ls-files does not
know about it. git-clean in C (parked in 'pu') doesn't either.
We probably could change git-ls-files to use the standard set
when no excludes are specified on the command line and ignore
processing was asked, or something like that, but that will be a
change in semantics and might break people's scripts in a subtle
way. I am somewhat reluctant to make such a change.
On the other hand, I think it makes perfect sense to fix
git-read-tree, git-merge-recursive and git-clean to follow the
same rule as other commands. I do not think of a valid use case
to give an exclude-per-directory that is nonstandard to
read-tree command, outside a "negative" test in the t1004 test
script.
This patch is the first step to untangle this mess.
The next step would be to teach read-tree, merge-recursive and
clean (in C) to use setup_standard_excludes().
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2007-11-14 16:05:00 +08:00
|
|
|
|
2008-06-19 06:00:11 +08:00
|
|
|
static int git_default_branch_config(const char *var, const char *value)
|
|
|
|
|
{
|
2008-02-20 00:24:37 +08:00
|
|
|
if (!strcmp(var, "branch.autosetupmerge")) {
|
|
|
|
|
if (value && !strcasecmp(value, "always")) {
|
|
|
|
|
git_branch_track = BRANCH_TRACK_ALWAYS;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
git_branch_track = git_config_bool(var, value);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2008-05-11 06:36:29 +08:00
|
|
|
if (!strcmp(var, "branch.autosetuprebase")) {
|
|
|
|
|
if (!value)
|
|
|
|
|
return config_error_nonbool(var);
|
|
|
|
|
else if (!strcmp(value, "never"))
|
|
|
|
|
autorebase = AUTOREBASE_NEVER;
|
|
|
|
|
else if (!strcmp(value, "local"))
|
|
|
|
|
autorebase = AUTOREBASE_LOCAL;
|
|
|
|
|
else if (!strcmp(value, "remote"))
|
|
|
|
|
autorebase = AUTOREBASE_REMOTE;
|
|
|
|
|
else if (!strcmp(value, "always"))
|
|
|
|
|
autorebase = AUTOREBASE_ALWAYS;
|
|
|
|
|
else
|
2018-07-21 15:49:27 +08:00
|
|
|
return error(_("malformed value for %s"), var);
|
2008-05-11 06:36:29 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
2007-11-02 15:24:27 +08:00
|
|
|
|
2006-04-25 06:59:33 +08:00
|
|
|
/* Add other config variables here and to Documentation/config.txt. */
|
2005-10-11 07:31:08 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2009-03-16 23:42:51 +08:00
|
|
|
static int git_default_push_config(const char *var, const char *value)
|
|
|
|
|
{
|
|
|
|
|
if (!strcmp(var, "push.default")) {
|
|
|
|
|
if (!value)
|
|
|
|
|
return config_error_nonbool(var);
|
|
|
|
|
else if (!strcmp(value, "nothing"))
|
|
|
|
|
push_default = PUSH_DEFAULT_NOTHING;
|
|
|
|
|
else if (!strcmp(value, "matching"))
|
|
|
|
|
push_default = PUSH_DEFAULT_MATCHING;
|
2012-04-24 15:50:03 +08:00
|
|
|
else if (!strcmp(value, "simple"))
|
|
|
|
|
push_default = PUSH_DEFAULT_SIMPLE;
|
2011-02-16 08:54:24 +08:00
|
|
|
else if (!strcmp(value, "upstream"))
|
|
|
|
|
push_default = PUSH_DEFAULT_UPSTREAM;
|
|
|
|
|
else if (!strcmp(value, "tracking")) /* deprecated */
|
|
|
|
|
push_default = PUSH_DEFAULT_UPSTREAM;
|
2009-03-16 23:42:51 +08:00
|
|
|
else if (!strcmp(value, "current"))
|
|
|
|
|
push_default = PUSH_DEFAULT_CURRENT;
|
|
|
|
|
else {
|
2018-07-21 15:49:27 +08:00
|
|
|
error(_("malformed value for %s: %s"), var, value);
|
|
|
|
|
return error(_("must be one of nothing, matching, simple, "
|
|
|
|
|
"upstream or current"));
|
2009-03-16 23:42:51 +08:00
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Add other config variables here and to Documentation/config.txt. */
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2009-02-08 22:34:27 +08:00
|
|
|
static int git_default_mailmap_config(const char *var, const char *value)
|
|
|
|
|
{
|
|
|
|
|
if (!strcmp(var, "mailmap.file"))
|
2014-05-27 16:45:58 +08:00
|
|
|
return git_config_pathname(&git_mailmap_file, var, value);
|
2012-12-12 19:04:04 +08:00
|
|
|
if (!strcmp(var, "mailmap.blob"))
|
|
|
|
|
return git_config_string(&git_mailmap_blob, var, value);
|
2009-02-08 22:34:27 +08:00
|
|
|
|
|
|
|
|
/* Add other config variables here and to Documentation/config.txt. */
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2018-10-31 02:40:03 +08:00
|
|
|
int git_default_config(const char *var, const char *value, void *cb)
|
2008-06-19 06:00:11 +08:00
|
|
|
{
|
2013-12-01 04:55:40 +08:00
|
|
|
if (starts_with(var, "core."))
|
2018-10-31 02:40:04 +08:00
|
|
|
return git_default_core_config(var, value, cb);
|
2008-06-19 06:00:11 +08:00
|
|
|
|
2019-02-05 02:48:50 +08:00
|
|
|
if (starts_with(var, "user.") ||
|
|
|
|
|
starts_with(var, "author.") ||
|
|
|
|
|
starts_with(var, "committer."))
|
2018-10-31 02:40:03 +08:00
|
|
|
return git_ident_config(var, value, cb);
|
2008-06-19 06:00:11 +08:00
|
|
|
|
2013-12-01 04:55:40 +08:00
|
|
|
if (starts_with(var, "i18n."))
|
2008-06-19 06:00:11 +08:00
|
|
|
return git_default_i18n_config(var, value);
|
|
|
|
|
|
2013-12-01 04:55:40 +08:00
|
|
|
if (starts_with(var, "branch."))
|
2008-06-19 06:00:11 +08:00
|
|
|
return git_default_branch_config(var, value);
|
|
|
|
|
|
2013-12-01 04:55:40 +08:00
|
|
|
if (starts_with(var, "push."))
|
2009-03-16 23:42:51 +08:00
|
|
|
return git_default_push_config(var, value);
|
|
|
|
|
|
2013-12-01 04:55:40 +08:00
|
|
|
if (starts_with(var, "mailmap."))
|
2009-02-08 22:34:27 +08:00
|
|
|
return git_default_mailmap_config(var, value);
|
|
|
|
|
|
2018-04-21 18:10:00 +08:00
|
|
|
if (starts_with(var, "advice.") || starts_with(var, "color.advice"))
|
2009-09-09 19:38:58 +08:00
|
|
|
return git_default_advice_config(var, value);
|
|
|
|
|
|
2008-06-19 06:00:11 +08:00
|
|
|
if (!strcmp(var, "pager.color") || !strcmp(var, "color.pager")) {
|
|
|
|
|
pager_use_color = git_config_bool(var,value);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2011-10-29 05:48:40 +08:00
|
|
|
if (!strcmp(var, "pack.packsizelimit")) {
|
|
|
|
|
pack_size_limit_cfg = git_config_ulong(var, value);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2016-11-16 09:42:40 +08:00
|
|
|
|
|
|
|
|
if (!strcmp(var, "pack.compression")) {
|
|
|
|
|
int level = git_config_int(var, value);
|
|
|
|
|
if (level == -1)
|
|
|
|
|
level = Z_DEFAULT_COMPRESSION;
|
|
|
|
|
else if (level < 0 || level > Z_BEST_COMPRESSION)
|
|
|
|
|
die(_("bad pack compression level %d"), level);
|
|
|
|
|
pack_compression_level = level;
|
|
|
|
|
pack_compression_seen = 1;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2008-06-19 06:00:11 +08:00
|
|
|
/* Add other config variables here and to Documentation/config.txt. */
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2013-05-11 21:18:52 +08:00
|
|
|
/*
|
2013-07-12 06:48:30 +08:00
|
|
|
* All source specific fields in the union, die_on_error, name and the callbacks
|
2013-07-12 06:44:39 +08:00
|
|
|
* fgetc, ungetc, ftell of top need to be initialized before calling
|
2013-05-11 21:18:52 +08:00
|
|
|
* this function.
|
|
|
|
|
*/
|
2018-04-09 16:32:05 +08:00
|
|
|
static int do_config_from(struct config_source *top, config_fn_t fn, void *data,
|
|
|
|
|
const struct config_options *opts)
|
2013-05-11 21:18:52 +08:00
|
|
|
{
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
/* push config-file parsing state stack */
|
|
|
|
|
top->prev = cf;
|
|
|
|
|
top->linenr = 1;
|
|
|
|
|
top->eof = 0;
|
|
|
|
|
strbuf_init(&top->value, 1024);
|
|
|
|
|
strbuf_init(&top->var, 1024);
|
|
|
|
|
cf = top;
|
|
|
|
|
|
2018-04-09 16:32:05 +08:00
|
|
|
ret = git_parse_source(fn, data, opts);
|
2013-05-11 21:18:52 +08:00
|
|
|
|
|
|
|
|
/* pop config-file parsing state stack */
|
|
|
|
|
strbuf_release(&top->value);
|
|
|
|
|
strbuf_release(&top->var);
|
|
|
|
|
cf = top->prev;
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2014-02-19 06:58:55 +08:00
|
|
|
static int do_config_from_file(config_fn_t fn,
|
i18n: config: unfold error messages marked for translation
Introduced in 473166b ("config: add 'origin_type' to config_source
struct", 2016-02-19), Git can inform the user about the origin of a
config error, but the implementation does not allow translators to
translate the keywords 'file', 'blob, 'standard input', and
'submodule-blob'. Moreover, for the second message, a reason for the
error is appended to the message, not allowing translators to translate
that reason either.
Unfold the message into several templates for each known origin_type.
That would result in better translation at the expense of code
verbosity.
Add enum config_oringin_type to ease management of the various
configuration origin types (blob, file, etc). Previously origin type
was considered from command line if cf->origin_type == NULL, i.e.,
uninitialized. Now we set origin_type to CONFIG_ORIGIN_CMDLINE in
git_config_from_parameters() and configset_add_value().
For error message in git_parse_source(), use xstrfmt() function to
prepare the message string, instead of doing something like it's done
for die_bad_number(), because intelligibility and code conciseness are
improved for that instance.
Signed-off-by: Vasco Almeida <vascomalmeida@sapo.pt>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-07-28 21:14:03 +08:00
|
|
|
const enum config_origin_type origin_type,
|
|
|
|
|
const char *name, const char *path, FILE *f,
|
2018-04-09 16:32:05 +08:00
|
|
|
void *data, const struct config_options *opts)
|
2005-10-11 07:31:08 +08:00
|
|
|
{
|
2014-02-19 06:58:55 +08:00
|
|
|
struct config_source top;
|
2018-03-31 03:26:15 +08:00
|
|
|
int ret;
|
2005-10-11 07:31:08 +08:00
|
|
|
|
2014-02-19 06:58:55 +08:00
|
|
|
top.u.file = f;
|
2016-02-19 17:16:01 +08:00
|
|
|
top.origin_type = origin_type;
|
2014-02-19 06:58:55 +08:00
|
|
|
top.name = name;
|
|
|
|
|
top.path = path;
|
2018-06-29 06:05:00 +08:00
|
|
|
top.default_error_action = CONFIG_ERROR_DIE;
|
2014-02-19 06:58:55 +08:00
|
|
|
top.do_fgetc = config_file_fgetc;
|
|
|
|
|
top.do_ungetc = config_file_ungetc;
|
|
|
|
|
top.do_ftell = config_file_ftell;
|
config.c: Make git_config() work correctly when called recursively
On Cygwin, this fixes a test failure in t3301-notes.sh (test 98,
"git notes copy --for-rewrite (disabled)").
The test failure is caused by a recursive call to git_config() which
has the effect of skipping to the end-of-file while processing the
"notes.rewriteref" config variable. Thus, any config variables that
appear after "notes.rewriteref" are simply ignored by git_config().
Also, we note that the original FILE handle is leaked as a result
of the recursive call.
The recursive call to git_config() is due to the "schizophrenic stat"
functions on cygwin, where one of two different implementations of
the l/stat functions is selected lazily, depending on some config
variables.
In this case, the init_copy_notes_for_rewrite() function calls
git_config() with the notes_rewrite_config() callback function.
This callback, while processing the "notes.rewriteref" variable,
in turn calls string_list_add_refs_by_glob() to process the
associated ref value. This eventually leads to a call to the
get_ref_dir() function, which in turn calls stat(). On cygwin,
the stat() macro leads to an indirect call to cygwin_stat_stub()
which, via init_stat(), then calls git_config() in order to
determine which l/stat implementation to bind to.
In order to solve this problem, we modify git_config() so that the
global state variables used by the config reading code is packaged
up and managed on a local state stack.
Signed-off-by: Ramsay Jones <ramsay@ramsay1.demon.co.uk>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-06-17 04:24:51 +08:00
|
|
|
|
2018-03-31 03:26:15 +08:00
|
|
|
flockfile(f);
|
2018-05-08 14:59:18 +08:00
|
|
|
ret = do_config_from(&top, fn, data, opts);
|
2018-03-31 03:26:15 +08:00
|
|
|
funlockfile(f);
|
|
|
|
|
return ret;
|
2014-02-19 06:58:55 +08:00
|
|
|
}
|
config.c: Make git_config() work correctly when called recursively
On Cygwin, this fixes a test failure in t3301-notes.sh (test 98,
"git notes copy --for-rewrite (disabled)").
The test failure is caused by a recursive call to git_config() which
has the effect of skipping to the end-of-file while processing the
"notes.rewriteref" config variable. Thus, any config variables that
appear after "notes.rewriteref" are simply ignored by git_config().
Also, we note that the original FILE handle is leaked as a result
of the recursive call.
The recursive call to git_config() is due to the "schizophrenic stat"
functions on cygwin, where one of two different implementations of
the l/stat functions is selected lazily, depending on some config
variables.
In this case, the init_copy_notes_for_rewrite() function calls
git_config() with the notes_rewrite_config() callback function.
This callback, while processing the "notes.rewriteref" variable,
in turn calls string_list_add_refs_by_glob() to process the
associated ref value. This eventually leads to a call to the
get_ref_dir() function, which in turn calls stat(). On cygwin,
the stat() macro leads to an indirect call to cygwin_stat_stub()
which, via init_stat(), then calls git_config() in order to
determine which l/stat implementation to bind to.
In order to solve this problem, we modify git_config() so that the
global state variables used by the config reading code is packaged
up and managed on a local state stack.
Signed-off-by: Ramsay Jones <ramsay@ramsay1.demon.co.uk>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-06-17 04:24:51 +08:00
|
|
|
|
2014-02-19 06:58:55 +08:00
|
|
|
static int git_config_from_stdin(config_fn_t fn, void *data)
|
|
|
|
|
{
|
2018-04-09 16:32:05 +08:00
|
|
|
return do_config_from_file(fn, CONFIG_ORIGIN_STDIN, "", NULL, stdin,
|
|
|
|
|
data, NULL);
|
2014-02-19 06:58:55 +08:00
|
|
|
}
|
|
|
|
|
|
2018-04-09 16:32:05 +08:00
|
|
|
int git_config_from_file_with_options(config_fn_t fn, const char *filename,
|
|
|
|
|
void *data,
|
|
|
|
|
const struct config_options *opts)
|
2014-02-19 06:58:55 +08:00
|
|
|
{
|
|
|
|
|
int ret = -1;
|
|
|
|
|
FILE *f;
|
config.c: Make git_config() work correctly when called recursively
On Cygwin, this fixes a test failure in t3301-notes.sh (test 98,
"git notes copy --for-rewrite (disabled)").
The test failure is caused by a recursive call to git_config() which
has the effect of skipping to the end-of-file while processing the
"notes.rewriteref" config variable. Thus, any config variables that
appear after "notes.rewriteref" are simply ignored by git_config().
Also, we note that the original FILE handle is leaked as a result
of the recursive call.
The recursive call to git_config() is due to the "schizophrenic stat"
functions on cygwin, where one of two different implementations of
the l/stat functions is selected lazily, depending on some config
variables.
In this case, the init_copy_notes_for_rewrite() function calls
git_config() with the notes_rewrite_config() callback function.
This callback, while processing the "notes.rewriteref" variable,
in turn calls string_list_add_refs_by_glob() to process the
associated ref value. This eventually leads to a call to the
get_ref_dir() function, which in turn calls stat(). On cygwin,
the stat() macro leads to an indirect call to cygwin_stat_stub()
which, via init_stat(), then calls git_config() in order to
determine which l/stat implementation to bind to.
In order to solve this problem, we modify git_config() so that the
global state variables used by the config reading code is packaged
up and managed on a local state stack.
Signed-off-by: Ramsay Jones <ramsay@ramsay1.demon.co.uk>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-06-17 04:24:51 +08:00
|
|
|
|
2017-05-03 18:16:50 +08:00
|
|
|
f = fopen_or_warn(filename, "r");
|
2014-02-19 06:58:55 +08:00
|
|
|
if (f) {
|
2018-04-09 16:32:05 +08:00
|
|
|
ret = do_config_from_file(fn, CONFIG_ORIGIN_FILE, filename,
|
|
|
|
|
filename, f, data, opts);
|
2005-10-11 07:31:08 +08:00
|
|
|
fclose(f);
|
|
|
|
|
}
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
2005-11-18 05:32:36 +08:00
|
|
|
|
2018-04-09 16:32:05 +08:00
|
|
|
int git_config_from_file(config_fn_t fn, const char *filename, void *data)
|
|
|
|
|
{
|
|
|
|
|
return git_config_from_file_with_options(fn, filename, data, NULL);
|
|
|
|
|
}
|
|
|
|
|
|
2018-06-29 06:05:24 +08:00
|
|
|
int git_config_from_mem(config_fn_t fn,
|
|
|
|
|
const enum config_origin_type origin_type,
|
|
|
|
|
const char *name, const char *buf, size_t len,
|
|
|
|
|
void *data, const struct config_options *opts)
|
2013-07-12 06:46:47 +08:00
|
|
|
{
|
|
|
|
|
struct config_source top;
|
|
|
|
|
|
|
|
|
|
top.u.buf.buf = buf;
|
|
|
|
|
top.u.buf.len = len;
|
|
|
|
|
top.u.buf.pos = 0;
|
2016-02-19 17:16:01 +08:00
|
|
|
top.origin_type = origin_type;
|
2013-07-12 06:46:47 +08:00
|
|
|
top.name = name;
|
2014-02-19 06:58:52 +08:00
|
|
|
top.path = NULL;
|
2018-06-29 06:05:00 +08:00
|
|
|
top.default_error_action = CONFIG_ERROR_ERROR;
|
2013-08-27 05:57:18 +08:00
|
|
|
top.do_fgetc = config_buf_fgetc;
|
|
|
|
|
top.do_ungetc = config_buf_ungetc;
|
|
|
|
|
top.do_ftell = config_buf_ftell;
|
2013-07-12 06:46:47 +08:00
|
|
|
|
2018-06-29 06:05:24 +08:00
|
|
|
return do_config_from(&top, fn, data, opts);
|
2013-07-12 06:46:47 +08:00
|
|
|
}
|
|
|
|
|
|
2017-07-14 07:49:20 +08:00
|
|
|
int git_config_from_blob_oid(config_fn_t fn,
|
2016-12-17 03:03:18 +08:00
|
|
|
const char *name,
|
2017-07-14 07:49:20 +08:00
|
|
|
const struct object_id *oid,
|
2016-12-17 03:03:18 +08:00
|
|
|
void *data)
|
2013-07-12 06:46:47 +08:00
|
|
|
{
|
|
|
|
|
enum object_type type;
|
|
|
|
|
char *buf;
|
|
|
|
|
unsigned long size;
|
|
|
|
|
int ret;
|
|
|
|
|
|
sha1_file: convert read_sha1_file to struct object_id
Convert read_sha1_file to take a pointer to struct object_id and rename
it read_object_file. Do the same for read_sha1_file_extended.
Convert one use in grep.c to use the new function without any other code
change, since the pointer being passed is a void pointer that is already
initialized with a pointer to struct object_id. Update the declaration
and definitions of the modified functions, and apply the following
semantic patch to convert the remaining callers:
@@
expression E1, E2, E3;
@@
- read_sha1_file(E1.hash, E2, E3)
+ read_object_file(&E1, E2, E3)
@@
expression E1, E2, E3;
@@
- read_sha1_file(E1->hash, E2, E3)
+ read_object_file(E1, E2, E3)
@@
expression E1, E2, E3, E4;
@@
- read_sha1_file_extended(E1.hash, E2, E3, E4)
+ read_object_file_extended(&E1, E2, E3, E4)
@@
expression E1, E2, E3, E4;
@@
- read_sha1_file_extended(E1->hash, E2, E3, E4)
+ read_object_file_extended(E1, E2, E3, E4)
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-03-12 10:27:53 +08:00
|
|
|
buf = read_object_file(oid, &type, &size);
|
2013-07-12 06:46:47 +08:00
|
|
|
if (!buf)
|
2018-07-21 15:49:27 +08:00
|
|
|
return error(_("unable to load config blob object '%s'"), name);
|
2013-07-12 06:46:47 +08:00
|
|
|
if (type != OBJ_BLOB) {
|
|
|
|
|
free(buf);
|
2018-07-21 15:49:27 +08:00
|
|
|
return error(_("reference '%s' does not point to a blob"), name);
|
2013-07-12 06:46:47 +08:00
|
|
|
}
|
|
|
|
|
|
2018-06-29 06:05:24 +08:00
|
|
|
ret = git_config_from_mem(fn, CONFIG_ORIGIN_BLOB, name, buf, size,
|
|
|
|
|
data, NULL);
|
2013-07-12 06:46:47 +08:00
|
|
|
free(buf);
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int git_config_from_blob_ref(config_fn_t fn,
|
|
|
|
|
const char *name,
|
|
|
|
|
void *data)
|
|
|
|
|
{
|
2017-07-14 07:49:20 +08:00
|
|
|
struct object_id oid;
|
2013-07-12 06:46:47 +08:00
|
|
|
|
2017-07-14 07:49:20 +08:00
|
|
|
if (get_oid(name, &oid) < 0)
|
2018-07-21 15:49:27 +08:00
|
|
|
return error(_("unable to resolve config blob '%s'"), name);
|
2017-07-14 07:49:20 +08:00
|
|
|
return git_config_from_blob_oid(fn, name, &oid, data);
|
2013-07-12 06:46:47 +08:00
|
|
|
}
|
|
|
|
|
|
2007-11-14 04:05:05 +08:00
|
|
|
const char *git_etc_gitconfig(void)
|
|
|
|
|
{
|
2007-11-14 04:05:06 +08:00
|
|
|
static const char *system_wide;
|
2008-07-14 04:31:18 +08:00
|
|
|
if (!system_wide)
|
|
|
|
|
system_wide = system_path(ETC_GITCONFIG);
|
2007-11-14 04:05:06 +08:00
|
|
|
return system_wide;
|
2007-11-14 04:05:05 +08:00
|
|
|
}
|
|
|
|
|
|
2014-08-26 23:23:21 +08:00
|
|
|
/*
|
|
|
|
|
* Parse environment variable 'k' as a boolean (in various
|
|
|
|
|
* possible spellings); if missing, use the default value 'def'.
|
|
|
|
|
*/
|
2010-03-18 03:55:51 +08:00
|
|
|
int git_env_bool(const char *k, int def)
|
2008-02-06 18:11:18 +08:00
|
|
|
{
|
|
|
|
|
const char *v = getenv(k);
|
|
|
|
|
return v ? git_config_bool(k, v) : def;
|
|
|
|
|
}
|
|
|
|
|
|
2014-08-26 23:23:21 +08:00
|
|
|
/*
|
|
|
|
|
* Parse environment variable 'k' as ulong with possibly a unit
|
|
|
|
|
* suffix; if missing, use the default value 'val'.
|
|
|
|
|
*/
|
|
|
|
|
unsigned long git_env_ulong(const char *k, unsigned long val)
|
|
|
|
|
{
|
|
|
|
|
const char *v = getenv(k);
|
|
|
|
|
if (v && !git_parse_ulong(v, &val))
|
2018-07-21 15:49:27 +08:00
|
|
|
die(_("failed to parse %s"), k);
|
2014-08-26 23:23:21 +08:00
|
|
|
return val;
|
|
|
|
|
}
|
|
|
|
|
|
2008-02-06 18:11:18 +08:00
|
|
|
int git_config_system(void)
|
|
|
|
|
{
|
|
|
|
|
return !git_env_bool("GIT_CONFIG_NOSYSTEM", 0);
|
|
|
|
|
}
|
|
|
|
|
|
2017-04-17 18:10:02 +08:00
|
|
|
static int do_git_config_sequence(const struct config_options *opts,
|
|
|
|
|
config_fn_t fn, void *data)
|
2005-11-26 08:03:56 +08:00
|
|
|
{
|
2016-05-19 06:39:02 +08:00
|
|
|
int ret = 0;
|
2015-05-06 16:01:03 +08:00
|
|
|
char *xdg_config = xdg_config_home("config");
|
2017-04-05 18:24:38 +08:00
|
|
|
char *user_config = expand_user_path("~/.gitconfig", 0);
|
2017-04-17 18:10:02 +08:00
|
|
|
char *repo_config;
|
2020-02-10 08:30:56 +08:00
|
|
|
enum config_scope prev_parsing_scope = current_parsing_scope;
|
2017-04-17 18:10:02 +08:00
|
|
|
|
2017-06-15 02:07:38 +08:00
|
|
|
if (opts->commondir)
|
|
|
|
|
repo_config = mkpathdup("%s/config", opts->commondir);
|
2018-11-14 21:59:02 +08:00
|
|
|
else if (opts->git_dir)
|
|
|
|
|
BUG("git_dir without commondir");
|
2017-04-17 18:10:02 +08:00
|
|
|
else
|
|
|
|
|
repo_config = NULL;
|
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-20 07:48:03 +08:00
|
|
|
|
config: add a notion of "scope"
A config callback passed to git_config() doesn't know very
much about the context in which it sees a variable. It can
ask whether the variable comes from a file, and get the file
name. But without analyzing the filename (which is hard to
do accurately), it cannot tell whether it is in system-level
config, user-level config, or repo-specific config.
Generally this doesn't matter; the point of not passing this
to the callback is that it should treat the config the same
no matter where it comes from. But some programs, like
upload-pack, are a special case: we should be able to run
them in an untrusted repository, which means we cannot use
any "dangerous" config from the repository config file (but
it is OK to use it from system or user config).
This patch teaches the config code to record the "scope" of
each variable, and make it available inside config
callbacks, similar to how we give access to the filename.
The scope is the starting source for a particular parsing
operation, and remains the same even if we include other
files (so a .git/config which includes another file will
remain CONFIG_SCOPE_REPO, as it would be similarly
untrusted).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-05-19 06:44:23 +08:00
|
|
|
current_parsing_scope = CONFIG_SCOPE_SYSTEM;
|
2019-04-30 04:14:22 +08:00
|
|
|
if (git_config_system() && !access_or_die(git_etc_gitconfig(), R_OK,
|
|
|
|
|
opts->system_gently ?
|
|
|
|
|
ACCESS_EACCES_OK : 0))
|
2008-06-30 15:37:47 +08:00
|
|
|
ret += git_config_from_file(fn, git_etc_gitconfig(),
|
|
|
|
|
data);
|
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-20 07:48:03 +08:00
|
|
|
|
config: add a notion of "scope"
A config callback passed to git_config() doesn't know very
much about the context in which it sees a variable. It can
ask whether the variable comes from a file, and get the file
name. But without analyzing the filename (which is hard to
do accurately), it cannot tell whether it is in system-level
config, user-level config, or repo-specific config.
Generally this doesn't matter; the point of not passing this
to the callback is that it should treat the config the same
no matter where it comes from. But some programs, like
upload-pack, are a special case: we should be able to run
them in an untrusted repository, which means we cannot use
any "dangerous" config from the repository config file (but
it is OK to use it from system or user config).
This patch teaches the config code to record the "scope" of
each variable, and make it available inside config
callbacks, similar to how we give access to the filename.
The scope is the starting source for a particular parsing
operation, and remains the same even if we include other
files (so a .git/config which includes another file will
remain CONFIG_SCOPE_REPO, as it would be similarly
untrusted).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-05-19 06:44:23 +08:00
|
|
|
current_parsing_scope = CONFIG_SCOPE_GLOBAL;
|
2016-05-19 06:39:02 +08:00
|
|
|
if (xdg_config && !access_or_die(xdg_config, R_OK, ACCESS_EACCES_OK))
|
2012-06-22 17:03:23 +08:00
|
|
|
ret += git_config_from_file(fn, xdg_config, data);
|
|
|
|
|
|
2016-05-19 06:39:02 +08:00
|
|
|
if (user_config && !access_or_die(user_config, R_OK, ACCESS_EACCES_OK))
|
2012-06-22 17:03:23 +08:00
|
|
|
ret += git_config_from_file(fn, user_config, data);
|
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-20 07:48:03 +08:00
|
|
|
|
2020-02-10 08:30:54 +08:00
|
|
|
current_parsing_scope = CONFIG_SCOPE_LOCAL;
|
2019-04-16 04:39:46 +08:00
|
|
|
if (!opts->ignore_repo && repo_config &&
|
|
|
|
|
!access_or_die(repo_config, R_OK, 0))
|
2009-02-21 08:48:55 +08:00
|
|
|
ret += git_config_from_file(fn, repo_config, data);
|
2010-03-27 06:53:57 +08:00
|
|
|
|
2020-02-10 08:30:54 +08:00
|
|
|
current_parsing_scope = CONFIG_SCOPE_WORKTREE;
|
2019-04-16 04:39:46 +08:00
|
|
|
if (!opts->ignore_worktree && repository_format_worktree_config) {
|
2018-10-21 22:02:28 +08:00
|
|
|
char *path = git_pathdup("config.worktree");
|
|
|
|
|
if (!access_or_die(path, R_OK, 0))
|
|
|
|
|
ret += git_config_from_file(fn, path, data);
|
|
|
|
|
free(path);
|
|
|
|
|
}
|
|
|
|
|
|
2020-02-10 08:30:55 +08:00
|
|
|
current_parsing_scope = CONFIG_SCOPE_COMMAND;
|
2019-04-16 04:39:46 +08:00
|
|
|
if (!opts->ignore_cmdline && git_config_from_parameters(fn, data) < 0)
|
2014-08-07 19:59:12 +08:00
|
|
|
die(_("unable to parse command-line config"));
|
2010-03-27 06:53:57 +08:00
|
|
|
|
2020-02-10 08:30:56 +08:00
|
|
|
current_parsing_scope = prev_parsing_scope;
|
2012-06-22 17:03:23 +08:00
|
|
|
free(xdg_config);
|
|
|
|
|
free(user_config);
|
2016-03-12 06:37:03 +08:00
|
|
|
free(repo_config);
|
2016-05-19 06:39:02 +08:00
|
|
|
return ret;
|
2005-11-26 08:03:56 +08:00
|
|
|
}
|
|
|
|
|
|
2017-06-15 02:07:39 +08:00
|
|
|
int config_with_options(config_fn_t fn, void *data,
|
|
|
|
|
struct git_config_source *config_source,
|
|
|
|
|
const struct config_options *opts)
|
2010-11-26 23:32:33 +08:00
|
|
|
{
|
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 17:54:04 +08:00
|
|
|
struct config_include_data inc = CONFIG_INCLUDE_INIT;
|
|
|
|
|
|
2017-04-17 18:10:00 +08:00
|
|
|
if (opts->respect_includes) {
|
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 17:54:04 +08:00
|
|
|
inc.fn = fn;
|
|
|
|
|
inc.data = data;
|
2017-04-17 18:10:00 +08:00
|
|
|
inc.opts = opts;
|
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 17:54:04 +08:00
|
|
|
fn = git_config_include;
|
|
|
|
|
data = &inc;
|
|
|
|
|
}
|
2010-11-26 23:32:33 +08:00
|
|
|
|
2020-02-10 08:30:57 +08:00
|
|
|
if (config_source)
|
|
|
|
|
current_parsing_scope = config_source->scope;
|
|
|
|
|
|
config: provide a version of git_config with more options
Callers may want to provide a specific version of a file in which to look
for config. Right now this can be done by setting the magic global
config_exclusive_filename variable. By providing a version of git_config
that takes a filename, we can take a step towards making this magic global
go away.
Furthermore, by providing a more "advanced" interface, we now have a a
natural place to add new options for callers like git-config, which care
about tweaking the specifics of config lookup, without disturbing the
large number of "simple" users (i.e., every other part of git).
The astute reader of this patch may notice that the logic for handling
config_exclusive_filename was taken out of git_config_early, but added
into git_config. This means that git_config_early will no longer respect
config_exclusive_filename. That's OK, because the only other caller of
git_config_early is check_repository_format_gently, but the only function
which sets config_exclusive_filename is cmd_config, which does not call
check_repository_format_gently (and if it did, it would have been a bug,
anyway, as we would be checking the repository format in the wrong file).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-02-16 16:05:56 +08:00
|
|
|
/*
|
|
|
|
|
* If we have a specific filename, use it. Otherwise, follow the
|
|
|
|
|
* regular lookup sequence.
|
|
|
|
|
*/
|
2014-02-19 06:58:55 +08:00
|
|
|
if (config_source && config_source->use_stdin)
|
|
|
|
|
return git_config_from_stdin(fn, data);
|
|
|
|
|
else if (config_source && config_source->file)
|
2014-02-19 06:58:54 +08:00
|
|
|
return git_config_from_file(fn, config_source->file, data);
|
|
|
|
|
else if (config_source && config_source->blob)
|
|
|
|
|
return git_config_from_blob_ref(fn, config_source->blob, data);
|
config: provide a version of git_config with more options
Callers may want to provide a specific version of a file in which to look
for config. Right now this can be done by setting the magic global
config_exclusive_filename variable. By providing a version of git_config
that takes a filename, we can take a step towards making this magic global
go away.
Furthermore, by providing a more "advanced" interface, we now have a a
natural place to add new options for callers like git-config, which care
about tweaking the specifics of config lookup, without disturbing the
large number of "simple" users (i.e., every other part of git).
The astute reader of this patch may notice that the logic for handling
config_exclusive_filename was taken out of git_config_early, but added
into git_config. This means that git_config_early will no longer respect
config_exclusive_filename. That's OK, because the only other caller of
git_config_early is check_repository_format_gently, but the only function
which sets config_exclusive_filename is cmd_config, which does not call
check_repository_format_gently (and if it did, it would have been a bug,
anyway, as we would be checking the repository format in the wrong file).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-02-16 16:05:56 +08:00
|
|
|
|
2017-04-17 18:10:02 +08:00
|
|
|
return do_git_config_sequence(opts, fn, data);
|
2010-11-26 23:32:33 +08:00
|
|
|
}
|
|
|
|
|
|
2014-08-07 19:59:17 +08:00
|
|
|
static void configset_iter(struct config_set *cs, config_fn_t fn, void *data)
|
config: provide a version of git_config with more options
Callers may want to provide a specific version of a file in which to look
for config. Right now this can be done by setting the magic global
config_exclusive_filename variable. By providing a version of git_config
that takes a filename, we can take a step towards making this magic global
go away.
Furthermore, by providing a more "advanced" interface, we now have a a
natural place to add new options for callers like git-config, which care
about tweaking the specifics of config lookup, without disturbing the
large number of "simple" users (i.e., every other part of git).
The astute reader of this patch may notice that the logic for handling
config_exclusive_filename was taken out of git_config_early, but added
into git_config. This means that git_config_early will no longer respect
config_exclusive_filename. That's OK, because the only other caller of
git_config_early is check_repository_format_gently, but the only function
which sets config_exclusive_filename is cmd_config, which does not call
check_repository_format_gently (and if it did, it would have been a bug,
anyway, as we would be checking the repository format in the wrong file).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-02-16 16:05:56 +08:00
|
|
|
{
|
2014-08-07 19:59:17 +08:00
|
|
|
int i, value_index;
|
|
|
|
|
struct string_list *values;
|
|
|
|
|
struct config_set_element *entry;
|
|
|
|
|
struct configset_list *list = &cs->list;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < list->nr; i++) {
|
|
|
|
|
entry = list->items[i].e;
|
|
|
|
|
value_index = list->items[i].value_index;
|
|
|
|
|
values = &entry->value_list;
|
2016-05-27 08:32:23 +08:00
|
|
|
|
|
|
|
|
current_config_kvi = values->items[value_index].util;
|
|
|
|
|
|
|
|
|
|
if (fn(entry->key, values->items[value_index].string, data) < 0)
|
|
|
|
|
git_die_config_linenr(entry->key,
|
|
|
|
|
current_config_kvi->filename,
|
|
|
|
|
current_config_kvi->linenr);
|
|
|
|
|
|
|
|
|
|
current_config_kvi = NULL;
|
2014-08-07 19:59:17 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2017-03-14 04:11:04 +08:00
|
|
|
void read_early_config(config_fn_t cb, void *data)
|
|
|
|
|
{
|
2017-04-17 18:10:00 +08:00
|
|
|
struct config_options opts = {0};
|
2017-06-15 02:07:37 +08:00
|
|
|
struct strbuf commondir = STRBUF_INIT;
|
|
|
|
|
struct strbuf gitdir = STRBUF_INIT;
|
2017-03-14 04:11:12 +08:00
|
|
|
|
2017-04-17 18:10:00 +08:00
|
|
|
opts.respect_includes = 1;
|
2017-03-14 04:11:04 +08:00
|
|
|
|
2017-06-15 02:07:38 +08:00
|
|
|
if (have_git_dir()) {
|
|
|
|
|
opts.commondir = get_git_common_dir();
|
2017-04-17 18:10:01 +08:00
|
|
|
opts.git_dir = get_git_dir();
|
2017-03-14 04:11:04 +08:00
|
|
|
/*
|
2017-03-14 04:11:12 +08:00
|
|
|
* When setup_git_directory() was not yet asked to discover the
|
|
|
|
|
* GIT_DIR, we ask discover_git_directory() to figure out whether there
|
|
|
|
|
* is any repository config we should use (but unlike
|
|
|
|
|
* setup_git_directory_gently(), no global state is changed, most
|
|
|
|
|
* notably, the current working directory is still the same after the
|
|
|
|
|
* call).
|
2017-03-14 04:11:04 +08:00
|
|
|
*/
|
2017-06-15 02:07:38 +08:00
|
|
|
} else if (!discover_git_directory(&commondir, &gitdir)) {
|
|
|
|
|
opts.commondir = commondir.buf;
|
2017-06-15 02:07:37 +08:00
|
|
|
opts.git_dir = gitdir.buf;
|
2017-06-15 02:07:38 +08:00
|
|
|
}
|
2017-04-17 18:10:01 +08:00
|
|
|
|
2017-06-15 02:07:39 +08:00
|
|
|
config_with_options(cb, data, NULL, &opts);
|
2017-03-14 04:11:04 +08:00
|
|
|
|
2017-06-15 02:07:37 +08:00
|
|
|
strbuf_release(&commondir);
|
|
|
|
|
strbuf_release(&gitdir);
|
2017-03-14 04:11:04 +08:00
|
|
|
}
|
|
|
|
|
|
2019-04-16 04:39:46 +08:00
|
|
|
/*
|
|
|
|
|
* Read config but only enumerate system and global settings.
|
|
|
|
|
* Omit any repo-local, worktree-local, or command-line settings.
|
|
|
|
|
*/
|
|
|
|
|
void read_very_early_config(config_fn_t cb, void *data)
|
|
|
|
|
{
|
|
|
|
|
struct config_options opts = { 0 };
|
|
|
|
|
|
|
|
|
|
opts.respect_includes = 1;
|
|
|
|
|
opts.ignore_repo = 1;
|
|
|
|
|
opts.ignore_worktree = 1;
|
|
|
|
|
opts.ignore_cmdline = 1;
|
2019-04-30 04:14:22 +08:00
|
|
|
opts.system_gently = 1;
|
2019-04-16 04:39:46 +08:00
|
|
|
|
|
|
|
|
config_with_options(cb, data, NULL, &opts);
|
|
|
|
|
}
|
|
|
|
|
|
2014-07-28 18:10:38 +08:00
|
|
|
static struct config_set_element *configset_find_element(struct config_set *cs, const char *key)
|
|
|
|
|
{
|
|
|
|
|
struct config_set_element k;
|
|
|
|
|
struct config_set_element *found_entry;
|
|
|
|
|
char *normalized_key;
|
|
|
|
|
/*
|
|
|
|
|
* `key` may come from the user, so normalize it before using it
|
|
|
|
|
* for querying entries from the hashmap.
|
|
|
|
|
*/
|
2016-04-28 05:30:39 +08:00
|
|
|
if (git_config_parse_key(key, &normalized_key, NULL))
|
2014-07-28 18:10:38 +08:00
|
|
|
return NULL;
|
|
|
|
|
|
2019-10-07 07:30:27 +08:00
|
|
|
hashmap_entry_init(&k.ent, strhash(normalized_key));
|
2014-07-28 18:10:38 +08:00
|
|
|
k.key = normalized_key;
|
2019-10-07 07:30:42 +08:00
|
|
|
found_entry = hashmap_get_entry(&cs->config_hash, &k, ent, NULL);
|
2014-07-28 18:10:38 +08:00
|
|
|
free(normalized_key);
|
|
|
|
|
return found_entry;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int configset_add_value(struct config_set *cs, const char *key, const char *value)
|
|
|
|
|
{
|
|
|
|
|
struct config_set_element *e;
|
2014-08-07 19:59:14 +08:00
|
|
|
struct string_list_item *si;
|
2014-08-07 19:59:17 +08:00
|
|
|
struct configset_list_item *l_item;
|
2014-08-07 19:59:14 +08:00
|
|
|
struct key_value_info *kv_info = xmalloc(sizeof(*kv_info));
|
|
|
|
|
|
2014-07-28 18:10:38 +08:00
|
|
|
e = configset_find_element(cs, key);
|
|
|
|
|
/*
|
|
|
|
|
* Since the keys are being fed by git_config*() callback mechanism, they
|
|
|
|
|
* are already normalized. So simply add them without any further munging.
|
|
|
|
|
*/
|
|
|
|
|
if (!e) {
|
|
|
|
|
e = xmalloc(sizeof(*e));
|
2019-10-07 07:30:27 +08:00
|
|
|
hashmap_entry_init(&e->ent, strhash(key));
|
2014-07-28 18:10:38 +08:00
|
|
|
e->key = xstrdup(key);
|
|
|
|
|
string_list_init(&e->value_list, 1);
|
2019-10-07 07:30:29 +08:00
|
|
|
hashmap_add(&cs->config_hash, &e->ent);
|
2014-07-28 18:10:38 +08:00
|
|
|
}
|
2015-01-13 09:59:09 +08:00
|
|
|
si = string_list_append_nodup(&e->value_list, xstrdup_or_null(value));
|
2014-08-07 19:59:17 +08:00
|
|
|
|
|
|
|
|
ALLOC_GROW(cs->list.items, cs->list.nr + 1, cs->list.alloc);
|
|
|
|
|
l_item = &cs->list.items[cs->list.nr++];
|
|
|
|
|
l_item->e = e;
|
|
|
|
|
l_item->value_index = e->value_list.nr - 1;
|
|
|
|
|
|
2016-05-19 06:41:08 +08:00
|
|
|
if (!cf)
|
2018-05-02 17:38:39 +08:00
|
|
|
BUG("configset_add_value has no source");
|
2016-05-19 06:41:08 +08:00
|
|
|
if (cf->name) {
|
2014-08-07 19:59:14 +08:00
|
|
|
kv_info->filename = strintern(cf->name);
|
|
|
|
|
kv_info->linenr = cf->linenr;
|
i18n: config: unfold error messages marked for translation
Introduced in 473166b ("config: add 'origin_type' to config_source
struct", 2016-02-19), Git can inform the user about the origin of a
config error, but the implementation does not allow translators to
translate the keywords 'file', 'blob, 'standard input', and
'submodule-blob'. Moreover, for the second message, a reason for the
error is appended to the message, not allowing translators to translate
that reason either.
Unfold the message into several templates for each known origin_type.
That would result in better translation at the expense of code
verbosity.
Add enum config_oringin_type to ease management of the various
configuration origin types (blob, file, etc). Previously origin type
was considered from command line if cf->origin_type == NULL, i.e.,
uninitialized. Now we set origin_type to CONFIG_ORIGIN_CMDLINE in
git_config_from_parameters() and configset_add_value().
For error message in git_parse_source(), use xstrfmt() function to
prepare the message string, instead of doing something like it's done
for die_bad_number(), because intelligibility and code conciseness are
improved for that instance.
Signed-off-by: Vasco Almeida <vascomalmeida@sapo.pt>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-07-28 21:14:03 +08:00
|
|
|
kv_info->origin_type = cf->origin_type;
|
2014-08-07 19:59:14 +08:00
|
|
|
} else {
|
|
|
|
|
/* for values read from `git_config_from_parameters()` */
|
|
|
|
|
kv_info->filename = NULL;
|
|
|
|
|
kv_info->linenr = -1;
|
i18n: config: unfold error messages marked for translation
Introduced in 473166b ("config: add 'origin_type' to config_source
struct", 2016-02-19), Git can inform the user about the origin of a
config error, but the implementation does not allow translators to
translate the keywords 'file', 'blob, 'standard input', and
'submodule-blob'. Moreover, for the second message, a reason for the
error is appended to the message, not allowing translators to translate
that reason either.
Unfold the message into several templates for each known origin_type.
That would result in better translation at the expense of code
verbosity.
Add enum config_oringin_type to ease management of the various
configuration origin types (blob, file, etc). Previously origin type
was considered from command line if cf->origin_type == NULL, i.e.,
uninitialized. Now we set origin_type to CONFIG_ORIGIN_CMDLINE in
git_config_from_parameters() and configset_add_value().
For error message in git_parse_source(), use xstrfmt() function to
prepare the message string, instead of doing something like it's done
for die_bad_number(), because intelligibility and code conciseness are
improved for that instance.
Signed-off-by: Vasco Almeida <vascomalmeida@sapo.pt>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-07-28 21:14:03 +08:00
|
|
|
kv_info->origin_type = CONFIG_ORIGIN_CMDLINE;
|
2014-08-07 19:59:14 +08:00
|
|
|
}
|
config: add a notion of "scope"
A config callback passed to git_config() doesn't know very
much about the context in which it sees a variable. It can
ask whether the variable comes from a file, and get the file
name. But without analyzing the filename (which is hard to
do accurately), it cannot tell whether it is in system-level
config, user-level config, or repo-specific config.
Generally this doesn't matter; the point of not passing this
to the callback is that it should treat the config the same
no matter where it comes from. But some programs, like
upload-pack, are a special case: we should be able to run
them in an untrusted repository, which means we cannot use
any "dangerous" config from the repository config file (but
it is OK to use it from system or user config).
This patch teaches the config code to record the "scope" of
each variable, and make it available inside config
callbacks, similar to how we give access to the filename.
The scope is the starting source for a particular parsing
operation, and remains the same even if we include other
files (so a .git/config which includes another file will
remain CONFIG_SCOPE_REPO, as it would be similarly
untrusted).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-05-19 06:44:23 +08:00
|
|
|
kv_info->scope = current_parsing_scope;
|
2014-08-07 19:59:14 +08:00
|
|
|
si->util = kv_info;
|
2014-07-28 18:10:38 +08:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2017-07-01 03:14:05 +08:00
|
|
|
static int config_set_element_cmp(const void *unused_cmp_data,
|
2019-10-07 07:30:37 +08:00
|
|
|
const struct hashmap_entry *eptr,
|
|
|
|
|
const struct hashmap_entry *entry_or_key,
|
2017-07-01 03:14:05 +08:00
|
|
|
const void *unused_keydata)
|
2014-07-28 18:10:38 +08:00
|
|
|
{
|
2019-10-07 07:30:37 +08:00
|
|
|
const struct config_set_element *e1, *e2;
|
|
|
|
|
|
|
|
|
|
e1 = container_of(eptr, const struct config_set_element, ent);
|
|
|
|
|
e2 = container_of(entry_or_key, const struct config_set_element, ent);
|
2017-07-01 08:28:32 +08:00
|
|
|
|
2014-07-28 18:10:38 +08:00
|
|
|
return strcmp(e1->key, e2->key);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void git_configset_init(struct config_set *cs)
|
|
|
|
|
{
|
2017-07-01 08:28:32 +08:00
|
|
|
hashmap_init(&cs->config_hash, config_set_element_cmp, NULL, 0);
|
2014-07-28 18:10:38 +08:00
|
|
|
cs->hash_initialized = 1;
|
2014-08-07 19:59:17 +08:00
|
|
|
cs->list.nr = 0;
|
|
|
|
|
cs->list.alloc = 0;
|
|
|
|
|
cs->list.items = NULL;
|
2014-07-28 18:10:38 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void git_configset_clear(struct config_set *cs)
|
|
|
|
|
{
|
|
|
|
|
struct config_set_element *entry;
|
|
|
|
|
struct hashmap_iter iter;
|
|
|
|
|
if (!cs->hash_initialized)
|
|
|
|
|
return;
|
|
|
|
|
|
2019-10-07 07:30:38 +08:00
|
|
|
hashmap_for_each_entry(&cs->config_hash, &iter, entry,
|
|
|
|
|
ent /* member name */) {
|
2014-07-28 18:10:38 +08:00
|
|
|
free(entry->key);
|
2014-08-07 19:59:14 +08:00
|
|
|
string_list_clear(&entry->value_list, 1);
|
2014-07-28 18:10:38 +08:00
|
|
|
}
|
2019-10-07 07:30:40 +08:00
|
|
|
hashmap_free_entries(&cs->config_hash, struct config_set_element, ent);
|
2014-07-28 18:10:38 +08:00
|
|
|
cs->hash_initialized = 0;
|
2014-08-07 19:59:17 +08:00
|
|
|
free(cs->list.items);
|
|
|
|
|
cs->list.nr = 0;
|
|
|
|
|
cs->list.alloc = 0;
|
|
|
|
|
cs->list.items = NULL;
|
2014-07-28 18:10:38 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int config_set_callback(const char *key, const char *value, void *cb)
|
|
|
|
|
{
|
|
|
|
|
struct config_set *cs = cb;
|
|
|
|
|
configset_add_value(cs, key, value);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int git_configset_add_file(struct config_set *cs, const char *filename)
|
|
|
|
|
{
|
|
|
|
|
return git_config_from_file(config_set_callback, filename, cs);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int git_configset_get_value(struct config_set *cs, const char *key, const char **value)
|
|
|
|
|
{
|
|
|
|
|
const struct string_list *values = NULL;
|
|
|
|
|
/*
|
|
|
|
|
* Follows "last one wins" semantic, i.e., if there are multiple matches for the
|
|
|
|
|
* queried key in the files of the configset, the value returned will be the last
|
|
|
|
|
* value in the value list for that key.
|
|
|
|
|
*/
|
|
|
|
|
values = git_configset_get_value_multi(cs, key);
|
|
|
|
|
|
|
|
|
|
if (!values)
|
|
|
|
|
return 1;
|
|
|
|
|
assert(values->nr > 0);
|
|
|
|
|
*value = values->items[values->nr - 1].string;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const struct string_list *git_configset_get_value_multi(struct config_set *cs, const char *key)
|
|
|
|
|
{
|
|
|
|
|
struct config_set_element *e = configset_find_element(cs, key);
|
|
|
|
|
return e ? &e->value_list : NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int git_configset_get_string_const(struct config_set *cs, const char *key, const char **dest)
|
|
|
|
|
{
|
|
|
|
|
const char *value;
|
|
|
|
|
if (!git_configset_get_value(cs, key, &value))
|
|
|
|
|
return git_config_string(dest, key, value);
|
|
|
|
|
else
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int git_configset_get_string(struct config_set *cs, const char *key, char **dest)
|
|
|
|
|
{
|
|
|
|
|
return git_configset_get_string_const(cs, key, (const char **)dest);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int git_configset_get_int(struct config_set *cs, const char *key, int *dest)
|
|
|
|
|
{
|
|
|
|
|
const char *value;
|
|
|
|
|
if (!git_configset_get_value(cs, key, &value)) {
|
|
|
|
|
*dest = git_config_int(key, value);
|
|
|
|
|
return 0;
|
|
|
|
|
} else
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int git_configset_get_ulong(struct config_set *cs, const char *key, unsigned long *dest)
|
|
|
|
|
{
|
|
|
|
|
const char *value;
|
|
|
|
|
if (!git_configset_get_value(cs, key, &value)) {
|
|
|
|
|
*dest = git_config_ulong(key, value);
|
|
|
|
|
return 0;
|
|
|
|
|
} else
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int git_configset_get_bool(struct config_set *cs, const char *key, int *dest)
|
|
|
|
|
{
|
|
|
|
|
const char *value;
|
|
|
|
|
if (!git_configset_get_value(cs, key, &value)) {
|
|
|
|
|
*dest = git_config_bool(key, value);
|
|
|
|
|
return 0;
|
|
|
|
|
} else
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int git_configset_get_bool_or_int(struct config_set *cs, const char *key,
|
|
|
|
|
int *is_bool, int *dest)
|
|
|
|
|
{
|
|
|
|
|
const char *value;
|
|
|
|
|
if (!git_configset_get_value(cs, key, &value)) {
|
|
|
|
|
*dest = git_config_bool_or_int(key, value, is_bool);
|
|
|
|
|
return 0;
|
|
|
|
|
} else
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int git_configset_get_maybe_bool(struct config_set *cs, const char *key, int *dest)
|
|
|
|
|
{
|
|
|
|
|
const char *value;
|
|
|
|
|
if (!git_configset_get_value(cs, key, &value)) {
|
2017-08-08 02:20:49 +08:00
|
|
|
*dest = git_parse_maybe_bool(value);
|
2014-07-28 18:10:38 +08:00
|
|
|
if (*dest == -1)
|
|
|
|
|
return -1;
|
|
|
|
|
return 0;
|
|
|
|
|
} else
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int git_configset_get_pathname(struct config_set *cs, const char *key, const char **dest)
|
|
|
|
|
{
|
|
|
|
|
const char *value;
|
|
|
|
|
if (!git_configset_get_value(cs, key, &value))
|
|
|
|
|
return git_config_pathname(dest, key, value);
|
|
|
|
|
else
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
2017-06-23 02:43:42 +08:00
|
|
|
/* Functions use to read configuration from a repository */
|
|
|
|
|
static void repo_read_config(struct repository *repo)
|
2014-07-28 18:10:38 +08:00
|
|
|
{
|
2019-04-16 04:39:42 +08:00
|
|
|
struct config_options opts = { 0 };
|
2017-06-23 02:43:42 +08:00
|
|
|
|
|
|
|
|
opts.respect_includes = 1;
|
|
|
|
|
opts.commondir = repo->commondir;
|
|
|
|
|
opts.git_dir = repo->gitdir;
|
|
|
|
|
|
|
|
|
|
if (!repo->config)
|
|
|
|
|
repo->config = xcalloc(1, sizeof(struct config_set));
|
|
|
|
|
else
|
|
|
|
|
git_configset_clear(repo->config);
|
|
|
|
|
|
|
|
|
|
git_configset_init(repo->config);
|
|
|
|
|
|
|
|
|
|
if (config_with_options(config_set_callback, repo->config, NULL, &opts) < 0)
|
|
|
|
|
/*
|
|
|
|
|
* config_with_options() normally returns only
|
|
|
|
|
* zero, as most errors are fatal, and
|
|
|
|
|
* non-fatal potential errors are guarded by "if"
|
|
|
|
|
* statements that are entered only when no error is
|
|
|
|
|
* possible.
|
|
|
|
|
*
|
|
|
|
|
* If we ever encounter a non-fatal error, it means
|
|
|
|
|
* something went really wrong and we should stop
|
|
|
|
|
* immediately.
|
|
|
|
|
*/
|
|
|
|
|
die(_("unknown error occurred while reading the configuration files"));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void git_config_check_init(struct repository *repo)
|
|
|
|
|
{
|
|
|
|
|
if (repo->config && repo->config->hash_initialized)
|
2014-07-28 18:10:38 +08:00
|
|
|
return;
|
2017-06-23 02:43:42 +08:00
|
|
|
repo_read_config(repo);
|
2014-07-28 18:10:38 +08:00
|
|
|
}
|
|
|
|
|
|
2017-06-23 02:43:42 +08:00
|
|
|
static void repo_config_clear(struct repository *repo)
|
2014-07-28 18:10:38 +08:00
|
|
|
{
|
2017-06-23 02:43:42 +08:00
|
|
|
if (!repo->config || !repo->config->hash_initialized)
|
2014-07-28 18:10:38 +08:00
|
|
|
return;
|
2017-06-23 02:43:42 +08:00
|
|
|
git_configset_clear(repo->config);
|
2014-07-28 18:10:38 +08:00
|
|
|
}
|
|
|
|
|
|
2017-06-23 02:43:42 +08:00
|
|
|
void repo_config(struct repository *repo, config_fn_t fn, void *data)
|
2014-07-28 18:10:38 +08:00
|
|
|
{
|
2017-06-23 02:43:42 +08:00
|
|
|
git_config_check_init(repo);
|
|
|
|
|
configset_iter(repo->config, fn, data);
|
2014-07-28 18:10:38 +08:00
|
|
|
}
|
|
|
|
|
|
2017-06-23 02:43:42 +08:00
|
|
|
int repo_config_get_value(struct repository *repo,
|
|
|
|
|
const char *key, const char **value)
|
2014-07-28 18:10:38 +08:00
|
|
|
{
|
2017-06-23 02:43:42 +08:00
|
|
|
git_config_check_init(repo);
|
|
|
|
|
return git_configset_get_value(repo->config, key, value);
|
2014-07-28 18:10:38 +08:00
|
|
|
}
|
|
|
|
|
|
2017-06-23 02:43:42 +08:00
|
|
|
const struct string_list *repo_config_get_value_multi(struct repository *repo,
|
|
|
|
|
const char *key)
|
|
|
|
|
{
|
|
|
|
|
git_config_check_init(repo);
|
|
|
|
|
return git_configset_get_value_multi(repo->config, key);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int repo_config_get_string_const(struct repository *repo,
|
|
|
|
|
const char *key, const char **dest)
|
|
|
|
|
{
|
|
|
|
|
int ret;
|
|
|
|
|
git_config_check_init(repo);
|
|
|
|
|
ret = git_configset_get_string_const(repo->config, key, dest);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
git_die_config(key, NULL);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int repo_config_get_string(struct repository *repo,
|
|
|
|
|
const char *key, char **dest)
|
|
|
|
|
{
|
|
|
|
|
git_config_check_init(repo);
|
|
|
|
|
return repo_config_get_string_const(repo, key, (const char **)dest);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int repo_config_get_int(struct repository *repo,
|
|
|
|
|
const char *key, int *dest)
|
|
|
|
|
{
|
|
|
|
|
git_config_check_init(repo);
|
|
|
|
|
return git_configset_get_int(repo->config, key, dest);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int repo_config_get_ulong(struct repository *repo,
|
|
|
|
|
const char *key, unsigned long *dest)
|
|
|
|
|
{
|
|
|
|
|
git_config_check_init(repo);
|
|
|
|
|
return git_configset_get_ulong(repo->config, key, dest);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int repo_config_get_bool(struct repository *repo,
|
|
|
|
|
const char *key, int *dest)
|
|
|
|
|
{
|
|
|
|
|
git_config_check_init(repo);
|
|
|
|
|
return git_configset_get_bool(repo->config, key, dest);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int repo_config_get_bool_or_int(struct repository *repo,
|
|
|
|
|
const char *key, int *is_bool, int *dest)
|
|
|
|
|
{
|
|
|
|
|
git_config_check_init(repo);
|
|
|
|
|
return git_configset_get_bool_or_int(repo->config, key, is_bool, dest);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int repo_config_get_maybe_bool(struct repository *repo,
|
|
|
|
|
const char *key, int *dest)
|
|
|
|
|
{
|
|
|
|
|
git_config_check_init(repo);
|
|
|
|
|
return git_configset_get_maybe_bool(repo->config, key, dest);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int repo_config_get_pathname(struct repository *repo,
|
|
|
|
|
const char *key, const char **dest)
|
2014-07-28 18:10:38 +08:00
|
|
|
{
|
2014-08-07 19:59:16 +08:00
|
|
|
int ret;
|
2017-06-23 02:43:42 +08:00
|
|
|
git_config_check_init(repo);
|
|
|
|
|
ret = git_configset_get_pathname(repo->config, key, dest);
|
2014-08-07 19:59:16 +08:00
|
|
|
if (ret < 0)
|
|
|
|
|
git_die_config(key, NULL);
|
|
|
|
|
return ret;
|
2014-07-28 18:10:38 +08:00
|
|
|
}
|
|
|
|
|
|
2017-06-23 02:43:42 +08:00
|
|
|
/* Functions used historically to read configuration from 'the_repository' */
|
|
|
|
|
void git_config(config_fn_t fn, void *data)
|
|
|
|
|
{
|
|
|
|
|
repo_config(the_repository, fn, data);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void git_config_clear(void)
|
|
|
|
|
{
|
|
|
|
|
repo_config_clear(the_repository);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int git_config_get_value(const char *key, const char **value)
|
|
|
|
|
{
|
|
|
|
|
return repo_config_get_value(the_repository, key, value);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const struct string_list *git_config_get_value_multi(const char *key)
|
|
|
|
|
{
|
|
|
|
|
return repo_config_get_value_multi(the_repository, key);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int git_config_get_string_const(const char *key, const char **dest)
|
|
|
|
|
{
|
|
|
|
|
return repo_config_get_string_const(the_repository, key, dest);
|
|
|
|
|
}
|
|
|
|
|
|
2014-07-28 18:10:38 +08:00
|
|
|
int git_config_get_string(const char *key, char **dest)
|
|
|
|
|
{
|
2017-06-23 02:43:42 +08:00
|
|
|
return repo_config_get_string(the_repository, key, dest);
|
2014-07-28 18:10:38 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int git_config_get_int(const char *key, int *dest)
|
|
|
|
|
{
|
2017-06-23 02:43:42 +08:00
|
|
|
return repo_config_get_int(the_repository, key, dest);
|
2014-07-28 18:10:38 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int git_config_get_ulong(const char *key, unsigned long *dest)
|
|
|
|
|
{
|
2017-06-23 02:43:42 +08:00
|
|
|
return repo_config_get_ulong(the_repository, key, dest);
|
2014-07-28 18:10:38 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int git_config_get_bool(const char *key, int *dest)
|
|
|
|
|
{
|
2017-06-23 02:43:42 +08:00
|
|
|
return repo_config_get_bool(the_repository, key, dest);
|
2014-07-28 18:10:38 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int git_config_get_bool_or_int(const char *key, int *is_bool, int *dest)
|
|
|
|
|
{
|
2017-06-23 02:43:42 +08:00
|
|
|
return repo_config_get_bool_or_int(the_repository, key, is_bool, dest);
|
2014-07-28 18:10:38 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int git_config_get_maybe_bool(const char *key, int *dest)
|
|
|
|
|
{
|
2017-06-23 02:43:42 +08:00
|
|
|
return repo_config_get_maybe_bool(the_repository, key, dest);
|
2014-07-28 18:10:38 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int git_config_get_pathname(const char *key, const char **dest)
|
|
|
|
|
{
|
2017-06-23 02:43:42 +08:00
|
|
|
return repo_config_get_pathname(the_repository, key, dest);
|
2014-08-07 19:59:16 +08:00
|
|
|
}
|
|
|
|
|
|
2017-02-28 02:00:13 +08:00
|
|
|
int git_config_get_expiry(const char *key, const char **output)
|
|
|
|
|
{
|
|
|
|
|
int ret = git_config_get_string_const(key, output);
|
|
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
|
|
|
|
if (strcmp(*output, "now")) {
|
2017-04-27 03:29:31 +08:00
|
|
|
timestamp_t now = approxidate("now");
|
2017-02-28 02:00:13 +08:00
|
|
|
if (approxidate(*output) >= now)
|
|
|
|
|
git_die_config(key, _("Invalid %s: '%s'"), key, *output);
|
|
|
|
|
}
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2017-08-20 02:43:39 +08:00
|
|
|
int git_config_get_expiry_in_days(const char *key, timestamp_t *expiry, timestamp_t now)
|
|
|
|
|
{
|
|
|
|
|
char *expiry_string;
|
|
|
|
|
intmax_t days;
|
|
|
|
|
timestamp_t when;
|
|
|
|
|
|
|
|
|
|
if (git_config_get_string(key, &expiry_string))
|
|
|
|
|
return 1; /* no such thing */
|
|
|
|
|
|
|
|
|
|
if (git_parse_signed(expiry_string, &days, maximum_signed_value_of_type(int))) {
|
|
|
|
|
const int scale = 86400;
|
|
|
|
|
*expiry = now - days * scale;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!parse_expiry_date(expiry_string, &when)) {
|
|
|
|
|
*expiry = when;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
return -1; /* thing exists but cannot be parsed */
|
|
|
|
|
}
|
|
|
|
|
|
2017-02-28 02:00:00 +08:00
|
|
|
int git_config_get_split_index(void)
|
|
|
|
|
{
|
|
|
|
|
int val;
|
|
|
|
|
|
|
|
|
|
if (!git_config_get_maybe_bool("core.splitindex", &val))
|
|
|
|
|
return val;
|
|
|
|
|
|
|
|
|
|
return -1; /* default value */
|
|
|
|
|
}
|
|
|
|
|
|
2017-02-28 02:00:07 +08:00
|
|
|
int git_config_get_max_percent_split_change(void)
|
|
|
|
|
{
|
|
|
|
|
int val = -1;
|
|
|
|
|
|
|
|
|
|
if (!git_config_get_int("splitindex.maxpercentchange", &val)) {
|
|
|
|
|
if (0 <= val && val <= 100)
|
|
|
|
|
return val;
|
|
|
|
|
|
|
|
|
|
return error(_("splitIndex.maxPercentChange value '%d' "
|
|
|
|
|
"should be between 0 and 100"), val);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return -1; /* default value */
|
|
|
|
|
}
|
|
|
|
|
|
2017-09-23 00:35:40 +08:00
|
|
|
int git_config_get_fsmonitor(void)
|
|
|
|
|
{
|
|
|
|
|
if (git_config_get_pathname("core.fsmonitor", &core_fsmonitor))
|
2018-09-19 07:29:35 +08:00
|
|
|
core_fsmonitor = getenv("GIT_TEST_FSMONITOR");
|
2017-09-23 00:35:40 +08:00
|
|
|
|
|
|
|
|
if (core_fsmonitor && !*core_fsmonitor)
|
|
|
|
|
core_fsmonitor = NULL;
|
|
|
|
|
|
|
|
|
|
if (core_fsmonitor)
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
index: make index.threads=true enable ieot and eoie
If a user explicitly sets
[index]
threads = true
to read the index using multiple threads, ensure that index writes
include the offset table by default to make that possible. This
ensures that the user's intent of turning on threading is respected.
In other words, permit the following configurations:
- index.threads and index.recordOffsetTable unspecified: do not write
the offset table yet (to avoid alarming the user with "ignoring IEOT
extension" messages when an older version of Git accesses the
repository) but do make use of multiple threads to read the index if
the supporting offset table is present.
This can also be requested explicitly by setting index.threads=true,
0, or >1 and index.recordOffsetTable=false.
- index.threads=false or 1: do not write the offset table, and do not
make use of the offset table.
One can set index.recordOffsetTable=false as well, to be more
explicit.
- index.threads=true, 0, or >1 and index.recordOffsetTable unspecified:
write the offset table and make use of threads at read time.
This can also be requested by setting index.threads=true, 0, >1, or
unspecified and index.recordOffsetTable=true.
Fortunately the complication is temporary: once most Git installations
have upgraded to a version with support for the IEOT and EOIE
extensions, we can flip the defaults for index.recordEndOfIndexEntries
and index.recordOffsetTable to true and eliminate the settings.
Helped-by: Ben Peart <benpeart@microsoft.com>
Signed-off-by: Jonathan Nieder <jrnieder@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-11-20 14:14:26 +08:00
|
|
|
int git_config_get_index_threads(int *dest)
|
2018-10-10 23:59:35 +08:00
|
|
|
{
|
index: make index.threads=true enable ieot and eoie
If a user explicitly sets
[index]
threads = true
to read the index using multiple threads, ensure that index writes
include the offset table by default to make that possible. This
ensures that the user's intent of turning on threading is respected.
In other words, permit the following configurations:
- index.threads and index.recordOffsetTable unspecified: do not write
the offset table yet (to avoid alarming the user with "ignoring IEOT
extension" messages when an older version of Git accesses the
repository) but do make use of multiple threads to read the index if
the supporting offset table is present.
This can also be requested explicitly by setting index.threads=true,
0, or >1 and index.recordOffsetTable=false.
- index.threads=false or 1: do not write the offset table, and do not
make use of the offset table.
One can set index.recordOffsetTable=false as well, to be more
explicit.
- index.threads=true, 0, or >1 and index.recordOffsetTable unspecified:
write the offset table and make use of threads at read time.
This can also be requested by setting index.threads=true, 0, >1, or
unspecified and index.recordOffsetTable=true.
Fortunately the complication is temporary: once most Git installations
have upgraded to a version with support for the IEOT and EOIE
extensions, we can flip the defaults for index.recordEndOfIndexEntries
and index.recordOffsetTable to true and eliminate the settings.
Helped-by: Ben Peart <benpeart@microsoft.com>
Signed-off-by: Jonathan Nieder <jrnieder@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-11-20 14:14:26 +08:00
|
|
|
int is_bool, val;
|
2018-10-10 23:59:35 +08:00
|
|
|
|
|
|
|
|
val = git_env_ulong("GIT_TEST_INDEX_THREADS", 0);
|
index: make index.threads=true enable ieot and eoie
If a user explicitly sets
[index]
threads = true
to read the index using multiple threads, ensure that index writes
include the offset table by default to make that possible. This
ensures that the user's intent of turning on threading is respected.
In other words, permit the following configurations:
- index.threads and index.recordOffsetTable unspecified: do not write
the offset table yet (to avoid alarming the user with "ignoring IEOT
extension" messages when an older version of Git accesses the
repository) but do make use of multiple threads to read the index if
the supporting offset table is present.
This can also be requested explicitly by setting index.threads=true,
0, or >1 and index.recordOffsetTable=false.
- index.threads=false or 1: do not write the offset table, and do not
make use of the offset table.
One can set index.recordOffsetTable=false as well, to be more
explicit.
- index.threads=true, 0, or >1 and index.recordOffsetTable unspecified:
write the offset table and make use of threads at read time.
This can also be requested by setting index.threads=true, 0, >1, or
unspecified and index.recordOffsetTable=true.
Fortunately the complication is temporary: once most Git installations
have upgraded to a version with support for the IEOT and EOIE
extensions, we can flip the defaults for index.recordEndOfIndexEntries
and index.recordOffsetTable to true and eliminate the settings.
Helped-by: Ben Peart <benpeart@microsoft.com>
Signed-off-by: Jonathan Nieder <jrnieder@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-11-20 14:14:26 +08:00
|
|
|
if (val) {
|
|
|
|
|
*dest = val;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2018-10-10 23:59:35 +08:00
|
|
|
|
|
|
|
|
if (!git_config_get_bool_or_int("index.threads", &is_bool, &val)) {
|
|
|
|
|
if (is_bool)
|
index: make index.threads=true enable ieot and eoie
If a user explicitly sets
[index]
threads = true
to read the index using multiple threads, ensure that index writes
include the offset table by default to make that possible. This
ensures that the user's intent of turning on threading is respected.
In other words, permit the following configurations:
- index.threads and index.recordOffsetTable unspecified: do not write
the offset table yet (to avoid alarming the user with "ignoring IEOT
extension" messages when an older version of Git accesses the
repository) but do make use of multiple threads to read the index if
the supporting offset table is present.
This can also be requested explicitly by setting index.threads=true,
0, or >1 and index.recordOffsetTable=false.
- index.threads=false or 1: do not write the offset table, and do not
make use of the offset table.
One can set index.recordOffsetTable=false as well, to be more
explicit.
- index.threads=true, 0, or >1 and index.recordOffsetTable unspecified:
write the offset table and make use of threads at read time.
This can also be requested by setting index.threads=true, 0, >1, or
unspecified and index.recordOffsetTable=true.
Fortunately the complication is temporary: once most Git installations
have upgraded to a version with support for the IEOT and EOIE
extensions, we can flip the defaults for index.recordEndOfIndexEntries
and index.recordOffsetTable to true and eliminate the settings.
Helped-by: Ben Peart <benpeart@microsoft.com>
Signed-off-by: Jonathan Nieder <jrnieder@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-11-20 14:14:26 +08:00
|
|
|
*dest = val ? 0 : 1;
|
2018-10-10 23:59:35 +08:00
|
|
|
else
|
index: make index.threads=true enable ieot and eoie
If a user explicitly sets
[index]
threads = true
to read the index using multiple threads, ensure that index writes
include the offset table by default to make that possible. This
ensures that the user's intent of turning on threading is respected.
In other words, permit the following configurations:
- index.threads and index.recordOffsetTable unspecified: do not write
the offset table yet (to avoid alarming the user with "ignoring IEOT
extension" messages when an older version of Git accesses the
repository) but do make use of multiple threads to read the index if
the supporting offset table is present.
This can also be requested explicitly by setting index.threads=true,
0, or >1 and index.recordOffsetTable=false.
- index.threads=false or 1: do not write the offset table, and do not
make use of the offset table.
One can set index.recordOffsetTable=false as well, to be more
explicit.
- index.threads=true, 0, or >1 and index.recordOffsetTable unspecified:
write the offset table and make use of threads at read time.
This can also be requested by setting index.threads=true, 0, >1, or
unspecified and index.recordOffsetTable=true.
Fortunately the complication is temporary: once most Git installations
have upgraded to a version with support for the IEOT and EOIE
extensions, we can flip the defaults for index.recordEndOfIndexEntries
and index.recordOffsetTable to true and eliminate the settings.
Helped-by: Ben Peart <benpeart@microsoft.com>
Signed-off-by: Jonathan Nieder <jrnieder@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-11-20 14:14:26 +08:00
|
|
|
*dest = val;
|
|
|
|
|
return 0;
|
2018-10-10 23:59:35 +08:00
|
|
|
}
|
|
|
|
|
|
index: make index.threads=true enable ieot and eoie
If a user explicitly sets
[index]
threads = true
to read the index using multiple threads, ensure that index writes
include the offset table by default to make that possible. This
ensures that the user's intent of turning on threading is respected.
In other words, permit the following configurations:
- index.threads and index.recordOffsetTable unspecified: do not write
the offset table yet (to avoid alarming the user with "ignoring IEOT
extension" messages when an older version of Git accesses the
repository) but do make use of multiple threads to read the index if
the supporting offset table is present.
This can also be requested explicitly by setting index.threads=true,
0, or >1 and index.recordOffsetTable=false.
- index.threads=false or 1: do not write the offset table, and do not
make use of the offset table.
One can set index.recordOffsetTable=false as well, to be more
explicit.
- index.threads=true, 0, or >1 and index.recordOffsetTable unspecified:
write the offset table and make use of threads at read time.
This can also be requested by setting index.threads=true, 0, >1, or
unspecified and index.recordOffsetTable=true.
Fortunately the complication is temporary: once most Git installations
have upgraded to a version with support for the IEOT and EOIE
extensions, we can flip the defaults for index.recordEndOfIndexEntries
and index.recordOffsetTable to true and eliminate the settings.
Helped-by: Ben Peart <benpeart@microsoft.com>
Signed-off-by: Jonathan Nieder <jrnieder@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-11-20 14:14:26 +08:00
|
|
|
return 1;
|
2018-10-10 23:59:35 +08:00
|
|
|
}
|
|
|
|
|
|
2014-08-07 19:59:16 +08:00
|
|
|
NORETURN
|
|
|
|
|
void git_die_config_linenr(const char *key, const char *filename, int linenr)
|
|
|
|
|
{
|
|
|
|
|
if (!filename)
|
|
|
|
|
die(_("unable to parse '%s' from command-line config"), key);
|
|
|
|
|
else
|
|
|
|
|
die(_("bad config variable '%s' in file '%s' at line %d"),
|
|
|
|
|
key, filename, linenr);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
NORETURN __attribute__((format(printf, 2, 3)))
|
|
|
|
|
void git_die_config(const char *key, const char *err, ...)
|
|
|
|
|
{
|
|
|
|
|
const struct string_list *values;
|
|
|
|
|
struct key_value_info *kv_info;
|
|
|
|
|
|
|
|
|
|
if (err) {
|
|
|
|
|
va_list params;
|
|
|
|
|
va_start(params, err);
|
|
|
|
|
vreportf("error: ", err, params);
|
|
|
|
|
va_end(params);
|
|
|
|
|
}
|
|
|
|
|
values = git_config_get_value_multi(key);
|
|
|
|
|
kv_info = values->items[values->nr - 1].util;
|
|
|
|
|
git_die_config_linenr(key, kv_info->filename, kv_info->linenr);
|
2014-07-28 18:10:38 +08:00
|
|
|
}
|
|
|
|
|
|
2005-11-18 05:32:36 +08:00
|
|
|
/*
|
|
|
|
|
* Find all the stuff for git_config_set() below.
|
|
|
|
|
*/
|
2005-11-20 13:52:22 +08:00
|
|
|
|
2018-04-09 16:32:09 +08:00
|
|
|
struct config_store_data {
|
2005-11-18 05:32:36 +08:00
|
|
|
int baselen;
|
2009-05-01 17:06:36 +08:00
|
|
|
char *key;
|
2005-11-20 20:24:18 +08:00
|
|
|
int do_not_match;
|
2009-05-01 17:06:36 +08:00
|
|
|
regex_t *value_regex;
|
2005-11-20 13:52:22 +08:00
|
|
|
int multi_replace;
|
git_config_set: make use of the config parser's event stream
In the recent commit with the title "config: introduce an optional event
stream while parsing", we introduced an optional callback to keep track
of the config parser's events "comment", "white-space", "section header"
and "entry".
One motivation for this feature was to make use of it in the code that
edits the config. And this commit makes it so.
Note: this patch changes the meaning of the `seen` array that records
whether we saw the config entry that is to be edited: previously, it
contained the end offset of the found entry. Now, we introduce a new
array `parsed` that keeps a record of *all* config parser events (with
begin/end offsets), and the items in the `seen` array now point into the
`parsed` array.
There are two reasons why we do it this way:
1. To keep the implementation simple, the config parser's event stream
reports the event only after the config callback was called, so we
would not receive the begin offset otherwise.
2. In the following patches, we will re-use the `parsed` array to fix two
long-standing bugs related to empty sections.
Note that this also makes the code more robust with respect to finding the
begin offset of the part(s) of the config file to be edited, as we no
longer back-track to find the beginning of the line.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 16:32:20 +08:00
|
|
|
struct {
|
|
|
|
|
size_t begin, end;
|
|
|
|
|
enum config_event_t type;
|
git config --unset: remove empty sections (in the common case)
The original reasoning for not removing section headers upon removal of
the last entry went like this: the user could have added comments about
the section, or about the entries therein, and if there were other
comments there, we would not know whether we should remove them.
In particular, a concocted example was presented that looked like this
(and was added to t1300):
# some generic comment on the configuration file itself
# a comment specific to this "section" section.
[section]
# some intervening lines
# that should also be dropped
key = value
# please be careful when you update the above variable
The ideal thing for `git config --unset section.key` in this case would
be to leave only the first line behind, because all the other comments
are now obsolete.
However, this is unfeasible, short of adding a complete Natural Language
Processing module to Git, which seems not only a lot of work, but a
totally unreasonable feature (for little benefit to most users).
Now, the real kicker about this problem is: most users do not edit their
config files at all! In their use case, the config looks like this
instead:
[section]
key = value
... and it is totally obvious what should happen if the entry is
removed: the entire section should vanish.
Let's generalize this observation to this conservative strategy: if we
are removing the last entry from a section, and there are no comments
inside that section nor surrounding it, then remove the entire section.
Otherwise behave as before: leave the now-empty section (including those
comments, even ones about the now-deleted entry).
We have to be extra careful to handle the case where more than one entry
is removed: any subset of them might be the last entries of their
respective sections (and if there are no comments in or around that
section, the section should be removed, too).
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 16:32:24 +08:00
|
|
|
int is_keys_section;
|
git_config_set: make use of the config parser's event stream
In the recent commit with the title "config: introduce an optional event
stream while parsing", we introduced an optional callback to keep track
of the config parser's events "comment", "white-space", "section header"
and "entry".
One motivation for this feature was to make use of it in the code that
edits the config. And this commit makes it so.
Note: this patch changes the meaning of the `seen` array that records
whether we saw the config entry that is to be edited: previously, it
contained the end offset of the found entry. Now, we introduce a new
array `parsed` that keeps a record of *all* config parser events (with
begin/end offsets), and the items in the `seen` array now point into the
`parsed` array.
There are two reasons why we do it this way:
1. To keep the implementation simple, the config parser's event stream
reports the event only after the config callback was called, so we
would not receive the begin offset otherwise.
2. In the following patches, we will re-use the `parsed` array to fix two
long-standing bugs related to empty sections.
Note that this also makes the code more robust with respect to finding the
begin offset of the part(s) of the config file to be edited, as we no
longer back-track to find the beginning of the line.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 16:32:20 +08:00
|
|
|
} *parsed;
|
|
|
|
|
unsigned int parsed_nr, parsed_alloc, *seen, seen_nr, seen_alloc;
|
2018-04-09 16:32:17 +08:00
|
|
|
unsigned int key_seen:1, section_seen:1, is_keys_section:1;
|
2018-04-09 16:32:09 +08:00
|
|
|
};
|
2005-11-18 05:32:36 +08:00
|
|
|
|
2018-05-20 18:42:33 +08:00
|
|
|
static void config_store_data_clear(struct config_store_data *store)
|
|
|
|
|
{
|
2018-05-20 18:42:35 +08:00
|
|
|
free(store->key);
|
2018-05-20 18:42:34 +08:00
|
|
|
if (store->value_regex != NULL &&
|
|
|
|
|
store->value_regex != CONFIG_REGEX_NONE) {
|
|
|
|
|
regfree(store->value_regex);
|
|
|
|
|
free(store->value_regex);
|
|
|
|
|
}
|
2018-05-20 18:42:33 +08:00
|
|
|
free(store->parsed);
|
|
|
|
|
free(store->seen);
|
|
|
|
|
memset(store, 0, sizeof(*store));
|
|
|
|
|
}
|
|
|
|
|
|
2018-04-09 16:32:09 +08:00
|
|
|
static int matches(const char *key, const char *value,
|
|
|
|
|
const struct config_store_data *store)
|
2005-11-20 20:24:18 +08:00
|
|
|
{
|
2018-04-09 16:32:09 +08:00
|
|
|
if (strcmp(key, store->key))
|
2014-08-19 14:20:00 +08:00
|
|
|
return 0; /* not ours */
|
2018-04-09 16:32:09 +08:00
|
|
|
if (!store->value_regex)
|
2014-08-19 14:20:00 +08:00
|
|
|
return 1; /* always matches */
|
2018-04-09 16:32:09 +08:00
|
|
|
if (store->value_regex == CONFIG_REGEX_NONE)
|
2014-08-19 14:20:00 +08:00
|
|
|
return 0; /* never matches */
|
|
|
|
|
|
2018-04-09 16:32:09 +08:00
|
|
|
return store->do_not_match ^
|
|
|
|
|
(value && !regexec(store->value_regex, value, 0, NULL, 0));
|
2005-11-20 20:24:18 +08:00
|
|
|
}
|
|
|
|
|
|
git_config_set: make use of the config parser's event stream
In the recent commit with the title "config: introduce an optional event
stream while parsing", we introduced an optional callback to keep track
of the config parser's events "comment", "white-space", "section header"
and "entry".
One motivation for this feature was to make use of it in the code that
edits the config. And this commit makes it so.
Note: this patch changes the meaning of the `seen` array that records
whether we saw the config entry that is to be edited: previously, it
contained the end offset of the found entry. Now, we introduce a new
array `parsed` that keeps a record of *all* config parser events (with
begin/end offsets), and the items in the `seen` array now point into the
`parsed` array.
There are two reasons why we do it this way:
1. To keep the implementation simple, the config parser's event stream
reports the event only after the config callback was called, so we
would not receive the begin offset otherwise.
2. In the following patches, we will re-use the `parsed` array to fix two
long-standing bugs related to empty sections.
Note that this also makes the code more robust with respect to finding the
begin offset of the part(s) of the config file to be edited, as we no
longer back-track to find the beginning of the line.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 16:32:20 +08:00
|
|
|
static int store_aux_event(enum config_event_t type,
|
|
|
|
|
size_t begin, size_t end, void *data)
|
|
|
|
|
{
|
|
|
|
|
struct config_store_data *store = data;
|
|
|
|
|
|
|
|
|
|
ALLOC_GROW(store->parsed, store->parsed_nr + 1, store->parsed_alloc);
|
|
|
|
|
store->parsed[store->parsed_nr].begin = begin;
|
|
|
|
|
store->parsed[store->parsed_nr].end = end;
|
|
|
|
|
store->parsed[store->parsed_nr].type = type;
|
|
|
|
|
|
|
|
|
|
if (type == CONFIG_EVENT_SECTION) {
|
2018-08-09 03:50:19 +08:00
|
|
|
int (*cmpfn)(const char *, const char *, size_t);
|
|
|
|
|
|
git_config_set: make use of the config parser's event stream
In the recent commit with the title "config: introduce an optional event
stream while parsing", we introduced an optional callback to keep track
of the config parser's events "comment", "white-space", "section header"
and "entry".
One motivation for this feature was to make use of it in the code that
edits the config. And this commit makes it so.
Note: this patch changes the meaning of the `seen` array that records
whether we saw the config entry that is to be edited: previously, it
contained the end offset of the found entry. Now, we introduce a new
array `parsed` that keeps a record of *all* config parser events (with
begin/end offsets), and the items in the `seen` array now point into the
`parsed` array.
There are two reasons why we do it this way:
1. To keep the implementation simple, the config parser's event stream
reports the event only after the config callback was called, so we
would not receive the begin offset otherwise.
2. In the following patches, we will re-use the `parsed` array to fix two
long-standing bugs related to empty sections.
Note that this also makes the code more robust with respect to finding the
begin offset of the part(s) of the config file to be edited, as we no
longer back-track to find the beginning of the line.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 16:32:20 +08:00
|
|
|
if (cf->var.len < 2 || cf->var.buf[cf->var.len - 1] != '.')
|
2018-07-21 15:49:27 +08:00
|
|
|
return error(_("invalid section name '%s'"), cf->var.buf);
|
git_config_set: make use of the config parser's event stream
In the recent commit with the title "config: introduce an optional event
stream while parsing", we introduced an optional callback to keep track
of the config parser's events "comment", "white-space", "section header"
and "entry".
One motivation for this feature was to make use of it in the code that
edits the config. And this commit makes it so.
Note: this patch changes the meaning of the `seen` array that records
whether we saw the config entry that is to be edited: previously, it
contained the end offset of the found entry. Now, we introduce a new
array `parsed` that keeps a record of *all* config parser events (with
begin/end offsets), and the items in the `seen` array now point into the
`parsed` array.
There are two reasons why we do it this way:
1. To keep the implementation simple, the config parser's event stream
reports the event only after the config callback was called, so we
would not receive the begin offset otherwise.
2. In the following patches, we will re-use the `parsed` array to fix two
long-standing bugs related to empty sections.
Note that this also makes the code more robust with respect to finding the
begin offset of the part(s) of the config file to be edited, as we no
longer back-track to find the beginning of the line.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 16:32:20 +08:00
|
|
|
|
2018-08-09 03:50:19 +08:00
|
|
|
if (cf->subsection_case_sensitive)
|
|
|
|
|
cmpfn = strncasecmp;
|
|
|
|
|
else
|
|
|
|
|
cmpfn = strncmp;
|
|
|
|
|
|
git_config_set: make use of the config parser's event stream
In the recent commit with the title "config: introduce an optional event
stream while parsing", we introduced an optional callback to keep track
of the config parser's events "comment", "white-space", "section header"
and "entry".
One motivation for this feature was to make use of it in the code that
edits the config. And this commit makes it so.
Note: this patch changes the meaning of the `seen` array that records
whether we saw the config entry that is to be edited: previously, it
contained the end offset of the found entry. Now, we introduce a new
array `parsed` that keeps a record of *all* config parser events (with
begin/end offsets), and the items in the `seen` array now point into the
`parsed` array.
There are two reasons why we do it this way:
1. To keep the implementation simple, the config parser's event stream
reports the event only after the config callback was called, so we
would not receive the begin offset otherwise.
2. In the following patches, we will re-use the `parsed` array to fix two
long-standing bugs related to empty sections.
Note that this also makes the code more robust with respect to finding the
begin offset of the part(s) of the config file to be edited, as we no
longer back-track to find the beginning of the line.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 16:32:20 +08:00
|
|
|
/* Is this the section we were looking for? */
|
git config --unset: remove empty sections (in the common case)
The original reasoning for not removing section headers upon removal of
the last entry went like this: the user could have added comments about
the section, or about the entries therein, and if there were other
comments there, we would not know whether we should remove them.
In particular, a concocted example was presented that looked like this
(and was added to t1300):
# some generic comment on the configuration file itself
# a comment specific to this "section" section.
[section]
# some intervening lines
# that should also be dropped
key = value
# please be careful when you update the above variable
The ideal thing for `git config --unset section.key` in this case would
be to leave only the first line behind, because all the other comments
are now obsolete.
However, this is unfeasible, short of adding a complete Natural Language
Processing module to Git, which seems not only a lot of work, but a
totally unreasonable feature (for little benefit to most users).
Now, the real kicker about this problem is: most users do not edit their
config files at all! In their use case, the config looks like this
instead:
[section]
key = value
... and it is totally obvious what should happen if the entry is
removed: the entire section should vanish.
Let's generalize this observation to this conservative strategy: if we
are removing the last entry from a section, and there are no comments
inside that section nor surrounding it, then remove the entire section.
Otherwise behave as before: leave the now-empty section (including those
comments, even ones about the now-deleted entry).
We have to be extra careful to handle the case where more than one entry
is removed: any subset of them might be the last entries of their
respective sections (and if there are no comments in or around that
section, the section should be removed, too).
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 16:32:24 +08:00
|
|
|
store->is_keys_section =
|
|
|
|
|
store->parsed[store->parsed_nr].is_keys_section =
|
|
|
|
|
cf->var.len - 1 == store->baselen &&
|
2018-08-09 03:50:19 +08:00
|
|
|
!cmpfn(cf->var.buf, store->key, store->baselen);
|
2018-04-09 16:32:29 +08:00
|
|
|
if (store->is_keys_section) {
|
|
|
|
|
store->section_seen = 1;
|
|
|
|
|
ALLOC_GROW(store->seen, store->seen_nr + 1,
|
|
|
|
|
store->seen_alloc);
|
|
|
|
|
store->seen[store->seen_nr] = store->parsed_nr;
|
|
|
|
|
}
|
git_config_set: make use of the config parser's event stream
In the recent commit with the title "config: introduce an optional event
stream while parsing", we introduced an optional callback to keep track
of the config parser's events "comment", "white-space", "section header"
and "entry".
One motivation for this feature was to make use of it in the code that
edits the config. And this commit makes it so.
Note: this patch changes the meaning of the `seen` array that records
whether we saw the config entry that is to be edited: previously, it
contained the end offset of the found entry. Now, we introduce a new
array `parsed` that keeps a record of *all* config parser events (with
begin/end offsets), and the items in the `seen` array now point into the
`parsed` array.
There are two reasons why we do it this way:
1. To keep the implementation simple, the config parser's event stream
reports the event only after the config callback was called, so we
would not receive the begin offset otherwise.
2. In the following patches, we will re-use the `parsed` array to fix two
long-standing bugs related to empty sections.
Note that this also makes the code more robust with respect to finding the
begin offset of the part(s) of the config file to be edited, as we no
longer back-track to find the beginning of the line.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 16:32:20 +08:00
|
|
|
}
|
|
|
|
|
|
git config --unset: remove empty sections (in the common case)
The original reasoning for not removing section headers upon removal of
the last entry went like this: the user could have added comments about
the section, or about the entries therein, and if there were other
comments there, we would not know whether we should remove them.
In particular, a concocted example was presented that looked like this
(and was added to t1300):
# some generic comment on the configuration file itself
# a comment specific to this "section" section.
[section]
# some intervening lines
# that should also be dropped
key = value
# please be careful when you update the above variable
The ideal thing for `git config --unset section.key` in this case would
be to leave only the first line behind, because all the other comments
are now obsolete.
However, this is unfeasible, short of adding a complete Natural Language
Processing module to Git, which seems not only a lot of work, but a
totally unreasonable feature (for little benefit to most users).
Now, the real kicker about this problem is: most users do not edit their
config files at all! In their use case, the config looks like this
instead:
[section]
key = value
... and it is totally obvious what should happen if the entry is
removed: the entire section should vanish.
Let's generalize this observation to this conservative strategy: if we
are removing the last entry from a section, and there are no comments
inside that section nor surrounding it, then remove the entire section.
Otherwise behave as before: leave the now-empty section (including those
comments, even ones about the now-deleted entry).
We have to be extra careful to handle the case where more than one entry
is removed: any subset of them might be the last entries of their
respective sections (and if there are no comments in or around that
section, the section should be removed, too).
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 16:32:24 +08:00
|
|
|
store->parsed_nr++;
|
|
|
|
|
|
git_config_set: make use of the config parser's event stream
In the recent commit with the title "config: introduce an optional event
stream while parsing", we introduced an optional callback to keep track
of the config parser's events "comment", "white-space", "section header"
and "entry".
One motivation for this feature was to make use of it in the code that
edits the config. And this commit makes it so.
Note: this patch changes the meaning of the `seen` array that records
whether we saw the config entry that is to be edited: previously, it
contained the end offset of the found entry. Now, we introduce a new
array `parsed` that keeps a record of *all* config parser events (with
begin/end offsets), and the items in the `seen` array now point into the
`parsed` array.
There are two reasons why we do it this way:
1. To keep the implementation simple, the config parser's event stream
reports the event only after the config callback was called, so we
would not receive the begin offset otherwise.
2. In the following patches, we will re-use the `parsed` array to fix two
long-standing bugs related to empty sections.
Note that this also makes the code more robust with respect to finding the
begin offset of the part(s) of the config file to be edited, as we no
longer back-track to find the beginning of the line.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 16:32:20 +08:00
|
|
|
return 0;
|
2005-11-20 20:24:18 +08:00
|
|
|
}
|
|
|
|
|
|
2009-05-01 17:06:36 +08:00
|
|
|
static int store_aux(const char *key, const char *value, void *cb)
|
2005-11-18 05:32:36 +08:00
|
|
|
{
|
2018-04-09 16:32:09 +08:00
|
|
|
struct config_store_data *store = cb;
|
2007-05-13 12:49:33 +08:00
|
|
|
|
2018-04-09 16:32:17 +08:00
|
|
|
if (store->key_seen) {
|
2018-04-09 16:32:09 +08:00
|
|
|
if (matches(key, value, store)) {
|
2018-04-09 16:32:13 +08:00
|
|
|
if (store->seen_nr == 1 && store->multi_replace == 0) {
|
2014-08-07 19:59:12 +08:00
|
|
|
warning(_("%s has multiple values"), key);
|
2005-11-18 05:32:36 +08:00
|
|
|
}
|
2005-11-20 13:52:22 +08:00
|
|
|
|
2018-04-09 16:32:13 +08:00
|
|
|
ALLOC_GROW(store->seen, store->seen_nr + 1,
|
|
|
|
|
store->seen_alloc);
|
2013-11-13 18:19:00 +08:00
|
|
|
|
git_config_set: make use of the config parser's event stream
In the recent commit with the title "config: introduce an optional event
stream while parsing", we introduced an optional callback to keep track
of the config parser's events "comment", "white-space", "section header"
and "entry".
One motivation for this feature was to make use of it in the code that
edits the config. And this commit makes it so.
Note: this patch changes the meaning of the `seen` array that records
whether we saw the config entry that is to be edited: previously, it
contained the end offset of the found entry. Now, we introduce a new
array `parsed` that keeps a record of *all* config parser events (with
begin/end offsets), and the items in the `seen` array now point into the
`parsed` array.
There are two reasons why we do it this way:
1. To keep the implementation simple, the config parser's event stream
reports the event only after the config callback was called, so we
would not receive the begin offset otherwise.
2. In the following patches, we will re-use the `parsed` array to fix two
long-standing bugs related to empty sections.
Note that this also makes the code more robust with respect to finding the
begin offset of the part(s) of the config file to be edited, as we no
longer back-track to find the beginning of the line.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 16:32:20 +08:00
|
|
|
store->seen[store->seen_nr] = store->parsed_nr;
|
2018-04-09 16:32:13 +08:00
|
|
|
store->seen_nr++;
|
2005-11-18 05:32:36 +08:00
|
|
|
}
|
2018-04-09 16:32:17 +08:00
|
|
|
} else if (store->is_keys_section) {
|
2007-05-13 12:49:33 +08:00
|
|
|
/*
|
git_config_set: make use of the config parser's event stream
In the recent commit with the title "config: introduce an optional event
stream while parsing", we introduced an optional callback to keep track
of the config parser's events "comment", "white-space", "section header"
and "entry".
One motivation for this feature was to make use of it in the code that
edits the config. And this commit makes it so.
Note: this patch changes the meaning of the `seen` array that records
whether we saw the config entry that is to be edited: previously, it
contained the end offset of the found entry. Now, we introduce a new
array `parsed` that keeps a record of *all* config parser events (with
begin/end offsets), and the items in the `seen` array now point into the
`parsed` array.
There are two reasons why we do it this way:
1. To keep the implementation simple, the config parser's event stream
reports the event only after the config callback was called, so we
would not receive the begin offset otherwise.
2. In the following patches, we will re-use the `parsed` array to fix two
long-standing bugs related to empty sections.
Note that this also makes the code more robust with respect to finding the
begin offset of the part(s) of the config file to be edited, as we no
longer back-track to find the beginning of the line.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 16:32:20 +08:00
|
|
|
* Do not increment matches yet: this may not be a match, but we
|
|
|
|
|
* are in the desired section.
|
2007-05-13 12:49:33 +08:00
|
|
|
*/
|
git_config_set: make use of the config parser's event stream
In the recent commit with the title "config: introduce an optional event
stream while parsing", we introduced an optional callback to keep track
of the config parser's events "comment", "white-space", "section header"
and "entry".
One motivation for this feature was to make use of it in the code that
edits the config. And this commit makes it so.
Note: this patch changes the meaning of the `seen` array that records
whether we saw the config entry that is to be edited: previously, it
contained the end offset of the found entry. Now, we introduce a new
array `parsed` that keeps a record of *all* config parser events (with
begin/end offsets), and the items in the `seen` array now point into the
`parsed` array.
There are two reasons why we do it this way:
1. To keep the implementation simple, the config parser's event stream
reports the event only after the config callback was called, so we
would not receive the begin offset otherwise.
2. In the following patches, we will re-use the `parsed` array to fix two
long-standing bugs related to empty sections.
Note that this also makes the code more robust with respect to finding the
begin offset of the part(s) of the config file to be edited, as we no
longer back-track to find the beginning of the line.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 16:32:20 +08:00
|
|
|
ALLOC_GROW(store->seen, store->seen_nr + 1, store->seen_alloc);
|
|
|
|
|
store->seen[store->seen_nr] = store->parsed_nr;
|
2018-04-09 16:32:17 +08:00
|
|
|
store->section_seen = 1;
|
2007-05-13 12:49:33 +08:00
|
|
|
|
git_config_set: make use of the config parser's event stream
In the recent commit with the title "config: introduce an optional event
stream while parsing", we introduced an optional callback to keep track
of the config parser's events "comment", "white-space", "section header"
and "entry".
One motivation for this feature was to make use of it in the code that
edits the config. And this commit makes it so.
Note: this patch changes the meaning of the `seen` array that records
whether we saw the config entry that is to be edited: previously, it
contained the end offset of the found entry. Now, we introduce a new
array `parsed` that keeps a record of *all* config parser events (with
begin/end offsets), and the items in the `seen` array now point into the
`parsed` array.
There are two reasons why we do it this way:
1. To keep the implementation simple, the config parser's event stream
reports the event only after the config callback was called, so we
would not receive the begin offset otherwise.
2. In the following patches, we will re-use the `parsed` array to fix two
long-standing bugs related to empty sections.
Note that this also makes the code more robust with respect to finding the
begin offset of the part(s) of the config file to be edited, as we no
longer back-track to find the beginning of the line.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 16:32:20 +08:00
|
|
|
if (matches(key, value, store)) {
|
|
|
|
|
store->seen_nr++;
|
|
|
|
|
store->key_seen = 1;
|
2006-05-07 02:14:02 +08:00
|
|
|
}
|
2005-11-18 05:32:36 +08:00
|
|
|
}
|
2018-04-09 16:32:17 +08:00
|
|
|
|
2005-11-18 05:32:36 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2008-05-13 05:41:04 +08:00
|
|
|
static int write_error(const char *filename)
|
2007-01-08 23:58:38 +08:00
|
|
|
{
|
2018-07-21 15:49:27 +08:00
|
|
|
error(_("failed to write new configuration file %s"), filename);
|
2007-01-08 23:58:38 +08:00
|
|
|
|
|
|
|
|
/* Same error code as "failed to rename". */
|
|
|
|
|
return 4;
|
|
|
|
|
}
|
|
|
|
|
|
2018-04-09 16:32:09 +08:00
|
|
|
static struct strbuf store_create_section(const char *key,
|
|
|
|
|
const struct config_store_data *store)
|
2005-11-18 05:32:36 +08:00
|
|
|
{
|
2007-12-15 04:59:58 +08:00
|
|
|
const char *dot;
|
2017-09-14 01:17:57 +08:00
|
|
|
int i;
|
2008-10-10 03:12:12 +08:00
|
|
|
struct strbuf sb = STRBUF_INIT;
|
2006-05-10 03:24:02 +08:00
|
|
|
|
2018-04-09 16:32:09 +08:00
|
|
|
dot = memchr(key, '.', store->baselen);
|
2006-05-10 03:24:02 +08:00
|
|
|
if (dot) {
|
2007-12-15 04:59:58 +08:00
|
|
|
strbuf_addf(&sb, "[%.*s \"", (int)(dot - key), key);
|
2018-04-09 16:32:09 +08:00
|
|
|
for (i = dot - key + 1; i < store->baselen; i++) {
|
2008-05-04 13:37:52 +08:00
|
|
|
if (key[i] == '"' || key[i] == '\\')
|
2007-12-15 04:59:58 +08:00
|
|
|
strbuf_addch(&sb, '\\');
|
|
|
|
|
strbuf_addch(&sb, key[i]);
|
2006-05-10 03:24:02 +08:00
|
|
|
}
|
2007-12-15 04:59:58 +08:00
|
|
|
strbuf_addstr(&sb, "\"]\n");
|
|
|
|
|
} else {
|
2018-04-09 16:32:09 +08:00
|
|
|
strbuf_addf(&sb, "[%.*s]\n", store->baselen, key);
|
2006-05-10 03:24:02 +08:00
|
|
|
}
|
|
|
|
|
|
2017-06-19 05:16:31 +08:00
|
|
|
return sb;
|
|
|
|
|
}
|
|
|
|
|
|
2018-04-09 16:32:09 +08:00
|
|
|
static ssize_t write_section(int fd, const char *key,
|
|
|
|
|
const struct config_store_data *store)
|
2017-06-19 05:16:31 +08:00
|
|
|
{
|
2018-04-09 16:32:09 +08:00
|
|
|
struct strbuf sb = store_create_section(key, store);
|
2017-10-03 14:42:48 +08:00
|
|
|
ssize_t ret;
|
2017-06-19 05:16:31 +08:00
|
|
|
|
2017-11-18 18:20:04 +08:00
|
|
|
ret = write_in_full(fd, sb.buf, sb.len);
|
2007-12-15 04:59:58 +08:00
|
|
|
strbuf_release(&sb);
|
2007-01-08 23:58:38 +08:00
|
|
|
|
2017-09-14 01:17:57 +08:00
|
|
|
return ret;
|
2005-11-18 05:32:36 +08:00
|
|
|
}
|
|
|
|
|
|
2018-04-09 16:32:09 +08:00
|
|
|
static ssize_t write_pair(int fd, const char *key, const char *value,
|
|
|
|
|
const struct config_store_data *store)
|
2005-11-18 05:32:36 +08:00
|
|
|
{
|
2017-09-14 01:17:57 +08:00
|
|
|
int i;
|
|
|
|
|
ssize_t ret;
|
2018-04-09 16:32:09 +08:00
|
|
|
int length = strlen(key + store->baselen + 1);
|
2007-12-15 04:59:58 +08:00
|
|
|
const char *quote = "";
|
2008-10-10 03:12:12 +08:00
|
|
|
struct strbuf sb = STRBUF_INIT;
|
2007-01-09 13:27:41 +08:00
|
|
|
|
2007-12-08 23:48:05 +08:00
|
|
|
/*
|
|
|
|
|
* Check to see if the value needs to be surrounded with a dq pair.
|
|
|
|
|
* Note that problematic characters are always backslash-quoted; this
|
|
|
|
|
* check is about not losing leading or trailing SP and strings that
|
|
|
|
|
* follow beginning-of-comment characters (i.e. ';' and '#') by the
|
|
|
|
|
* configuration parser.
|
|
|
|
|
*/
|
2007-01-09 13:27:41 +08:00
|
|
|
if (value[0] == ' ')
|
2007-12-15 04:59:58 +08:00
|
|
|
quote = "\"";
|
2007-01-09 13:27:41 +08:00
|
|
|
for (i = 0; value[i]; i++)
|
|
|
|
|
if (value[i] == ';' || value[i] == '#')
|
2007-12-15 04:59:58 +08:00
|
|
|
quote = "\"";
|
|
|
|
|
if (i && value[i - 1] == ' ')
|
|
|
|
|
quote = "\"";
|
|
|
|
|
|
|
|
|
|
strbuf_addf(&sb, "\t%.*s = %s",
|
2018-04-09 16:32:09 +08:00
|
|
|
length, key + store->baselen + 1, quote);
|
2005-11-18 05:32:36 +08:00
|
|
|
|
|
|
|
|
for (i = 0; value[i]; i++)
|
|
|
|
|
switch (value[i]) {
|
2007-01-08 23:58:38 +08:00
|
|
|
case '\n':
|
2007-12-15 04:59:58 +08:00
|
|
|
strbuf_addstr(&sb, "\\n");
|
2007-01-08 23:58:38 +08:00
|
|
|
break;
|
|
|
|
|
case '\t':
|
2007-12-15 04:59:58 +08:00
|
|
|
strbuf_addstr(&sb, "\\t");
|
2007-01-08 23:58:38 +08:00
|
|
|
break;
|
|
|
|
|
case '"':
|
|
|
|
|
case '\\':
|
2007-12-15 04:59:58 +08:00
|
|
|
strbuf_addch(&sb, '\\');
|
consistently use "fallthrough" comments in switches
Gcc 7 adds -Wimplicit-fallthrough, which can warn when a
switch case falls through to the next case. The general idea
is that the compiler can't tell if this was intentional or
not, so you should annotate any intentional fall-throughs as
such, leaving it to complain about any unannotated ones.
There's a GNU __attribute__ which can be used for
annotation, but of course we'd have to #ifdef it away on
non-gcc compilers. Gcc will also recognize
specially-formatted comments, which matches our current
practice. Let's extend that practice to all of the
unannotated sites (which I did look over and verify that
they were behaving as intended).
Ideally in each case we'd actually give some reasons in the
comment about why we're falling through, or what we're
falling through to. And gcc does support that with
-Wimplicit-fallthrough=2, which relaxes the comment pattern
matching to anything that contains "fallthrough" (or a
variety of spelling variants). However, this isn't the
default for -Wimplicit-fallthrough, nor for -Wextra. In the
name of simplicity, it's probably better for us to support
the default level, which requires "fallthrough" to be the
only thing in the comment (modulo some window dressing like
"else" and some punctuation; see the gcc manual for the
complete set of patterns).
This patch suppresses all warnings due to
-Wimplicit-fallthrough. We might eventually want to add that
to the DEVELOPER Makefile knob, but we should probably wait
until gcc 7 is more widely adopted (since earlier versions
will complain about the unknown warning type).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-21 14:25:41 +08:00
|
|
|
/* fallthrough */
|
2007-01-08 23:58:38 +08:00
|
|
|
default:
|
2007-12-15 04:59:58 +08:00
|
|
|
strbuf_addch(&sb, value[i]);
|
2007-01-08 23:58:38 +08:00
|
|
|
break;
|
|
|
|
|
}
|
2007-12-15 04:59:58 +08:00
|
|
|
strbuf_addf(&sb, "%s\n", quote);
|
|
|
|
|
|
2017-09-14 01:17:57 +08:00
|
|
|
ret = write_in_full(fd, sb.buf, sb.len);
|
2007-12-15 04:59:58 +08:00
|
|
|
strbuf_release(&sb);
|
|
|
|
|
|
2017-09-14 01:17:57 +08:00
|
|
|
return ret;
|
2005-11-18 05:32:36 +08:00
|
|
|
}
|
|
|
|
|
|
git config --unset: remove empty sections (in the common case)
The original reasoning for not removing section headers upon removal of
the last entry went like this: the user could have added comments about
the section, or about the entries therein, and if there were other
comments there, we would not know whether we should remove them.
In particular, a concocted example was presented that looked like this
(and was added to t1300):
# some generic comment on the configuration file itself
# a comment specific to this "section" section.
[section]
# some intervening lines
# that should also be dropped
key = value
# please be careful when you update the above variable
The ideal thing for `git config --unset section.key` in this case would
be to leave only the first line behind, because all the other comments
are now obsolete.
However, this is unfeasible, short of adding a complete Natural Language
Processing module to Git, which seems not only a lot of work, but a
totally unreasonable feature (for little benefit to most users).
Now, the real kicker about this problem is: most users do not edit their
config files at all! In their use case, the config looks like this
instead:
[section]
key = value
... and it is totally obvious what should happen if the entry is
removed: the entire section should vanish.
Let's generalize this observation to this conservative strategy: if we
are removing the last entry from a section, and there are no comments
inside that section nor surrounding it, then remove the entire section.
Otherwise behave as before: leave the now-empty section (including those
comments, even ones about the now-deleted entry).
We have to be extra careful to handle the case where more than one entry
is removed: any subset of them might be the last entries of their
respective sections (and if there are no comments in or around that
section, the section should be removed, too).
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 16:32:24 +08:00
|
|
|
/*
|
|
|
|
|
* If we are about to unset the last key(s) in a section, and if there are
|
|
|
|
|
* no comments surrounding (or included in) the section, we will want to
|
|
|
|
|
* extend begin/end to remove the entire section.
|
|
|
|
|
*
|
|
|
|
|
* Note: the parameter `seen_ptr` points to the index into the store.seen
|
|
|
|
|
* array. * This index may be incremented if a section has more than one
|
|
|
|
|
* entry (which all are to be removed).
|
|
|
|
|
*/
|
|
|
|
|
static void maybe_remove_section(struct config_store_data *store,
|
|
|
|
|
size_t *begin_offset, size_t *end_offset,
|
|
|
|
|
int *seen_ptr)
|
2005-11-20 13:52:22 +08:00
|
|
|
{
|
git config --unset: remove empty sections (in the common case)
The original reasoning for not removing section headers upon removal of
the last entry went like this: the user could have added comments about
the section, or about the entries therein, and if there were other
comments there, we would not know whether we should remove them.
In particular, a concocted example was presented that looked like this
(and was added to t1300):
# some generic comment on the configuration file itself
# a comment specific to this "section" section.
[section]
# some intervening lines
# that should also be dropped
key = value
# please be careful when you update the above variable
The ideal thing for `git config --unset section.key` in this case would
be to leave only the first line behind, because all the other comments
are now obsolete.
However, this is unfeasible, short of adding a complete Natural Language
Processing module to Git, which seems not only a lot of work, but a
totally unreasonable feature (for little benefit to most users).
Now, the real kicker about this problem is: most users do not edit their
config files at all! In their use case, the config looks like this
instead:
[section]
key = value
... and it is totally obvious what should happen if the entry is
removed: the entire section should vanish.
Let's generalize this observation to this conservative strategy: if we
are removing the last entry from a section, and there are no comments
inside that section nor surrounding it, then remove the entire section.
Otherwise behave as before: leave the now-empty section (including those
comments, even ones about the now-deleted entry).
We have to be extra careful to handle the case where more than one entry
is removed: any subset of them might be the last entries of their
respective sections (and if there are no comments in or around that
section, the section should be removed, too).
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 16:32:24 +08:00
|
|
|
size_t begin;
|
|
|
|
|
int i, seen, section_seen = 0;
|
2005-11-20 13:52:22 +08:00
|
|
|
|
git config --unset: remove empty sections (in the common case)
The original reasoning for not removing section headers upon removal of
the last entry went like this: the user could have added comments about
the section, or about the entries therein, and if there were other
comments there, we would not know whether we should remove them.
In particular, a concocted example was presented that looked like this
(and was added to t1300):
# some generic comment on the configuration file itself
# a comment specific to this "section" section.
[section]
# some intervening lines
# that should also be dropped
key = value
# please be careful when you update the above variable
The ideal thing for `git config --unset section.key` in this case would
be to leave only the first line behind, because all the other comments
are now obsolete.
However, this is unfeasible, short of adding a complete Natural Language
Processing module to Git, which seems not only a lot of work, but a
totally unreasonable feature (for little benefit to most users).
Now, the real kicker about this problem is: most users do not edit their
config files at all! In their use case, the config looks like this
instead:
[section]
key = value
... and it is totally obvious what should happen if the entry is
removed: the entire section should vanish.
Let's generalize this observation to this conservative strategy: if we
are removing the last entry from a section, and there are no comments
inside that section nor surrounding it, then remove the entire section.
Otherwise behave as before: leave the now-empty section (including those
comments, even ones about the now-deleted entry).
We have to be extra careful to handle the case where more than one entry
is removed: any subset of them might be the last entries of their
respective sections (and if there are no comments in or around that
section, the section should be removed, too).
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 16:32:24 +08:00
|
|
|
/*
|
|
|
|
|
* First, ensure that this is the first key, and that there are no
|
|
|
|
|
* comments before the entry nor before the section header.
|
|
|
|
|
*/
|
|
|
|
|
seen = *seen_ptr;
|
|
|
|
|
for (i = store->seen[seen]; i > 0; i--) {
|
|
|
|
|
enum config_event_t type = store->parsed[i - 1].type;
|
|
|
|
|
|
|
|
|
|
if (type == CONFIG_EVENT_COMMENT)
|
|
|
|
|
/* There is a comment before this entry or section */
|
|
|
|
|
return;
|
|
|
|
|
if (type == CONFIG_EVENT_ENTRY) {
|
|
|
|
|
if (!section_seen)
|
|
|
|
|
/* This is not the section's first entry. */
|
|
|
|
|
return;
|
|
|
|
|
/* We encountered no comment before the section. */
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
if (type == CONFIG_EVENT_SECTION) {
|
|
|
|
|
if (!store->parsed[i - 1].is_keys_section)
|
|
|
|
|
break;
|
|
|
|
|
section_seen = 1;
|
2005-11-20 13:52:22 +08:00
|
|
|
}
|
2008-02-11 08:23:03 +08:00
|
|
|
}
|
git config --unset: remove empty sections (in the common case)
The original reasoning for not removing section headers upon removal of
the last entry went like this: the user could have added comments about
the section, or about the entries therein, and if there were other
comments there, we would not know whether we should remove them.
In particular, a concocted example was presented that looked like this
(and was added to t1300):
# some generic comment on the configuration file itself
# a comment specific to this "section" section.
[section]
# some intervening lines
# that should also be dropped
key = value
# please be careful when you update the above variable
The ideal thing for `git config --unset section.key` in this case would
be to leave only the first line behind, because all the other comments
are now obsolete.
However, this is unfeasible, short of adding a complete Natural Language
Processing module to Git, which seems not only a lot of work, but a
totally unreasonable feature (for little benefit to most users).
Now, the real kicker about this problem is: most users do not edit their
config files at all! In their use case, the config looks like this
instead:
[section]
key = value
... and it is totally obvious what should happen if the entry is
removed: the entire section should vanish.
Let's generalize this observation to this conservative strategy: if we
are removing the last entry from a section, and there are no comments
inside that section nor surrounding it, then remove the entire section.
Otherwise behave as before: leave the now-empty section (including those
comments, even ones about the now-deleted entry).
We have to be extra careful to handle the case where more than one entry
is removed: any subset of them might be the last entries of their
respective sections (and if there are no comments in or around that
section, the section should be removed, too).
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 16:32:24 +08:00
|
|
|
begin = store->parsed[i].begin;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Next, make sure that we are removing he last key(s) in the section,
|
|
|
|
|
* and that there are no comments that are possibly about the current
|
|
|
|
|
* section.
|
|
|
|
|
*/
|
|
|
|
|
for (i = store->seen[seen] + 1; i < store->parsed_nr; i++) {
|
|
|
|
|
enum config_event_t type = store->parsed[i].type;
|
2005-11-20 13:52:22 +08:00
|
|
|
|
git config --unset: remove empty sections (in the common case)
The original reasoning for not removing section headers upon removal of
the last entry went like this: the user could have added comments about
the section, or about the entries therein, and if there were other
comments there, we would not know whether we should remove them.
In particular, a concocted example was presented that looked like this
(and was added to t1300):
# some generic comment on the configuration file itself
# a comment specific to this "section" section.
[section]
# some intervening lines
# that should also be dropped
key = value
# please be careful when you update the above variable
The ideal thing for `git config --unset section.key` in this case would
be to leave only the first line behind, because all the other comments
are now obsolete.
However, this is unfeasible, short of adding a complete Natural Language
Processing module to Git, which seems not only a lot of work, but a
totally unreasonable feature (for little benefit to most users).
Now, the real kicker about this problem is: most users do not edit their
config files at all! In their use case, the config looks like this
instead:
[section]
key = value
... and it is totally obvious what should happen if the entry is
removed: the entire section should vanish.
Let's generalize this observation to this conservative strategy: if we
are removing the last entry from a section, and there are no comments
inside that section nor surrounding it, then remove the entire section.
Otherwise behave as before: leave the now-empty section (including those
comments, even ones about the now-deleted entry).
We have to be extra careful to handle the case where more than one entry
is removed: any subset of them might be the last entries of their
respective sections (and if there are no comments in or around that
section, the section should be removed, too).
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 16:32:24 +08:00
|
|
|
if (type == CONFIG_EVENT_COMMENT)
|
|
|
|
|
return;
|
|
|
|
|
if (type == CONFIG_EVENT_SECTION) {
|
|
|
|
|
if (store->parsed[i].is_keys_section)
|
|
|
|
|
continue;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
if (type == CONFIG_EVENT_ENTRY) {
|
|
|
|
|
if (++seen < store->seen_nr &&
|
|
|
|
|
i == store->seen[seen])
|
|
|
|
|
/* We want to remove this entry, too */
|
|
|
|
|
continue;
|
|
|
|
|
/* There is another entry in this section. */
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* We are really removing the last entry/entries from this section, and
|
|
|
|
|
* there are no enclosed or surrounding comments. Remove the entire,
|
|
|
|
|
* now-empty section.
|
|
|
|
|
*/
|
|
|
|
|
*seen_ptr = seen;
|
|
|
|
|
*begin_offset = begin;
|
|
|
|
|
if (i < store->parsed_nr)
|
|
|
|
|
*end_offset = store->parsed[i].begin;
|
|
|
|
|
else
|
|
|
|
|
*end_offset = store->parsed[store->parsed_nr - 1].end;
|
2005-11-20 13:52:22 +08:00
|
|
|
}
|
|
|
|
|
|
2016-02-22 19:23:35 +08:00
|
|
|
int git_config_set_in_file_gently(const char *config_filename,
|
|
|
|
|
const char *key, const char *value)
|
2011-08-04 18:39:00 +08:00
|
|
|
{
|
2016-02-22 19:23:35 +08:00
|
|
|
return git_config_set_multivar_in_file_gently(config_filename, key, value, NULL, 0);
|
2011-08-04 18:39:00 +08:00
|
|
|
}
|
|
|
|
|
|
2016-02-22 19:23:36 +08:00
|
|
|
void git_config_set_in_file(const char *config_filename,
|
|
|
|
|
const char *key, const char *value)
|
2005-11-18 05:32:36 +08:00
|
|
|
{
|
2016-02-22 19:23:36 +08:00
|
|
|
git_config_set_multivar_in_file(config_filename, key, value, NULL, 0);
|
2016-02-16 20:56:28 +08:00
|
|
|
}
|
|
|
|
|
|
2016-02-22 19:23:35 +08:00
|
|
|
int git_config_set_gently(const char *key, const char *value)
|
2005-11-18 05:32:36 +08:00
|
|
|
{
|
2016-02-22 19:23:35 +08:00
|
|
|
return git_config_set_multivar_gently(key, value, NULL, 0);
|
2005-11-18 05:32:36 +08:00
|
|
|
}
|
|
|
|
|
|
2016-02-22 19:23:36 +08:00
|
|
|
void git_config_set(const char *key, const char *value)
|
2016-02-16 20:56:28 +08:00
|
|
|
{
|
2016-02-22 19:23:36 +08:00
|
|
|
git_config_set_multivar(key, value, NULL, 0);
|
2019-02-23 06:25:01 +08:00
|
|
|
|
|
|
|
|
trace2_cmd_set_config(key, value);
|
2005-11-18 05:32:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* If value==NULL, unset in (remove from) config,
|
|
|
|
|
* if value_regex!=NULL, disregard key/value pairs where value does not match.
|
2014-08-19 14:20:00 +08:00
|
|
|
* if value_regex==CONFIG_REGEX_NONE, do not match any existing values
|
|
|
|
|
* (only add a new one)
|
2005-11-20 13:52:22 +08:00
|
|
|
* if multi_replace==0, nothing, or only one matching key/value is replaced,
|
|
|
|
|
* else all matching key/values (regardless how many) are removed,
|
|
|
|
|
* before the new pair is written.
|
2005-11-18 05:32:36 +08:00
|
|
|
*
|
|
|
|
|
* Returns 0 on success.
|
|
|
|
|
*
|
|
|
|
|
* This function does this:
|
|
|
|
|
*
|
|
|
|
|
* - it locks the config file by creating ".git/config.lock"
|
|
|
|
|
*
|
|
|
|
|
* - it then parses the config using store_aux() as validator to find
|
|
|
|
|
* the position on the key/value pair to replace. If it is to be unset,
|
|
|
|
|
* it must be found exactly once.
|
|
|
|
|
*
|
|
|
|
|
* - the config file is mmap()ed and the part before the match (if any) is
|
|
|
|
|
* written to the lock file, then the changed part and the rest.
|
|
|
|
|
*
|
|
|
|
|
* - the config file is removed and the lock file rename()d to it.
|
|
|
|
|
*
|
|
|
|
|
*/
|
2016-02-22 19:23:35 +08:00
|
|
|
int git_config_set_multivar_in_file_gently(const char *config_filename,
|
|
|
|
|
const char *key, const char *value,
|
|
|
|
|
const char *value_regex,
|
|
|
|
|
int multi_replace)
|
2005-11-18 05:32:36 +08:00
|
|
|
{
|
2015-08-15 04:21:17 +08:00
|
|
|
int fd = -1, in_fd = -1;
|
2006-04-17 23:14:48 +08:00
|
|
|
int ret;
|
2017-09-05 20:15:21 +08:00
|
|
|
struct lock_file lock = LOCK_INIT;
|
2012-02-16 16:04:05 +08:00
|
|
|
char *filename_buf = NULL;
|
2015-05-28 15:54:43 +08:00
|
|
|
char *contents = NULL;
|
|
|
|
|
size_t contents_sz;
|
2018-04-09 16:32:09 +08:00
|
|
|
struct config_store_data store;
|
|
|
|
|
|
|
|
|
|
memset(&store, 0, sizeof(store));
|
2005-11-20 13:52:22 +08:00
|
|
|
|
2011-01-31 03:40:41 +08:00
|
|
|
/* parse-key returns negative; flip the sign to feed exit(3) */
|
|
|
|
|
ret = 0 - git_config_parse_key(key, &store.key, &store.baselen);
|
|
|
|
|
if (ret)
|
2006-04-17 23:14:48 +08:00
|
|
|
goto out_free;
|
2005-11-21 04:22:19 +08:00
|
|
|
|
|
|
|
|
store.multi_replace = multi_replace;
|
2005-11-18 05:32:36 +08:00
|
|
|
|
2012-02-16 16:04:05 +08:00
|
|
|
if (!config_filename)
|
|
|
|
|
config_filename = filename_buf = git_pathdup("config");
|
2005-11-18 05:32:36 +08:00
|
|
|
|
|
|
|
|
/*
|
2007-07-27 00:55:28 +08:00
|
|
|
* The lock serves a purpose in addition to locking: the new
|
2005-11-18 05:32:36 +08:00
|
|
|
* contents of .git/config will be written into it.
|
|
|
|
|
*/
|
2017-09-05 20:15:21 +08:00
|
|
|
fd = hold_lock_file_for_update(&lock, config_filename, 0);
|
2007-07-27 00:55:28 +08:00
|
|
|
if (fd < 0) {
|
2018-07-21 15:49:27 +08:00
|
|
|
error_errno(_("could not lock config file %s"), config_filename);
|
2011-05-17 23:38:52 +08:00
|
|
|
ret = CONFIG_NO_LOCK;
|
2006-04-17 23:14:48 +08:00
|
|
|
goto out_free;
|
2005-11-18 05:32:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* If .git/config does not exist yet, write a minimal version.
|
|
|
|
|
*/
|
2006-01-05 19:43:34 +08:00
|
|
|
in_fd = open(config_filename, O_RDONLY);
|
|
|
|
|
if ( in_fd < 0 ) {
|
|
|
|
|
if ( ENOENT != errno ) {
|
2018-07-21 15:49:27 +08:00
|
|
|
error_errno(_("opening %s"), config_filename);
|
2011-05-17 23:38:52 +08:00
|
|
|
ret = CONFIG_INVALID_FILE; /* same as "invalid config file" */
|
2006-04-17 23:14:48 +08:00
|
|
|
goto out_free;
|
2006-01-05 19:43:34 +08:00
|
|
|
}
|
2005-11-18 05:32:36 +08:00
|
|
|
/* if nothing to unset, error out */
|
|
|
|
|
if (value == NULL) {
|
2011-05-17 23:38:52 +08:00
|
|
|
ret = CONFIG_NOTHING_SET;
|
2006-04-17 23:14:48 +08:00
|
|
|
goto out_free;
|
2005-11-18 05:32:36 +08:00
|
|
|
}
|
|
|
|
|
|
2018-05-20 18:42:35 +08:00
|
|
|
free(store.key);
|
|
|
|
|
store.key = xstrdup(key);
|
2018-04-09 16:32:09 +08:00
|
|
|
if (write_section(fd, key, &store) < 0 ||
|
|
|
|
|
write_pair(fd, key, value, &store) < 0)
|
2007-01-12 05:16:26 +08:00
|
|
|
goto write_err_out;
|
|
|
|
|
} else {
|
2006-01-05 19:43:34 +08:00
|
|
|
struct stat st;
|
2015-05-28 15:54:43 +08:00
|
|
|
size_t copy_begin, copy_end;
|
2007-03-07 09:44:37 +08:00
|
|
|
int i, new_line = 0;
|
git_config_set: make use of the config parser's event stream
In the recent commit with the title "config: introduce an optional event
stream while parsing", we introduced an optional callback to keep track
of the config parser's events "comment", "white-space", "section header"
and "entry".
One motivation for this feature was to make use of it in the code that
edits the config. And this commit makes it so.
Note: this patch changes the meaning of the `seen` array that records
whether we saw the config entry that is to be edited: previously, it
contained the end offset of the found entry. Now, we introduce a new
array `parsed` that keeps a record of *all* config parser events (with
begin/end offsets), and the items in the `seen` array now point into the
`parsed` array.
There are two reasons why we do it this way:
1. To keep the implementation simple, the config parser's event stream
reports the event only after the config callback was called, so we
would not receive the begin offset otherwise.
2. In the following patches, we will re-use the `parsed` array to fix two
long-standing bugs related to empty sections.
Note that this also makes the code more robust with respect to finding the
begin offset of the part(s) of the config file to be edited, as we no
longer back-track to find the beginning of the line.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 16:32:20 +08:00
|
|
|
struct config_options opts;
|
2005-11-18 05:32:36 +08:00
|
|
|
|
|
|
|
|
if (value_regex == NULL)
|
|
|
|
|
store.value_regex = NULL;
|
2014-08-19 14:20:00 +08:00
|
|
|
else if (value_regex == CONFIG_REGEX_NONE)
|
|
|
|
|
store.value_regex = CONFIG_REGEX_NONE;
|
2005-11-18 05:32:36 +08:00
|
|
|
else {
|
2005-11-20 20:24:18 +08:00
|
|
|
if (value_regex[0] == '!') {
|
|
|
|
|
store.do_not_match = 1;
|
|
|
|
|
value_regex++;
|
|
|
|
|
} else
|
|
|
|
|
store.do_not_match = 0;
|
|
|
|
|
|
2006-09-01 06:32:39 +08:00
|
|
|
store.value_regex = (regex_t*)xmalloc(sizeof(regex_t));
|
2005-11-18 05:32:36 +08:00
|
|
|
if (regcomp(store.value_regex, value_regex,
|
|
|
|
|
REG_EXTENDED)) {
|
2018-07-21 15:49:27 +08:00
|
|
|
error(_("invalid pattern: %s"), value_regex);
|
2018-05-20 18:42:34 +08:00
|
|
|
FREE_AND_NULL(store.value_regex);
|
2011-05-17 23:38:52 +08:00
|
|
|
ret = CONFIG_INVALID_PATTERN;
|
2006-04-17 23:14:48 +08:00
|
|
|
goto out_free;
|
2005-11-18 05:32:36 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
git_config_set: make use of the config parser's event stream
In the recent commit with the title "config: introduce an optional event
stream while parsing", we introduced an optional callback to keep track
of the config parser's events "comment", "white-space", "section header"
and "entry".
One motivation for this feature was to make use of it in the code that
edits the config. And this commit makes it so.
Note: this patch changes the meaning of the `seen` array that records
whether we saw the config entry that is to be edited: previously, it
contained the end offset of the found entry. Now, we introduce a new
array `parsed` that keeps a record of *all* config parser events (with
begin/end offsets), and the items in the `seen` array now point into the
`parsed` array.
There are two reasons why we do it this way:
1. To keep the implementation simple, the config parser's event stream
reports the event only after the config callback was called, so we
would not receive the begin offset otherwise.
2. In the following patches, we will re-use the `parsed` array to fix two
long-standing bugs related to empty sections.
Note that this also makes the code more robust with respect to finding the
begin offset of the part(s) of the config file to be edited, as we no
longer back-track to find the beginning of the line.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 16:32:20 +08:00
|
|
|
ALLOC_GROW(store.parsed, 1, store.parsed_alloc);
|
|
|
|
|
store.parsed[0].end = 0;
|
|
|
|
|
|
|
|
|
|
memset(&opts, 0, sizeof(opts));
|
|
|
|
|
opts.event_fn = store_aux_event;
|
|
|
|
|
opts.event_fn_data = &store;
|
2005-11-18 05:32:36 +08:00
|
|
|
|
|
|
|
|
/*
|
git_config_set: make use of the config parser's event stream
In the recent commit with the title "config: introduce an optional event
stream while parsing", we introduced an optional callback to keep track
of the config parser's events "comment", "white-space", "section header"
and "entry".
One motivation for this feature was to make use of it in the code that
edits the config. And this commit makes it so.
Note: this patch changes the meaning of the `seen` array that records
whether we saw the config entry that is to be edited: previously, it
contained the end offset of the found entry. Now, we introduce a new
array `parsed` that keeps a record of *all* config parser events (with
begin/end offsets), and the items in the `seen` array now point into the
`parsed` array.
There are two reasons why we do it this way:
1. To keep the implementation simple, the config parser's event stream
reports the event only after the config callback was called, so we
would not receive the begin offset otherwise.
2. In the following patches, we will re-use the `parsed` array to fix two
long-standing bugs related to empty sections.
Note that this also makes the code more robust with respect to finding the
begin offset of the part(s) of the config file to be edited, as we no
longer back-track to find the beginning of the line.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 16:32:20 +08:00
|
|
|
* After this, store.parsed will contain offsets of all the
|
|
|
|
|
* parsed elements, and store.seen will contain a list of
|
|
|
|
|
* matches, as indices into store.parsed.
|
|
|
|
|
*
|
2005-11-18 05:32:36 +08:00
|
|
|
* As a side effect, we make sure to transform only a valid
|
|
|
|
|
* existing config file.
|
|
|
|
|
*/
|
git_config_set: make use of the config parser's event stream
In the recent commit with the title "config: introduce an optional event
stream while parsing", we introduced an optional callback to keep track
of the config parser's events "comment", "white-space", "section header"
and "entry".
One motivation for this feature was to make use of it in the code that
edits the config. And this commit makes it so.
Note: this patch changes the meaning of the `seen` array that records
whether we saw the config entry that is to be edited: previously, it
contained the end offset of the found entry. Now, we introduce a new
array `parsed` that keeps a record of *all* config parser events (with
begin/end offsets), and the items in the `seen` array now point into the
`parsed` array.
There are two reasons why we do it this way:
1. To keep the implementation simple, the config parser's event stream
reports the event only after the config callback was called, so we
would not receive the begin offset otherwise.
2. In the following patches, we will re-use the `parsed` array to fix two
long-standing bugs related to empty sections.
Note that this also makes the code more robust with respect to finding the
begin offset of the part(s) of the config file to be edited, as we no
longer back-track to find the beginning of the line.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 16:32:20 +08:00
|
|
|
if (git_config_from_file_with_options(store_aux,
|
|
|
|
|
config_filename,
|
|
|
|
|
&store, &opts)) {
|
2018-07-21 15:49:27 +08:00
|
|
|
error(_("invalid config file %s"), config_filename);
|
2011-05-17 23:38:52 +08:00
|
|
|
ret = CONFIG_INVALID_FILE;
|
2006-04-17 23:14:48 +08:00
|
|
|
goto out_free;
|
2005-11-18 05:32:36 +08:00
|
|
|
}
|
|
|
|
|
|
2005-11-20 13:52:22 +08:00
|
|
|
/* if nothing to unset, or too many matches, error out */
|
2018-04-09 16:32:13 +08:00
|
|
|
if ((store.seen_nr == 0 && value == NULL) ||
|
|
|
|
|
(store.seen_nr > 1 && multi_replace == 0)) {
|
2011-05-17 23:38:52 +08:00
|
|
|
ret = CONFIG_NOTHING_SET;
|
2006-04-17 23:14:48 +08:00
|
|
|
goto out_free;
|
2005-11-18 05:32:36 +08:00
|
|
|
}
|
|
|
|
|
|
2016-12-19 17:21:55 +08:00
|
|
|
if (fstat(in_fd, &st) == -1) {
|
|
|
|
|
error_errno(_("fstat on %s failed"), config_filename);
|
|
|
|
|
ret = CONFIG_INVALID_FILE;
|
|
|
|
|
goto out_free;
|
|
|
|
|
}
|
|
|
|
|
|
2007-03-07 09:44:37 +08:00
|
|
|
contents_sz = xsize_t(st.st_size);
|
2015-05-28 15:56:15 +08:00
|
|
|
contents = xmmap_gently(NULL, contents_sz, PROT_READ,
|
|
|
|
|
MAP_PRIVATE, in_fd, 0);
|
|
|
|
|
if (contents == MAP_FAILED) {
|
2015-05-28 16:03:01 +08:00
|
|
|
if (errno == ENODEV && S_ISDIR(st.st_mode))
|
|
|
|
|
errno = EISDIR;
|
2018-07-21 15:49:27 +08:00
|
|
|
error_errno(_("unable to mmap '%s'"), config_filename);
|
2015-05-28 15:56:15 +08:00
|
|
|
ret = CONFIG_INVALID_FILE;
|
|
|
|
|
contents = NULL;
|
|
|
|
|
goto out_free;
|
|
|
|
|
}
|
2005-11-18 05:32:36 +08:00
|
|
|
close(in_fd);
|
2015-08-15 04:21:17 +08:00
|
|
|
in_fd = -1;
|
2005-11-18 05:32:36 +08:00
|
|
|
|
2017-09-05 20:15:21 +08:00
|
|
|
if (chmod(get_lock_file_path(&lock), st.st_mode & 07777) < 0) {
|
2018-07-21 15:49:27 +08:00
|
|
|
error_errno(_("chmod on %s failed"), get_lock_file_path(&lock));
|
2014-05-06 08:17:14 +08:00
|
|
|
ret = CONFIG_NO_WRITE;
|
|
|
|
|
goto out_free;
|
|
|
|
|
}
|
|
|
|
|
|
git_config_set: make use of the config parser's event stream
In the recent commit with the title "config: introduce an optional event
stream while parsing", we introduced an optional callback to keep track
of the config parser's events "comment", "white-space", "section header"
and "entry".
One motivation for this feature was to make use of it in the code that
edits the config. And this commit makes it so.
Note: this patch changes the meaning of the `seen` array that records
whether we saw the config entry that is to be edited: previously, it
contained the end offset of the found entry. Now, we introduce a new
array `parsed` that keeps a record of *all* config parser events (with
begin/end offsets), and the items in the `seen` array now point into the
`parsed` array.
There are two reasons why we do it this way:
1. To keep the implementation simple, the config parser's event stream
reports the event only after the config callback was called, so we
would not receive the begin offset otherwise.
2. In the following patches, we will re-use the `parsed` array to fix two
long-standing bugs related to empty sections.
Note that this also makes the code more robust with respect to finding the
begin offset of the part(s) of the config file to be edited, as we no
longer back-track to find the beginning of the line.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 16:32:20 +08:00
|
|
|
if (store.seen_nr == 0) {
|
|
|
|
|
if (!store.seen_alloc) {
|
|
|
|
|
/* Did not see key nor section */
|
|
|
|
|
ALLOC_GROW(store.seen, 1, store.seen_alloc);
|
|
|
|
|
store.seen[0] = store.parsed_nr
|
|
|
|
|
- !!store.parsed_nr;
|
|
|
|
|
}
|
2018-04-09 16:32:13 +08:00
|
|
|
store.seen_nr = 1;
|
git_config_set: make use of the config parser's event stream
In the recent commit with the title "config: introduce an optional event
stream while parsing", we introduced an optional callback to keep track
of the config parser's events "comment", "white-space", "section header"
and "entry".
One motivation for this feature was to make use of it in the code that
edits the config. And this commit makes it so.
Note: this patch changes the meaning of the `seen` array that records
whether we saw the config entry that is to be edited: previously, it
contained the end offset of the found entry. Now, we introduce a new
array `parsed` that keeps a record of *all* config parser events (with
begin/end offsets), and the items in the `seen` array now point into the
`parsed` array.
There are two reasons why we do it this way:
1. To keep the implementation simple, the config parser's event stream
reports the event only after the config callback was called, so we
would not receive the begin offset otherwise.
2. In the following patches, we will re-use the `parsed` array to fix two
long-standing bugs related to empty sections.
Note that this also makes the code more robust with respect to finding the
begin offset of the part(s) of the config file to be edited, as we no
longer back-track to find the beginning of the line.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 16:32:20 +08:00
|
|
|
}
|
2005-11-20 13:52:22 +08:00
|
|
|
|
2018-04-09 16:32:13 +08:00
|
|
|
for (i = 0, copy_begin = 0; i < store.seen_nr; i++) {
|
git_config_set: make use of the config parser's event stream
In the recent commit with the title "config: introduce an optional event
stream while parsing", we introduced an optional callback to keep track
of the config parser's events "comment", "white-space", "section header"
and "entry".
One motivation for this feature was to make use of it in the code that
edits the config. And this commit makes it so.
Note: this patch changes the meaning of the `seen` array that records
whether we saw the config entry that is to be edited: previously, it
contained the end offset of the found entry. Now, we introduce a new
array `parsed` that keeps a record of *all* config parser events (with
begin/end offsets), and the items in the `seen` array now point into the
`parsed` array.
There are two reasons why we do it this way:
1. To keep the implementation simple, the config parser's event stream
reports the event only after the config callback was called, so we
would not receive the begin offset otherwise.
2. In the following patches, we will re-use the `parsed` array to fix two
long-standing bugs related to empty sections.
Note that this also makes the code more robust with respect to finding the
begin offset of the part(s) of the config file to be edited, as we no
longer back-track to find the beginning of the line.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 16:32:20 +08:00
|
|
|
size_t replace_end;
|
|
|
|
|
int j = store.seen[i];
|
|
|
|
|
|
2018-04-04 00:28:14 +08:00
|
|
|
new_line = 0;
|
git_config_set: make use of the config parser's event stream
In the recent commit with the title "config: introduce an optional event
stream while parsing", we introduced an optional callback to keep track
of the config parser's events "comment", "white-space", "section header"
and "entry".
One motivation for this feature was to make use of it in the code that
edits the config. And this commit makes it so.
Note: this patch changes the meaning of the `seen` array that records
whether we saw the config entry that is to be edited: previously, it
contained the end offset of the found entry. Now, we introduce a new
array `parsed` that keeps a record of *all* config parser events (with
begin/end offsets), and the items in the `seen` array now point into the
`parsed` array.
There are two reasons why we do it this way:
1. To keep the implementation simple, the config parser's event stream
reports the event only after the config callback was called, so we
would not receive the begin offset otherwise.
2. In the following patches, we will re-use the `parsed` array to fix two
long-standing bugs related to empty sections.
Note that this also makes the code more robust with respect to finding the
begin offset of the part(s) of the config file to be edited, as we no
longer back-track to find the beginning of the line.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 16:32:20 +08:00
|
|
|
if (!store.key_seen) {
|
2018-04-09 16:32:29 +08:00
|
|
|
copy_end = store.parsed[j].end;
|
|
|
|
|
/* include '\n' when copying section header */
|
|
|
|
|
if (copy_end > 0 && copy_end < contents_sz &&
|
|
|
|
|
contents[copy_end - 1] != '\n' &&
|
|
|
|
|
contents[copy_end] == '\n')
|
|
|
|
|
copy_end++;
|
|
|
|
|
replace_end = copy_end;
|
git_config_set: make use of the config parser's event stream
In the recent commit with the title "config: introduce an optional event
stream while parsing", we introduced an optional callback to keep track
of the config parser's events "comment", "white-space", "section header"
and "entry".
One motivation for this feature was to make use of it in the code that
edits the config. And this commit makes it so.
Note: this patch changes the meaning of the `seen` array that records
whether we saw the config entry that is to be edited: previously, it
contained the end offset of the found entry. Now, we introduce a new
array `parsed` that keeps a record of *all* config parser events (with
begin/end offsets), and the items in the `seen` array now point into the
`parsed` array.
There are two reasons why we do it this way:
1. To keep the implementation simple, the config parser's event stream
reports the event only after the config callback was called, so we
would not receive the begin offset otherwise.
2. In the following patches, we will re-use the `parsed` array to fix two
long-standing bugs related to empty sections.
Note that this also makes the code more robust with respect to finding the
begin offset of the part(s) of the config file to be edited, as we no
longer back-track to find the beginning of the line.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 16:32:20 +08:00
|
|
|
} else {
|
|
|
|
|
replace_end = store.parsed[j].end;
|
|
|
|
|
copy_end = store.parsed[j].begin;
|
git config --unset: remove empty sections (in the common case)
The original reasoning for not removing section headers upon removal of
the last entry went like this: the user could have added comments about
the section, or about the entries therein, and if there were other
comments there, we would not know whether we should remove them.
In particular, a concocted example was presented that looked like this
(and was added to t1300):
# some generic comment on the configuration file itself
# a comment specific to this "section" section.
[section]
# some intervening lines
# that should also be dropped
key = value
# please be careful when you update the above variable
The ideal thing for `git config --unset section.key` in this case would
be to leave only the first line behind, because all the other comments
are now obsolete.
However, this is unfeasible, short of adding a complete Natural Language
Processing module to Git, which seems not only a lot of work, but a
totally unreasonable feature (for little benefit to most users).
Now, the real kicker about this problem is: most users do not edit their
config files at all! In their use case, the config looks like this
instead:
[section]
key = value
... and it is totally obvious what should happen if the entry is
removed: the entire section should vanish.
Let's generalize this observation to this conservative strategy: if we
are removing the last entry from a section, and there are no comments
inside that section nor surrounding it, then remove the entire section.
Otherwise behave as before: leave the now-empty section (including those
comments, even ones about the now-deleted entry).
We have to be extra careful to handle the case where more than one entry
is removed: any subset of them might be the last entries of their
respective sections (and if there are no comments in or around that
section, the section should be removed, too).
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 16:32:24 +08:00
|
|
|
if (!value)
|
2019-01-24 21:12:32 +08:00
|
|
|
maybe_remove_section(&store,
|
git config --unset: remove empty sections (in the common case)
The original reasoning for not removing section headers upon removal of
the last entry went like this: the user could have added comments about
the section, or about the entries therein, and if there were other
comments there, we would not know whether we should remove them.
In particular, a concocted example was presented that looked like this
(and was added to t1300):
# some generic comment on the configuration file itself
# a comment specific to this "section" section.
[section]
# some intervening lines
# that should also be dropped
key = value
# please be careful when you update the above variable
The ideal thing for `git config --unset section.key` in this case would
be to leave only the first line behind, because all the other comments
are now obsolete.
However, this is unfeasible, short of adding a complete Natural Language
Processing module to Git, which seems not only a lot of work, but a
totally unreasonable feature (for little benefit to most users).
Now, the real kicker about this problem is: most users do not edit their
config files at all! In their use case, the config looks like this
instead:
[section]
key = value
... and it is totally obvious what should happen if the entry is
removed: the entire section should vanish.
Let's generalize this observation to this conservative strategy: if we
are removing the last entry from a section, and there are no comments
inside that section nor surrounding it, then remove the entire section.
Otherwise behave as before: leave the now-empty section (including those
comments, even ones about the now-deleted entry).
We have to be extra careful to handle the case where more than one entry
is removed: any subset of them might be the last entries of their
respective sections (and if there are no comments in or around that
section, the section should be removed, too).
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 16:32:24 +08:00
|
|
|
©_end,
|
|
|
|
|
&replace_end, &i);
|
git_config_set: make use of the config parser's event stream
In the recent commit with the title "config: introduce an optional event
stream while parsing", we introduced an optional callback to keep track
of the config parser's events "comment", "white-space", "section header"
and "entry".
One motivation for this feature was to make use of it in the code that
edits the config. And this commit makes it so.
Note: this patch changes the meaning of the `seen` array that records
whether we saw the config entry that is to be edited: previously, it
contained the end offset of the found entry. Now, we introduce a new
array `parsed` that keeps a record of *all* config parser events (with
begin/end offsets), and the items in the `seen` array now point into the
`parsed` array.
There are two reasons why we do it this way:
1. To keep the implementation simple, the config parser's event stream
reports the event only after the config callback was called, so we
would not receive the begin offset otherwise.
2. In the following patches, we will re-use the `parsed` array to fix two
long-standing bugs related to empty sections.
Note that this also makes the code more robust with respect to finding the
begin offset of the part(s) of the config file to be edited, as we no
longer back-track to find the beginning of the line.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 16:32:20 +08:00
|
|
|
/*
|
|
|
|
|
* Swallow preceding white-space on the same
|
|
|
|
|
* line.
|
|
|
|
|
*/
|
|
|
|
|
while (copy_end > 0 ) {
|
|
|
|
|
char c = contents[copy_end - 1];
|
|
|
|
|
|
|
|
|
|
if (isspace(c) && c != '\n')
|
|
|
|
|
copy_end--;
|
|
|
|
|
else
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
2005-11-20 13:52:22 +08:00
|
|
|
|
2008-01-01 14:17:34 +08:00
|
|
|
if (copy_end > 0 && contents[copy_end-1] != '\n')
|
|
|
|
|
new_line = 1;
|
|
|
|
|
|
2005-11-20 13:52:22 +08:00
|
|
|
/* write the first part of the config */
|
|
|
|
|
if (copy_end > copy_begin) {
|
2007-01-12 05:16:26 +08:00
|
|
|
if (write_in_full(fd, contents + copy_begin,
|
config: avoid "write_in_full(fd, buf, len) < len" pattern
The return type of write_in_full() is a signed ssize_t,
because we may return "-1" on failure (even if we succeeded
in writing some bytes). But "len" itself is may be an
unsigned type (the function takes a size_t, but of course we
may have something else in the calling function). So while
it seems like:
if (write_in_full(fd, buf, len) < len)
die_errno("write error");
would trigger on error, it won't if "len" is unsigned. The
compiler sees a signed/unsigned comparison and promotes the
signed value, resulting in (size_t)-1, the highest possible
size_t (or again, whatever type the caller has). This cannot
possibly be smaller than "len", and so the conditional can
never trigger.
I scoured the code base for cases of this, but it turns out
that these two in git_config_set_multivar_in_file_gently()
are the only ones. Here our "len" is the difference between
two size_t variables, making the result an unsigned size_t.
We can fix this by just checking for a negative return value
directly, as write_in_full() will never return any value
except -1 or the full count.
There's no addition to the test suite here, since you need
to convince write() to fail in order to see the problem. The
simplest reproduction recipe I came up with is to trigger
ENOSPC:
# make a limited-size filesystem
dd if=/dev/zero of=small.disk bs=1M count=1
mke2fs small.disk
mkdir mnt
sudo mount -o loop small.disk mnt
cd mnt
sudo chown $USER:$USER .
# make a config file with some content
git config --file=config one.key value
git config --file=config two.key value
# now fill up the disk
dd if=/dev/zero of=fill
# and try to delete a key, which requires copying the rest
# of the file to config.lock, and will fail on write()
git config --file=config --unset two.key
That final command should (and does after this patch)
produce an error message due to the failed write, and leave
the file intact. Instead, it silently ignores the failure
and renames config.lock into place, leaving you with a
totally empty config file!
Reported-by: demerphq <demerphq@gmail.com>
Signed-off-by: Jeff King <peff@peff.net>
Reviewed-by: Jonathan Nieder <jrnieder@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-14 02:15:16 +08:00
|
|
|
copy_end - copy_begin) < 0)
|
2007-01-12 05:16:26 +08:00
|
|
|
goto write_err_out;
|
|
|
|
|
if (new_line &&
|
avoid "write_in_full(fd, buf, len) != len" pattern
The return value of write_in_full() is either "-1", or the
requested number of bytes[1]. If we make a partial write
before seeing an error, we still return -1, not a partial
value. This goes back to f6aa66cb95 (write_in_full: really
write in full or return error on disk full., 2007-01-11).
So checking anything except "was the return value negative"
is pointless. And there are a couple of reasons not to do
so:
1. It can do a funny signed/unsigned comparison. If your
"len" is signed (e.g., a size_t) then the compiler will
promote the "-1" to its unsigned variant.
This works out for "!= len" (unless you really were
trying to write the maximum size_t bytes), but is a
bug if you check "< len" (an example of which was fixed
recently in config.c).
We should avoid promoting the mental model that you
need to check the length at all, so that new sites are
not tempted to copy us.
2. Checking for a negative value is shorter to type,
especially when the length is an expression.
3. Linus says so. In d34cf19b89 (Clean up write_in_full()
users, 2007-01-11), right after the write_in_full()
semantics were changed, he wrote:
I really wish every "write_in_full()" user would just
check against "<0" now, but this fixes the nasty and
stupid ones.
Appeals to authority aside, this makes it clear that
writing it this way does not have an intentional
benefit. It's a historical curiosity that we never
bothered to clean up (and which was undoubtedly
cargo-culted into new sites).
So let's convert these obviously-correct cases (this
includes write_str_in_full(), which is just a wrapper for
write_in_full()).
[1] A careful reader may notice there is one way that
write_in_full() can return a different value. If we ask
write() to write N bytes and get a return value that is
_larger_ than N, we could return a larger total. But
besides the fact that this would imply a totally broken
version of write(), it would already invoke undefined
behavior. Our internal remaining counter is an unsigned
size_t, which means that subtracting too many byte will
wrap it around to a very large number. So we'll instantly
begin reading off the end of the buffer, trying to write
gigabytes (or petabytes) of data.
Signed-off-by: Jeff King <peff@peff.net>
Reviewed-by: Jonathan Nieder <jrnieder@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-14 01:16:03 +08:00
|
|
|
write_str_in_full(fd, "\n") < 0)
|
2007-01-12 05:16:26 +08:00
|
|
|
goto write_err_out;
|
2005-11-20 13:52:22 +08:00
|
|
|
}
|
git_config_set: make use of the config parser's event stream
In the recent commit with the title "config: introduce an optional event
stream while parsing", we introduced an optional callback to keep track
of the config parser's events "comment", "white-space", "section header"
and "entry".
One motivation for this feature was to make use of it in the code that
edits the config. And this commit makes it so.
Note: this patch changes the meaning of the `seen` array that records
whether we saw the config entry that is to be edited: previously, it
contained the end offset of the found entry. Now, we introduce a new
array `parsed` that keeps a record of *all* config parser events (with
begin/end offsets), and the items in the `seen` array now point into the
`parsed` array.
There are two reasons why we do it this way:
1. To keep the implementation simple, the config parser's event stream
reports the event only after the config callback was called, so we
would not receive the begin offset otherwise.
2. In the following patches, we will re-use the `parsed` array to fix two
long-standing bugs related to empty sections.
Note that this also makes the code more robust with respect to finding the
begin offset of the part(s) of the config file to be edited, as we no
longer back-track to find the beginning of the line.
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-04-09 16:32:20 +08:00
|
|
|
copy_begin = replace_end;
|
2005-11-18 05:32:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* write the pair (value == NULL means unset) */
|
|
|
|
|
if (value != NULL) {
|
2018-04-09 16:32:17 +08:00
|
|
|
if (!store.section_seen) {
|
2018-04-09 16:32:09 +08:00
|
|
|
if (write_section(fd, key, &store) < 0)
|
2007-01-12 05:16:26 +08:00
|
|
|
goto write_err_out;
|
2007-01-08 23:58:38 +08:00
|
|
|
}
|
2018-04-09 16:32:09 +08:00
|
|
|
if (write_pair(fd, key, value, &store) < 0)
|
2007-01-12 05:16:26 +08:00
|
|
|
goto write_err_out;
|
2005-11-18 05:32:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* write the rest of the config */
|
2007-03-07 09:44:37 +08:00
|
|
|
if (copy_begin < contents_sz)
|
2007-01-12 05:16:26 +08:00
|
|
|
if (write_in_full(fd, contents + copy_begin,
|
config: avoid "write_in_full(fd, buf, len) < len" pattern
The return type of write_in_full() is a signed ssize_t,
because we may return "-1" on failure (even if we succeeded
in writing some bytes). But "len" itself is may be an
unsigned type (the function takes a size_t, but of course we
may have something else in the calling function). So while
it seems like:
if (write_in_full(fd, buf, len) < len)
die_errno("write error");
would trigger on error, it won't if "len" is unsigned. The
compiler sees a signed/unsigned comparison and promotes the
signed value, resulting in (size_t)-1, the highest possible
size_t (or again, whatever type the caller has). This cannot
possibly be smaller than "len", and so the conditional can
never trigger.
I scoured the code base for cases of this, but it turns out
that these two in git_config_set_multivar_in_file_gently()
are the only ones. Here our "len" is the difference between
two size_t variables, making the result an unsigned size_t.
We can fix this by just checking for a negative return value
directly, as write_in_full() will never return any value
except -1 or the full count.
There's no addition to the test suite here, since you need
to convince write() to fail in order to see the problem. The
simplest reproduction recipe I came up with is to trigger
ENOSPC:
# make a limited-size filesystem
dd if=/dev/zero of=small.disk bs=1M count=1
mke2fs small.disk
mkdir mnt
sudo mount -o loop small.disk mnt
cd mnt
sudo chown $USER:$USER .
# make a config file with some content
git config --file=config one.key value
git config --file=config two.key value
# now fill up the disk
dd if=/dev/zero of=fill
# and try to delete a key, which requires copying the rest
# of the file to config.lock, and will fail on write()
git config --file=config --unset two.key
That final command should (and does after this patch)
produce an error message due to the failed write, and leave
the file intact. Instead, it silently ignores the failure
and renames config.lock into place, leaving you with a
totally empty config file!
Reported-by: demerphq <demerphq@gmail.com>
Signed-off-by: Jeff King <peff@peff.net>
Reviewed-by: Jonathan Nieder <jrnieder@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-14 02:15:16 +08:00
|
|
|
contents_sz - copy_begin) < 0)
|
2007-01-12 05:16:26 +08:00
|
|
|
goto write_err_out;
|
2015-06-30 22:34:13 +08:00
|
|
|
|
|
|
|
|
munmap(contents, contents_sz);
|
|
|
|
|
contents = NULL;
|
2005-11-18 05:32:36 +08:00
|
|
|
}
|
|
|
|
|
|
2017-09-05 20:15:21 +08:00
|
|
|
if (commit_lock_file(&lock) < 0) {
|
2018-07-21 15:49:27 +08:00
|
|
|
error_errno(_("could not write config file %s"), config_filename);
|
2011-05-17 23:38:52 +08:00
|
|
|
ret = CONFIG_NO_WRITE;
|
2006-04-17 23:14:48 +08:00
|
|
|
goto out_free;
|
2005-11-18 05:32:36 +08:00
|
|
|
}
|
|
|
|
|
|
2006-04-17 23:14:48 +08:00
|
|
|
ret = 0;
|
|
|
|
|
|
2014-07-28 18:10:38 +08:00
|
|
|
/* Invalidate the config cache */
|
|
|
|
|
git_config_clear();
|
|
|
|
|
|
2006-04-17 23:14:48 +08:00
|
|
|
out_free:
|
2017-09-05 20:15:21 +08:00
|
|
|
rollback_lock_file(&lock);
|
2012-02-16 16:04:05 +08:00
|
|
|
free(filename_buf);
|
2015-05-28 15:54:43 +08:00
|
|
|
if (contents)
|
|
|
|
|
munmap(contents, contents_sz);
|
2015-08-15 04:21:17 +08:00
|
|
|
if (in_fd >= 0)
|
|
|
|
|
close(in_fd);
|
2018-05-20 18:42:33 +08:00
|
|
|
config_store_data_clear(&store);
|
2006-04-17 23:14:48 +08:00
|
|
|
return ret;
|
2007-01-12 05:16:26 +08:00
|
|
|
|
|
|
|
|
write_err_out:
|
2017-09-05 20:15:21 +08:00
|
|
|
ret = write_error(get_lock_file_path(&lock));
|
2007-01-12 05:16:26 +08:00
|
|
|
goto out_free;
|
|
|
|
|
|
2005-11-18 05:32:36 +08:00
|
|
|
}
|
|
|
|
|
|
2016-02-22 19:23:36 +08:00
|
|
|
void git_config_set_multivar_in_file(const char *config_filename,
|
|
|
|
|
const char *key, const char *value,
|
|
|
|
|
const char *value_regex, int multi_replace)
|
2016-02-16 20:56:28 +08:00
|
|
|
{
|
2016-04-10 01:43:54 +08:00
|
|
|
if (!git_config_set_multivar_in_file_gently(config_filename, key, value,
|
|
|
|
|
value_regex, multi_replace))
|
|
|
|
|
return;
|
|
|
|
|
if (value)
|
2016-04-10 01:42:31 +08:00
|
|
|
die(_("could not set '%s' to '%s'"), key, value);
|
2016-04-10 01:43:54 +08:00
|
|
|
else
|
|
|
|
|
die(_("could not unset '%s'"), key);
|
2016-02-16 20:56:28 +08:00
|
|
|
}
|
|
|
|
|
|
2016-02-22 19:23:35 +08:00
|
|
|
int git_config_set_multivar_gently(const char *key, const char *value,
|
|
|
|
|
const char *value_regex, int multi_replace)
|
2011-08-04 18:39:00 +08:00
|
|
|
{
|
2016-02-22 19:23:35 +08:00
|
|
|
return git_config_set_multivar_in_file_gently(NULL, key, value, value_regex,
|
|
|
|
|
multi_replace);
|
2011-08-04 18:39:00 +08:00
|
|
|
}
|
|
|
|
|
|
2016-02-22 19:23:36 +08:00
|
|
|
void git_config_set_multivar(const char *key, const char *value,
|
|
|
|
|
const char *value_regex, int multi_replace)
|
2011-08-04 18:39:00 +08:00
|
|
|
{
|
2016-02-22 19:23:36 +08:00
|
|
|
git_config_set_multivar_in_file(NULL, key, value, value_regex,
|
|
|
|
|
multi_replace);
|
2011-08-04 18:39:00 +08:00
|
|
|
}
|
|
|
|
|
|
2007-03-03 04:53:33 +08:00
|
|
|
static int section_name_match (const char *buf, const char *name)
|
|
|
|
|
{
|
|
|
|
|
int i = 0, j = 0, dot = 0;
|
2009-07-25 05:21:43 +08:00
|
|
|
if (buf[i] != '[')
|
|
|
|
|
return 0;
|
|
|
|
|
for (i = 1; buf[i] && buf[i] != ']'; i++) {
|
2007-03-03 04:53:33 +08:00
|
|
|
if (!dot && isspace(buf[i])) {
|
|
|
|
|
dot = 1;
|
|
|
|
|
if (name[j++] != '.')
|
|
|
|
|
break;
|
|
|
|
|
for (i++; isspace(buf[i]); i++)
|
|
|
|
|
; /* do nothing */
|
|
|
|
|
if (buf[i] != '"')
|
|
|
|
|
break;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
if (buf[i] == '\\' && dot)
|
|
|
|
|
i++;
|
|
|
|
|
else if (buf[i] == '"' && dot) {
|
|
|
|
|
for (i++; isspace(buf[i]); i++)
|
|
|
|
|
; /* do_nothing */
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
if (buf[i] != name[j++])
|
|
|
|
|
break;
|
|
|
|
|
}
|
2009-07-25 05:21:43 +08:00
|
|
|
if (buf[i] == ']' && name[j] == 0) {
|
|
|
|
|
/*
|
|
|
|
|
* We match, now just find the right length offset by
|
|
|
|
|
* gobbling up any whitespace after it, as well
|
|
|
|
|
*/
|
|
|
|
|
i++;
|
|
|
|
|
for (; buf[i] && isspace(buf[i]); i++)
|
|
|
|
|
; /* do nothing */
|
|
|
|
|
return i;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
2007-03-03 04:53:33 +08:00
|
|
|
}
|
|
|
|
|
|
2012-04-26 09:47:14 +08:00
|
|
|
static int section_name_is_ok(const char *name)
|
|
|
|
|
{
|
|
|
|
|
/* Empty section names are bogus. */
|
|
|
|
|
if (!*name)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Before a dot, we must be alphanumeric or dash. After the first dot,
|
|
|
|
|
* anything goes, so we can stop checking.
|
|
|
|
|
*/
|
|
|
|
|
for (; *name && *name != '.'; name++)
|
|
|
|
|
if (*name != '-' && !isalnum(*name))
|
|
|
|
|
return 0;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
2007-03-03 04:53:33 +08:00
|
|
|
/* if new_name == NULL, the section is removed instead */
|
branch: add a --copy (-c) option to go with --move (-m)
Add the ability to --copy a branch and its reflog and configuration,
this uses the same underlying machinery as the --move (-m) option
except the reflog and configuration is copied instead of being moved.
This is useful for e.g. copying a topic branch to a new version,
e.g. work to work-2 after submitting the work topic to the list, while
preserving all the tracking info and other configuration that goes
with the branch, and unlike --move keeping the other already-submitted
branch around for reference.
Like --move, when the source branch is the currently checked out
branch the HEAD is moved to the destination branch. In the case of
--move we don't really have a choice (other than remaining on a
detached HEAD) and in order to keep the functionality consistent, we
are doing it in similar way for --copy too.
The most common usage of this feature is expected to be moving to a
new topic branch which is a copy of the current one, in that case
moving to the target branch is what the user wants, and doesn't
unexpectedly behave differently than --move would.
One outstanding caveat of this implementation is that:
git checkout maint &&
git checkout master &&
git branch -c topic &&
git checkout -
Will check out 'maint' instead of 'master'. This is because the @{-N}
feature (or its -1 shorthand "-") relies on HEAD reflogs created by
the checkout command, so in this case we'll checkout maint instead of
master, as the user might expect. What to do about that is left to a
future change.
Helped-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Sahil Dua <sahildua2305@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-06-19 05:19:16 +08:00
|
|
|
static int git_config_copy_or_rename_section_in_file(const char *config_filename,
|
2018-04-09 16:32:09 +08:00
|
|
|
const char *old_name,
|
|
|
|
|
const char *new_name, int copy)
|
2006-12-16 22:14:14 +08:00
|
|
|
{
|
2007-03-03 04:53:33 +08:00
|
|
|
int ret = 0, remove = 0;
|
2012-02-16 16:04:25 +08:00
|
|
|
char *filename_buf = NULL;
|
2017-10-06 04:32:04 +08:00
|
|
|
struct lock_file lock = LOCK_INIT;
|
2006-12-16 22:14:14 +08:00
|
|
|
int out_fd;
|
|
|
|
|
char buf[1024];
|
2017-05-04 21:55:41 +08:00
|
|
|
FILE *config_file = NULL;
|
2014-05-06 08:17:14 +08:00
|
|
|
struct stat st;
|
branch: add a --copy (-c) option to go with --move (-m)
Add the ability to --copy a branch and its reflog and configuration,
this uses the same underlying machinery as the --move (-m) option
except the reflog and configuration is copied instead of being moved.
This is useful for e.g. copying a topic branch to a new version,
e.g. work to work-2 after submitting the work topic to the list, while
preserving all the tracking info and other configuration that goes
with the branch, and unlike --move keeping the other already-submitted
branch around for reference.
Like --move, when the source branch is the currently checked out
branch the HEAD is moved to the destination branch. In the case of
--move we don't really have a choice (other than remaining on a
detached HEAD) and in order to keep the functionality consistent, we
are doing it in similar way for --copy too.
The most common usage of this feature is expected to be moving to a
new topic branch which is a copy of the current one, in that case
moving to the target branch is what the user wants, and doesn't
unexpectedly behave differently than --move would.
One outstanding caveat of this implementation is that:
git checkout maint &&
git checkout master &&
git branch -c topic &&
git checkout -
Will check out 'maint' instead of 'master'. This is because the @{-N}
feature (or its -1 shorthand "-") relies on HEAD reflogs created by
the checkout command, so in this case we'll checkout maint instead of
master, as the user might expect. What to do about that is left to a
future change.
Helped-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Sahil Dua <sahildua2305@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-06-19 05:19:16 +08:00
|
|
|
struct strbuf copystr = STRBUF_INIT;
|
2018-04-09 16:32:09 +08:00
|
|
|
struct config_store_data store;
|
|
|
|
|
|
|
|
|
|
memset(&store, 0, sizeof(store));
|
2006-12-16 22:14:14 +08:00
|
|
|
|
2012-04-26 09:47:14 +08:00
|
|
|
if (new_name && !section_name_is_ok(new_name)) {
|
2018-07-21 15:49:27 +08:00
|
|
|
ret = error(_("invalid section name: %s"), new_name);
|
2016-12-20 17:48:36 +08:00
|
|
|
goto out_no_rollback;
|
2012-04-26 09:47:14 +08:00
|
|
|
}
|
|
|
|
|
|
2012-02-16 16:04:25 +08:00
|
|
|
if (!config_filename)
|
|
|
|
|
config_filename = filename_buf = git_pathdup("config");
|
|
|
|
|
|
2017-10-06 04:32:04 +08:00
|
|
|
out_fd = hold_lock_file_for_update(&lock, config_filename, 0);
|
2006-12-20 13:55:27 +08:00
|
|
|
if (out_fd < 0) {
|
2018-07-21 15:49:27 +08:00
|
|
|
ret = error(_("could not lock config file %s"), config_filename);
|
2006-12-20 13:55:27 +08:00
|
|
|
goto out;
|
|
|
|
|
}
|
2006-12-16 22:14:14 +08:00
|
|
|
|
2006-12-20 13:55:27 +08:00
|
|
|
if (!(config_file = fopen(config_filename, "rb"))) {
|
2017-05-03 18:16:49 +08:00
|
|
|
ret = warn_on_fopen_errors(config_filename);
|
|
|
|
|
if (ret)
|
|
|
|
|
goto out;
|
2007-04-05 22:20:55 +08:00
|
|
|
/* no config file means nothing to rename, no error */
|
2016-12-20 17:48:35 +08:00
|
|
|
goto commit_and_out;
|
2006-12-20 13:55:27 +08:00
|
|
|
}
|
2006-12-16 22:14:14 +08:00
|
|
|
|
2016-12-19 17:21:55 +08:00
|
|
|
if (fstat(fileno(config_file), &st) == -1) {
|
|
|
|
|
ret = error_errno(_("fstat on %s failed"), config_filename);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
2014-05-06 08:17:14 +08:00
|
|
|
|
2017-10-06 04:32:04 +08:00
|
|
|
if (chmod(get_lock_file_path(&lock), st.st_mode & 07777) < 0) {
|
2018-07-21 15:49:27 +08:00
|
|
|
ret = error_errno(_("chmod on %s failed"),
|
2017-10-06 04:32:04 +08:00
|
|
|
get_lock_file_path(&lock));
|
2014-05-06 08:17:14 +08:00
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-16 22:14:14 +08:00
|
|
|
while (fgets(buf, sizeof(buf), config_file)) {
|
|
|
|
|
int i;
|
2007-01-08 23:58:38 +08:00
|
|
|
int length;
|
branch: add a --copy (-c) option to go with --move (-m)
Add the ability to --copy a branch and its reflog and configuration,
this uses the same underlying machinery as the --move (-m) option
except the reflog and configuration is copied instead of being moved.
This is useful for e.g. copying a topic branch to a new version,
e.g. work to work-2 after submitting the work topic to the list, while
preserving all the tracking info and other configuration that goes
with the branch, and unlike --move keeping the other already-submitted
branch around for reference.
Like --move, when the source branch is the currently checked out
branch the HEAD is moved to the destination branch. In the case of
--move we don't really have a choice (other than remaining on a
detached HEAD) and in order to keep the functionality consistent, we
are doing it in similar way for --copy too.
The most common usage of this feature is expected to be moving to a
new topic branch which is a copy of the current one, in that case
moving to the target branch is what the user wants, and doesn't
unexpectedly behave differently than --move would.
One outstanding caveat of this implementation is that:
git checkout maint &&
git checkout master &&
git branch -c topic &&
git checkout -
Will check out 'maint' instead of 'master'. This is because the @{-N}
feature (or its -1 shorthand "-") relies on HEAD reflogs created by
the checkout command, so in this case we'll checkout maint instead of
master, as the user might expect. What to do about that is left to a
future change.
Helped-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Sahil Dua <sahildua2305@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-06-19 05:19:16 +08:00
|
|
|
int is_section = 0;
|
2009-07-25 05:21:44 +08:00
|
|
|
char *output = buf;
|
2006-12-16 22:14:14 +08:00
|
|
|
for (i = 0; buf[i] && isspace(buf[i]); i++)
|
|
|
|
|
; /* do nothing */
|
|
|
|
|
if (buf[i] == '[') {
|
|
|
|
|
/* it's a section */
|
branch: add a --copy (-c) option to go with --move (-m)
Add the ability to --copy a branch and its reflog and configuration,
this uses the same underlying machinery as the --move (-m) option
except the reflog and configuration is copied instead of being moved.
This is useful for e.g. copying a topic branch to a new version,
e.g. work to work-2 after submitting the work topic to the list, while
preserving all the tracking info and other configuration that goes
with the branch, and unlike --move keeping the other already-submitted
branch around for reference.
Like --move, when the source branch is the currently checked out
branch the HEAD is moved to the destination branch. In the case of
--move we don't really have a choice (other than remaining on a
detached HEAD) and in order to keep the functionality consistent, we
are doing it in similar way for --copy too.
The most common usage of this feature is expected to be moving to a
new topic branch which is a copy of the current one, in that case
moving to the target branch is what the user wants, and doesn't
unexpectedly behave differently than --move would.
One outstanding caveat of this implementation is that:
git checkout maint &&
git checkout master &&
git branch -c topic &&
git checkout -
Will check out 'maint' instead of 'master'. This is because the @{-N}
feature (or its -1 shorthand "-") relies on HEAD reflogs created by
the checkout command, so in this case we'll checkout maint instead of
master, as the user might expect. What to do about that is left to a
future change.
Helped-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Sahil Dua <sahildua2305@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-06-19 05:19:16 +08:00
|
|
|
int offset;
|
|
|
|
|
is_section = 1;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* When encountering a new section under -c we
|
|
|
|
|
* need to flush out any section we're already
|
|
|
|
|
* coping and begin anew. There might be
|
|
|
|
|
* multiple [branch "$name"] sections.
|
|
|
|
|
*/
|
|
|
|
|
if (copystr.len > 0) {
|
2017-11-15 20:40:43 +08:00
|
|
|
if (write_in_full(out_fd, copystr.buf, copystr.len) < 0) {
|
2017-11-06 12:11:21 +08:00
|
|
|
ret = write_error(get_lock_file_path(&lock));
|
branch: add a --copy (-c) option to go with --move (-m)
Add the ability to --copy a branch and its reflog and configuration,
this uses the same underlying machinery as the --move (-m) option
except the reflog and configuration is copied instead of being moved.
This is useful for e.g. copying a topic branch to a new version,
e.g. work to work-2 after submitting the work topic to the list, while
preserving all the tracking info and other configuration that goes
with the branch, and unlike --move keeping the other already-submitted
branch around for reference.
Like --move, when the source branch is the currently checked out
branch the HEAD is moved to the destination branch. In the case of
--move we don't really have a choice (other than remaining on a
detached HEAD) and in order to keep the functionality consistent, we
are doing it in similar way for --copy too.
The most common usage of this feature is expected to be moving to a
new topic branch which is a copy of the current one, in that case
moving to the target branch is what the user wants, and doesn't
unexpectedly behave differently than --move would.
One outstanding caveat of this implementation is that:
git checkout maint &&
git checkout master &&
git branch -c topic &&
git checkout -
Will check out 'maint' instead of 'master'. This is because the @{-N}
feature (or its -1 shorthand "-") relies on HEAD reflogs created by
the checkout command, so in this case we'll checkout maint instead of
master, as the user might expect. What to do about that is left to a
future change.
Helped-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Sahil Dua <sahildua2305@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-06-19 05:19:16 +08:00
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
strbuf_reset(©str);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
offset = section_name_match(&buf[i], old_name);
|
2009-07-25 05:21:43 +08:00
|
|
|
if (offset > 0) {
|
2007-03-03 04:53:33 +08:00
|
|
|
ret++;
|
|
|
|
|
if (new_name == NULL) {
|
|
|
|
|
remove = 1;
|
2006-12-16 22:14:14 +08:00
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
store.baselen = strlen(new_name);
|
branch: add a --copy (-c) option to go with --move (-m)
Add the ability to --copy a branch and its reflog and configuration,
this uses the same underlying machinery as the --move (-m) option
except the reflog and configuration is copied instead of being moved.
This is useful for e.g. copying a topic branch to a new version,
e.g. work to work-2 after submitting the work topic to the list, while
preserving all the tracking info and other configuration that goes
with the branch, and unlike --move keeping the other already-submitted
branch around for reference.
Like --move, when the source branch is the currently checked out
branch the HEAD is moved to the destination branch. In the case of
--move we don't really have a choice (other than remaining on a
detached HEAD) and in order to keep the functionality consistent, we
are doing it in similar way for --copy too.
The most common usage of this feature is expected to be moving to a
new topic branch which is a copy of the current one, in that case
moving to the target branch is what the user wants, and doesn't
unexpectedly behave differently than --move would.
One outstanding caveat of this implementation is that:
git checkout maint &&
git checkout master &&
git branch -c topic &&
git checkout -
Will check out 'maint' instead of 'master'. This is because the @{-N}
feature (or its -1 shorthand "-") relies on HEAD reflogs created by
the checkout command, so in this case we'll checkout maint instead of
master, as the user might expect. What to do about that is left to a
future change.
Helped-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Sahil Dua <sahildua2305@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-06-19 05:19:16 +08:00
|
|
|
if (!copy) {
|
2018-04-09 16:32:09 +08:00
|
|
|
if (write_section(out_fd, new_name, &store) < 0) {
|
2017-11-06 12:11:21 +08:00
|
|
|
ret = write_error(get_lock_file_path(&lock));
|
branch: add a --copy (-c) option to go with --move (-m)
Add the ability to --copy a branch and its reflog and configuration,
this uses the same underlying machinery as the --move (-m) option
except the reflog and configuration is copied instead of being moved.
This is useful for e.g. copying a topic branch to a new version,
e.g. work to work-2 after submitting the work topic to the list, while
preserving all the tracking info and other configuration that goes
with the branch, and unlike --move keeping the other already-submitted
branch around for reference.
Like --move, when the source branch is the currently checked out
branch the HEAD is moved to the destination branch. In the case of
--move we don't really have a choice (other than remaining on a
detached HEAD) and in order to keep the functionality consistent, we
are doing it in similar way for --copy too.
The most common usage of this feature is expected to be moving to a
new topic branch which is a copy of the current one, in that case
moving to the target branch is what the user wants, and doesn't
unexpectedly behave differently than --move would.
One outstanding caveat of this implementation is that:
git checkout maint &&
git checkout master &&
git branch -c topic &&
git checkout -
Will check out 'maint' instead of 'master'. This is because the @{-N}
feature (or its -1 shorthand "-") relies on HEAD reflogs created by
the checkout command, so in this case we'll checkout maint instead of
master, as the user might expect. What to do about that is left to a
future change.
Helped-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Sahil Dua <sahildua2305@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-06-19 05:19:16 +08:00
|
|
|
goto out;
|
|
|
|
|
}
|
2009-07-25 05:21:44 +08:00
|
|
|
/*
|
branch: add a --copy (-c) option to go with --move (-m)
Add the ability to --copy a branch and its reflog and configuration,
this uses the same underlying machinery as the --move (-m) option
except the reflog and configuration is copied instead of being moved.
This is useful for e.g. copying a topic branch to a new version,
e.g. work to work-2 after submitting the work topic to the list, while
preserving all the tracking info and other configuration that goes
with the branch, and unlike --move keeping the other already-submitted
branch around for reference.
Like --move, when the source branch is the currently checked out
branch the HEAD is moved to the destination branch. In the case of
--move we don't really have a choice (other than remaining on a
detached HEAD) and in order to keep the functionality consistent, we
are doing it in similar way for --copy too.
The most common usage of this feature is expected to be moving to a
new topic branch which is a copy of the current one, in that case
moving to the target branch is what the user wants, and doesn't
unexpectedly behave differently than --move would.
One outstanding caveat of this implementation is that:
git checkout maint &&
git checkout master &&
git branch -c topic &&
git checkout -
Will check out 'maint' instead of 'master'. This is because the @{-N}
feature (or its -1 shorthand "-") relies on HEAD reflogs created by
the checkout command, so in this case we'll checkout maint instead of
master, as the user might expect. What to do about that is left to a
future change.
Helped-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Sahil Dua <sahildua2305@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-06-19 05:19:16 +08:00
|
|
|
* We wrote out the new section, with
|
|
|
|
|
* a newline, now skip the old
|
|
|
|
|
* section's length
|
2009-07-25 05:21:44 +08:00
|
|
|
*/
|
branch: add a --copy (-c) option to go with --move (-m)
Add the ability to --copy a branch and its reflog and configuration,
this uses the same underlying machinery as the --move (-m) option
except the reflog and configuration is copied instead of being moved.
This is useful for e.g. copying a topic branch to a new version,
e.g. work to work-2 after submitting the work topic to the list, while
preserving all the tracking info and other configuration that goes
with the branch, and unlike --move keeping the other already-submitted
branch around for reference.
Like --move, when the source branch is the currently checked out
branch the HEAD is moved to the destination branch. In the case of
--move we don't really have a choice (other than remaining on a
detached HEAD) and in order to keep the functionality consistent, we
are doing it in similar way for --copy too.
The most common usage of this feature is expected to be moving to a
new topic branch which is a copy of the current one, in that case
moving to the target branch is what the user wants, and doesn't
unexpectedly behave differently than --move would.
One outstanding caveat of this implementation is that:
git checkout maint &&
git checkout master &&
git branch -c topic &&
git checkout -
Will check out 'maint' instead of 'master'. This is because the @{-N}
feature (or its -1 shorthand "-") relies on HEAD reflogs created by
the checkout command, so in this case we'll checkout maint instead of
master, as the user might expect. What to do about that is left to a
future change.
Helped-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Sahil Dua <sahildua2305@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-06-19 05:19:16 +08:00
|
|
|
output += offset + i;
|
|
|
|
|
if (strlen(output) > 0) {
|
|
|
|
|
/*
|
|
|
|
|
* More content means there's
|
|
|
|
|
* a declaration to put on the
|
|
|
|
|
* next line; indent with a
|
|
|
|
|
* tab
|
|
|
|
|
*/
|
|
|
|
|
output -= 1;
|
|
|
|
|
output[0] = '\t';
|
|
|
|
|
}
|
|
|
|
|
} else {
|
2018-04-09 16:32:09 +08:00
|
|
|
copystr = store_create_section(new_name, &store);
|
2009-07-25 05:21:44 +08:00
|
|
|
}
|
2006-12-16 22:14:14 +08:00
|
|
|
}
|
2007-03-03 04:53:33 +08:00
|
|
|
remove = 0;
|
2006-12-16 22:14:14 +08:00
|
|
|
}
|
2007-03-03 04:53:33 +08:00
|
|
|
if (remove)
|
|
|
|
|
continue;
|
2009-07-25 05:21:44 +08:00
|
|
|
length = strlen(output);
|
branch: add a --copy (-c) option to go with --move (-m)
Add the ability to --copy a branch and its reflog and configuration,
this uses the same underlying machinery as the --move (-m) option
except the reflog and configuration is copied instead of being moved.
This is useful for e.g. copying a topic branch to a new version,
e.g. work to work-2 after submitting the work topic to the list, while
preserving all the tracking info and other configuration that goes
with the branch, and unlike --move keeping the other already-submitted
branch around for reference.
Like --move, when the source branch is the currently checked out
branch the HEAD is moved to the destination branch. In the case of
--move we don't really have a choice (other than remaining on a
detached HEAD) and in order to keep the functionality consistent, we
are doing it in similar way for --copy too.
The most common usage of this feature is expected to be moving to a
new topic branch which is a copy of the current one, in that case
moving to the target branch is what the user wants, and doesn't
unexpectedly behave differently than --move would.
One outstanding caveat of this implementation is that:
git checkout maint &&
git checkout master &&
git branch -c topic &&
git checkout -
Will check out 'maint' instead of 'master'. This is because the @{-N}
feature (or its -1 shorthand "-") relies on HEAD reflogs created by
the checkout command, so in this case we'll checkout maint instead of
master, as the user might expect. What to do about that is left to a
future change.
Helped-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Sahil Dua <sahildua2305@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-06-19 05:19:16 +08:00
|
|
|
|
|
|
|
|
if (!is_section && copystr.len > 0) {
|
|
|
|
|
strbuf_add(©str, output, length);
|
|
|
|
|
}
|
|
|
|
|
|
avoid "write_in_full(fd, buf, len) != len" pattern
The return value of write_in_full() is either "-1", or the
requested number of bytes[1]. If we make a partial write
before seeing an error, we still return -1, not a partial
value. This goes back to f6aa66cb95 (write_in_full: really
write in full or return error on disk full., 2007-01-11).
So checking anything except "was the return value negative"
is pointless. And there are a couple of reasons not to do
so:
1. It can do a funny signed/unsigned comparison. If your
"len" is signed (e.g., a size_t) then the compiler will
promote the "-1" to its unsigned variant.
This works out for "!= len" (unless you really were
trying to write the maximum size_t bytes), but is a
bug if you check "< len" (an example of which was fixed
recently in config.c).
We should avoid promoting the mental model that you
need to check the length at all, so that new sites are
not tempted to copy us.
2. Checking for a negative value is shorter to type,
especially when the length is an expression.
3. Linus says so. In d34cf19b89 (Clean up write_in_full()
users, 2007-01-11), right after the write_in_full()
semantics were changed, he wrote:
I really wish every "write_in_full()" user would just
check against "<0" now, but this fixes the nasty and
stupid ones.
Appeals to authority aside, this makes it clear that
writing it this way does not have an intentional
benefit. It's a historical curiosity that we never
bothered to clean up (and which was undoubtedly
cargo-culted into new sites).
So let's convert these obviously-correct cases (this
includes write_str_in_full(), which is just a wrapper for
write_in_full()).
[1] A careful reader may notice there is one way that
write_in_full() can return a different value. If we ask
write() to write N bytes and get a return value that is
_larger_ than N, we could return a larger total. But
besides the fact that this would imply a totally broken
version of write(), it would already invoke undefined
behavior. Our internal remaining counter is an unsigned
size_t, which means that subtracting too many byte will
wrap it around to a very large number. So we'll instantly
begin reading off the end of the buffer, trying to write
gigabytes (or petabytes) of data.
Signed-off-by: Jeff King <peff@peff.net>
Reviewed-by: Jonathan Nieder <jrnieder@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-09-14 01:16:03 +08:00
|
|
|
if (write_in_full(out_fd, output, length) < 0) {
|
2017-10-06 04:32:04 +08:00
|
|
|
ret = write_error(get_lock_file_path(&lock));
|
2007-01-08 23:58:38 +08:00
|
|
|
goto out;
|
|
|
|
|
}
|
2006-12-16 22:14:14 +08:00
|
|
|
}
|
branch: add a --copy (-c) option to go with --move (-m)
Add the ability to --copy a branch and its reflog and configuration,
this uses the same underlying machinery as the --move (-m) option
except the reflog and configuration is copied instead of being moved.
This is useful for e.g. copying a topic branch to a new version,
e.g. work to work-2 after submitting the work topic to the list, while
preserving all the tracking info and other configuration that goes
with the branch, and unlike --move keeping the other already-submitted
branch around for reference.
Like --move, when the source branch is the currently checked out
branch the HEAD is moved to the destination branch. In the case of
--move we don't really have a choice (other than remaining on a
detached HEAD) and in order to keep the functionality consistent, we
are doing it in similar way for --copy too.
The most common usage of this feature is expected to be moving to a
new topic branch which is a copy of the current one, in that case
moving to the target branch is what the user wants, and doesn't
unexpectedly behave differently than --move would.
One outstanding caveat of this implementation is that:
git checkout maint &&
git checkout master &&
git branch -c topic &&
git checkout -
Will check out 'maint' instead of 'master'. This is because the @{-N}
feature (or its -1 shorthand "-") relies on HEAD reflogs created by
the checkout command, so in this case we'll checkout maint instead of
master, as the user might expect. What to do about that is left to a
future change.
Helped-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Sahil Dua <sahildua2305@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-06-19 05:19:16 +08:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Copy a trailing section at the end of the config, won't be
|
|
|
|
|
* flushed by the usual "flush because we have a new section
|
|
|
|
|
* logic in the loop above.
|
|
|
|
|
*/
|
|
|
|
|
if (copystr.len > 0) {
|
2017-11-15 20:40:43 +08:00
|
|
|
if (write_in_full(out_fd, copystr.buf, copystr.len) < 0) {
|
2017-11-06 12:11:21 +08:00
|
|
|
ret = write_error(get_lock_file_path(&lock));
|
branch: add a --copy (-c) option to go with --move (-m)
Add the ability to --copy a branch and its reflog and configuration,
this uses the same underlying machinery as the --move (-m) option
except the reflog and configuration is copied instead of being moved.
This is useful for e.g. copying a topic branch to a new version,
e.g. work to work-2 after submitting the work topic to the list, while
preserving all the tracking info and other configuration that goes
with the branch, and unlike --move keeping the other already-submitted
branch around for reference.
Like --move, when the source branch is the currently checked out
branch the HEAD is moved to the destination branch. In the case of
--move we don't really have a choice (other than remaining on a
detached HEAD) and in order to keep the functionality consistent, we
are doing it in similar way for --copy too.
The most common usage of this feature is expected to be moving to a
new topic branch which is a copy of the current one, in that case
moving to the target branch is what the user wants, and doesn't
unexpectedly behave differently than --move would.
One outstanding caveat of this implementation is that:
git checkout maint &&
git checkout master &&
git branch -c topic &&
git checkout -
Will check out 'maint' instead of 'master'. This is because the @{-N}
feature (or its -1 shorthand "-") relies on HEAD reflogs created by
the checkout command, so in this case we'll checkout maint instead of
master, as the user might expect. What to do about that is left to a
future change.
Helped-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Sahil Dua <sahildua2305@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-06-19 05:19:16 +08:00
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
strbuf_reset(©str);
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-20 13:55:27 +08:00
|
|
|
fclose(config_file);
|
2017-05-04 21:55:41 +08:00
|
|
|
config_file = NULL;
|
2016-12-20 17:48:35 +08:00
|
|
|
commit_and_out:
|
2017-10-06 04:32:04 +08:00
|
|
|
if (commit_lock_file(&lock) < 0)
|
2018-07-21 15:49:27 +08:00
|
|
|
ret = error_errno(_("could not write config file %s"),
|
2016-05-08 17:47:38 +08:00
|
|
|
config_filename);
|
2011-07-17 05:55:52 +08:00
|
|
|
out:
|
2017-05-04 21:55:41 +08:00
|
|
|
if (config_file)
|
|
|
|
|
fclose(config_file);
|
2017-10-06 04:32:04 +08:00
|
|
|
rollback_lock_file(&lock);
|
2016-12-20 17:48:36 +08:00
|
|
|
out_no_rollback:
|
2012-02-16 16:04:25 +08:00
|
|
|
free(filename_buf);
|
2018-05-20 18:42:33 +08:00
|
|
|
config_store_data_clear(&store);
|
2006-12-16 22:14:14 +08:00
|
|
|
return ret;
|
|
|
|
|
}
|
2008-02-12 02:41:18 +08:00
|
|
|
|
branch: add a --copy (-c) option to go with --move (-m)
Add the ability to --copy a branch and its reflog and configuration,
this uses the same underlying machinery as the --move (-m) option
except the reflog and configuration is copied instead of being moved.
This is useful for e.g. copying a topic branch to a new version,
e.g. work to work-2 after submitting the work topic to the list, while
preserving all the tracking info and other configuration that goes
with the branch, and unlike --move keeping the other already-submitted
branch around for reference.
Like --move, when the source branch is the currently checked out
branch the HEAD is moved to the destination branch. In the case of
--move we don't really have a choice (other than remaining on a
detached HEAD) and in order to keep the functionality consistent, we
are doing it in similar way for --copy too.
The most common usage of this feature is expected to be moving to a
new topic branch which is a copy of the current one, in that case
moving to the target branch is what the user wants, and doesn't
unexpectedly behave differently than --move would.
One outstanding caveat of this implementation is that:
git checkout maint &&
git checkout master &&
git branch -c topic &&
git checkout -
Will check out 'maint' instead of 'master'. This is because the @{-N}
feature (or its -1 shorthand "-") relies on HEAD reflogs created by
the checkout command, so in this case we'll checkout maint instead of
master, as the user might expect. What to do about that is left to a
future change.
Helped-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Sahil Dua <sahildua2305@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-06-19 05:19:16 +08:00
|
|
|
int git_config_rename_section_in_file(const char *config_filename,
|
|
|
|
|
const char *old_name, const char *new_name)
|
|
|
|
|
{
|
|
|
|
|
return git_config_copy_or_rename_section_in_file(config_filename,
|
|
|
|
|
old_name, new_name, 0);
|
|
|
|
|
}
|
|
|
|
|
|
2012-02-16 16:04:25 +08:00
|
|
|
int git_config_rename_section(const char *old_name, const char *new_name)
|
|
|
|
|
{
|
2012-02-16 16:09:32 +08:00
|
|
|
return git_config_rename_section_in_file(NULL, old_name, new_name);
|
2012-02-16 16:04:25 +08:00
|
|
|
}
|
|
|
|
|
|
branch: add a --copy (-c) option to go with --move (-m)
Add the ability to --copy a branch and its reflog and configuration,
this uses the same underlying machinery as the --move (-m) option
except the reflog and configuration is copied instead of being moved.
This is useful for e.g. copying a topic branch to a new version,
e.g. work to work-2 after submitting the work topic to the list, while
preserving all the tracking info and other configuration that goes
with the branch, and unlike --move keeping the other already-submitted
branch around for reference.
Like --move, when the source branch is the currently checked out
branch the HEAD is moved to the destination branch. In the case of
--move we don't really have a choice (other than remaining on a
detached HEAD) and in order to keep the functionality consistent, we
are doing it in similar way for --copy too.
The most common usage of this feature is expected to be moving to a
new topic branch which is a copy of the current one, in that case
moving to the target branch is what the user wants, and doesn't
unexpectedly behave differently than --move would.
One outstanding caveat of this implementation is that:
git checkout maint &&
git checkout master &&
git branch -c topic &&
git checkout -
Will check out 'maint' instead of 'master'. This is because the @{-N}
feature (or its -1 shorthand "-") relies on HEAD reflogs created by
the checkout command, so in this case we'll checkout maint instead of
master, as the user might expect. What to do about that is left to a
future change.
Helped-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Sahil Dua <sahildua2305@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-06-19 05:19:16 +08:00
|
|
|
int git_config_copy_section_in_file(const char *config_filename,
|
|
|
|
|
const char *old_name, const char *new_name)
|
|
|
|
|
{
|
|
|
|
|
return git_config_copy_or_rename_section_in_file(config_filename,
|
|
|
|
|
old_name, new_name, 1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int git_config_copy_section(const char *old_name, const char *new_name)
|
|
|
|
|
{
|
|
|
|
|
return git_config_copy_section_in_file(NULL, old_name, new_name);
|
|
|
|
|
}
|
|
|
|
|
|
2008-02-12 02:41:18 +08:00
|
|
|
/*
|
|
|
|
|
* Call this to report error for your variable that should not
|
|
|
|
|
* get a boolean value (i.e. "[my] var" means "true").
|
|
|
|
|
*/
|
2012-12-16 01:42:10 +08:00
|
|
|
#undef config_error_nonbool
|
2008-02-12 02:41:18 +08:00
|
|
|
int config_error_nonbool(const char *var)
|
|
|
|
|
{
|
2018-07-21 15:49:27 +08:00
|
|
|
return error(_("missing value for '%s'"), var);
|
2008-02-12 02:41:18 +08:00
|
|
|
}
|
2013-01-23 14:23:05 +08:00
|
|
|
|
|
|
|
|
int parse_config_key(const char *var,
|
|
|
|
|
const char *section,
|
|
|
|
|
const char **subsection, int *subsection_len,
|
|
|
|
|
const char **key)
|
|
|
|
|
{
|
|
|
|
|
const char *dot;
|
|
|
|
|
|
|
|
|
|
/* Does it start with "section." ? */
|
2017-02-25 05:07:19 +08:00
|
|
|
if (!skip_prefix(var, section, &var) || *var != '.')
|
2013-01-23 14:23:05 +08:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Find the key; we don't know yet if we have a subsection, but we must
|
|
|
|
|
* parse backwards from the end, since the subsection may have dots in
|
|
|
|
|
* it, too.
|
|
|
|
|
*/
|
|
|
|
|
dot = strrchr(var, '.');
|
|
|
|
|
*key = dot + 1;
|
|
|
|
|
|
|
|
|
|
/* Did we have a subsection at all? */
|
2017-02-25 05:07:19 +08:00
|
|
|
if (dot == var) {
|
parse_config_key: allow matching single-level config
The parse_config_key() function was introduced to make it
easier to match "section.subsection.key" variables. It also
handles the simpler "section.key", and the caller is
responsible for distinguishing the two from its
out-parameters.
Most callers who _only_ want "section.key" would just use a
strcmp(var, "section.key"), since there is no parsing
required. However, they may still use parse_config_key() if
their "section" variable isn't a constant (an example of
this is in parse_hide_refs_config).
Using the parse_config_key is a bit clunky, though:
const char *subsection;
int subsection_len;
const char *key;
if (!parse_config_key(var, section, &subsection, &subsection_len, &key) &&
!subsection) {
/* matched! */
}
Instead, let's treat a NULL subsection as an indication that
the caller does not expect one. That lets us write:
const char *key;
if (!parse_config_key(var, section, NULL, NULL, &key)) {
/* matched! */
}
Existing callers should be unaffected, as passing a NULL
subsection would currently segfault.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-02-25 05:08:02 +08:00
|
|
|
if (subsection) {
|
|
|
|
|
*subsection = NULL;
|
|
|
|
|
*subsection_len = 0;
|
|
|
|
|
}
|
2013-01-23 14:23:05 +08:00
|
|
|
}
|
|
|
|
|
else {
|
parse_config_key: allow matching single-level config
The parse_config_key() function was introduced to make it
easier to match "section.subsection.key" variables. It also
handles the simpler "section.key", and the caller is
responsible for distinguishing the two from its
out-parameters.
Most callers who _only_ want "section.key" would just use a
strcmp(var, "section.key"), since there is no parsing
required. However, they may still use parse_config_key() if
their "section" variable isn't a constant (an example of
this is in parse_hide_refs_config).
Using the parse_config_key is a bit clunky, though:
const char *subsection;
int subsection_len;
const char *key;
if (!parse_config_key(var, section, &subsection, &subsection_len, &key) &&
!subsection) {
/* matched! */
}
Instead, let's treat a NULL subsection as an indication that
the caller does not expect one. That lets us write:
const char *key;
if (!parse_config_key(var, section, NULL, NULL, &key)) {
/* matched! */
}
Existing callers should be unaffected, as passing a NULL
subsection would currently segfault.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-02-25 05:08:02 +08:00
|
|
|
if (!subsection)
|
|
|
|
|
return -1;
|
2017-02-25 05:07:19 +08:00
|
|
|
*subsection = var + 1;
|
2013-01-23 14:23:05 +08:00
|
|
|
*subsection_len = dot - *subsection;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2016-02-19 17:16:01 +08:00
|
|
|
|
|
|
|
|
const char *current_config_origin_type(void)
|
|
|
|
|
{
|
i18n: config: unfold error messages marked for translation
Introduced in 473166b ("config: add 'origin_type' to config_source
struct", 2016-02-19), Git can inform the user about the origin of a
config error, but the implementation does not allow translators to
translate the keywords 'file', 'blob, 'standard input', and
'submodule-blob'. Moreover, for the second message, a reason for the
error is appended to the message, not allowing translators to translate
that reason either.
Unfold the message into several templates for each known origin_type.
That would result in better translation at the expense of code
verbosity.
Add enum config_oringin_type to ease management of the various
configuration origin types (blob, file, etc). Previously origin type
was considered from command line if cf->origin_type == NULL, i.e.,
uninitialized. Now we set origin_type to CONFIG_ORIGIN_CMDLINE in
git_config_from_parameters() and configset_add_value().
For error message in git_parse_source(), use xstrfmt() function to
prepare the message string, instead of doing something like it's done
for die_bad_number(), because intelligibility and code conciseness are
improved for that instance.
Signed-off-by: Vasco Almeida <vascomalmeida@sapo.pt>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-07-28 21:14:03 +08:00
|
|
|
int type;
|
2016-05-27 08:32:23 +08:00
|
|
|
if (current_config_kvi)
|
|
|
|
|
type = current_config_kvi->origin_type;
|
|
|
|
|
else if(cf)
|
|
|
|
|
type = cf->origin_type;
|
|
|
|
|
else
|
2018-05-02 17:38:39 +08:00
|
|
|
BUG("current_config_origin_type called outside config callback");
|
i18n: config: unfold error messages marked for translation
Introduced in 473166b ("config: add 'origin_type' to config_source
struct", 2016-02-19), Git can inform the user about the origin of a
config error, but the implementation does not allow translators to
translate the keywords 'file', 'blob, 'standard input', and
'submodule-blob'. Moreover, for the second message, a reason for the
error is appended to the message, not allowing translators to translate
that reason either.
Unfold the message into several templates for each known origin_type.
That would result in better translation at the expense of code
verbosity.
Add enum config_oringin_type to ease management of the various
configuration origin types (blob, file, etc). Previously origin type
was considered from command line if cf->origin_type == NULL, i.e.,
uninitialized. Now we set origin_type to CONFIG_ORIGIN_CMDLINE in
git_config_from_parameters() and configset_add_value().
For error message in git_parse_source(), use xstrfmt() function to
prepare the message string, instead of doing something like it's done
for die_bad_number(), because intelligibility and code conciseness are
improved for that instance.
Signed-off-by: Vasco Almeida <vascomalmeida@sapo.pt>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-07-28 21:14:03 +08:00
|
|
|
|
|
|
|
|
switch (type) {
|
|
|
|
|
case CONFIG_ORIGIN_BLOB:
|
|
|
|
|
return "blob";
|
|
|
|
|
case CONFIG_ORIGIN_FILE:
|
|
|
|
|
return "file";
|
|
|
|
|
case CONFIG_ORIGIN_STDIN:
|
|
|
|
|
return "standard input";
|
|
|
|
|
case CONFIG_ORIGIN_SUBMODULE_BLOB:
|
|
|
|
|
return "submodule-blob";
|
|
|
|
|
case CONFIG_ORIGIN_CMDLINE:
|
|
|
|
|
return "command line";
|
|
|
|
|
default:
|
2018-05-02 17:38:39 +08:00
|
|
|
BUG("unknown config origin type");
|
i18n: config: unfold error messages marked for translation
Introduced in 473166b ("config: add 'origin_type' to config_source
struct", 2016-02-19), Git can inform the user about the origin of a
config error, but the implementation does not allow translators to
translate the keywords 'file', 'blob, 'standard input', and
'submodule-blob'. Moreover, for the second message, a reason for the
error is appended to the message, not allowing translators to translate
that reason either.
Unfold the message into several templates for each known origin_type.
That would result in better translation at the expense of code
verbosity.
Add enum config_oringin_type to ease management of the various
configuration origin types (blob, file, etc). Previously origin type
was considered from command line if cf->origin_type == NULL, i.e.,
uninitialized. Now we set origin_type to CONFIG_ORIGIN_CMDLINE in
git_config_from_parameters() and configset_add_value().
For error message in git_parse_source(), use xstrfmt() function to
prepare the message string, instead of doing something like it's done
for die_bad_number(), because intelligibility and code conciseness are
improved for that instance.
Signed-off-by: Vasco Almeida <vascomalmeida@sapo.pt>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-07-28 21:14:03 +08:00
|
|
|
}
|
2016-02-19 17:16:01 +08:00
|
|
|
}
|
|
|
|
|
|
2020-02-10 08:30:53 +08:00
|
|
|
const char *config_scope_name(enum config_scope scope)
|
|
|
|
|
{
|
|
|
|
|
switch (scope) {
|
|
|
|
|
case CONFIG_SCOPE_SYSTEM:
|
|
|
|
|
return "system";
|
|
|
|
|
case CONFIG_SCOPE_GLOBAL:
|
|
|
|
|
return "global";
|
2020-02-10 08:30:54 +08:00
|
|
|
case CONFIG_SCOPE_LOCAL:
|
|
|
|
|
return "local";
|
|
|
|
|
case CONFIG_SCOPE_WORKTREE:
|
|
|
|
|
return "worktree";
|
2020-02-10 08:30:55 +08:00
|
|
|
case CONFIG_SCOPE_COMMAND:
|
|
|
|
|
return "command";
|
2020-02-10 08:30:58 +08:00
|
|
|
case CONFIG_SCOPE_SUBMODULE:
|
|
|
|
|
return "submodule";
|
2020-02-10 08:30:53 +08:00
|
|
|
default:
|
|
|
|
|
return "unknown";
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2016-02-19 17:16:01 +08:00
|
|
|
const char *current_config_name(void)
|
|
|
|
|
{
|
2016-05-27 08:32:23 +08:00
|
|
|
const char *name;
|
|
|
|
|
if (current_config_kvi)
|
|
|
|
|
name = current_config_kvi->filename;
|
|
|
|
|
else if (cf)
|
|
|
|
|
name = cf->name;
|
|
|
|
|
else
|
2018-05-02 17:38:39 +08:00
|
|
|
BUG("current_config_name called outside config callback");
|
2016-05-27 08:32:23 +08:00
|
|
|
return name ? name : "";
|
2016-02-19 17:16:01 +08:00
|
|
|
}
|
config: add a notion of "scope"
A config callback passed to git_config() doesn't know very
much about the context in which it sees a variable. It can
ask whether the variable comes from a file, and get the file
name. But without analyzing the filename (which is hard to
do accurately), it cannot tell whether it is in system-level
config, user-level config, or repo-specific config.
Generally this doesn't matter; the point of not passing this
to the callback is that it should treat the config the same
no matter where it comes from. But some programs, like
upload-pack, are a special case: we should be able to run
them in an untrusted repository, which means we cannot use
any "dangerous" config from the repository config file (but
it is OK to use it from system or user config).
This patch teaches the config code to record the "scope" of
each variable, and make it available inside config
callbacks, similar to how we give access to the filename.
The scope is the starting source for a particular parsing
operation, and remains the same even if we include other
files (so a .git/config which includes another file will
remain CONFIG_SCOPE_REPO, as it would be similarly
untrusted).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-05-19 06:44:23 +08:00
|
|
|
|
|
|
|
|
enum config_scope current_config_scope(void)
|
|
|
|
|
{
|
|
|
|
|
if (current_config_kvi)
|
|
|
|
|
return current_config_kvi->scope;
|
|
|
|
|
else
|
|
|
|
|
return current_parsing_scope;
|
2016-02-19 17:16:01 +08:00
|
|
|
}
|
2018-05-26 21:55:21 +08:00
|
|
|
|
|
|
|
|
int lookup_config(const char **mapping, int nr_mapping, const char *var)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < nr_mapping; i++) {
|
|
|
|
|
const char *name = mapping[i];
|
|
|
|
|
|
|
|
|
|
if (name && !strcasecmp(var, name))
|
|
|
|
|
return i;
|
|
|
|
|
}
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
