🌐 AI搜索 & 代理 主页
Google Git
Sign in
chromium / external / github.com / git / git / refs/tags/v2.0.3 / . / config.c
blob: 2634457f6b07ca55b69f3b4a22b8a9e4339fd121 [file] [log] [blame]
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1/*
2 * GIT - The information manager from hell
3 *
4 * Copyright (C) Linus Torvalds, 2005
5 * Copyright (C) Johannes Schindelin, 2005
6 *
7 */
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]8#include "cache.h"
Johannes Sixt7f0e39f2007-11-13 20:05:06[diff] [blame]9#include "exec_cmd.h"
Alex Riesen572e4f62010-03-26 22:56:01[diff] [blame]10#include "strbuf.h"
Jeff King2b64fc82010-08-23 19:16:00[diff] [blame]11#include "quote.h"
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]12
Heiko Voigt4d8dd142013-07-11 22:44:39[diff] [blame]13struct config_source {
14 struct config_source *prev;
15 union {
16 FILE *file;
Heiko Voigt1bc88812013-07-11 22:46:47[diff] [blame]17 struct config_buf {
18 const char *buf;
19 size_t len;
20 size_t pos;
21 } buf;
Heiko Voigt4d8dd142013-07-11 22:44:39[diff] [blame]22 } u;
Ramsay Jones924aaf32011-06-16 20:24:51[diff] [blame]23 const char *name;
Jeff Kingd14d4242014-02-18 22:58:52[diff] [blame]24 const char *path;
Heiko Voigtb2dc0942013-07-11 22:48:30[diff] [blame]25 int die_on_error;
Ramsay Jones924aaf32011-06-16 20:24:51[diff] [blame]26 int linenr;
27 int eof;
28 struct strbuf value;
Ben Walton0971e992012-09-30 19:44:36[diff] [blame]29 struct strbuf var;
Ramsay Jones924aaf32011-06-16 20:24:51[diff] [blame]30
Jeff King49d6cfa2013-08-26 21:57:18[diff] [blame]31 int (*do_fgetc)(struct config_source *c);
32 int (*do_ungetc)(int c, struct config_source *conf);
33 long (*do_ftell)(struct config_source *c);
Heiko Voigt4d8dd142013-07-11 22:44:39[diff] [blame]34};
35
36static struct config_source *cf;
Ramsay Jones924aaf32011-06-16 20:24:51[diff] [blame]37
Dana How960ccca2007-05-09 20:56:50[diff] [blame]38static int zlib_compression_seen;
39
Heiko Voigt4d8dd142013-07-11 22:44:39[diff] [blame]40static int config_file_fgetc(struct config_source *conf)
41{
42 return fgetc(conf->u.file);
43}
44
45static int config_file_ungetc(int c, struct config_source *conf)
46{
47 return ungetc(c, conf->u.file);
48}
49
50static long config_file_ftell(struct config_source *conf)
51{
52 return ftell(conf->u.file);
53}
54
Heiko Voigt1bc88812013-07-11 22:46:47[diff] [blame]55
56static int config_buf_fgetc(struct config_source *conf)
57{
58 if (conf->u.buf.pos < conf->u.buf.len)
59 return conf->u.buf.buf[conf->u.buf.pos++];
60
61 return EOF;
62}
63
64static int config_buf_ungetc(int c, struct config_source *conf)
65{
66 if (conf->u.buf.pos > 0)
67 return conf->u.buf.buf[--conf->u.buf.pos];
68
69 return EOF;
70}
71
72static long config_buf_ftell(struct config_source *conf)
73{
74 return conf->u.buf.pos;
75}
76
Jeff King9b25a0b2012-02-06 09:54:04[diff] [blame]77#define MAX_INCLUDE_DEPTH 10
78static const char include_depth_advice[] =
79"exceeded maximum include depth (%d) while including\n"
80" %s\n"
81"from\n"
82" %s\n"
83"Do you have circular includes?";
84static int handle_path_include(const char *path, struct config_include_data *inc)
85{
86 int ret = 0;
87 struct strbuf buf = STRBUF_INIT;
Jeff King67beb602014-01-28 01:37:30[diff] [blame]88 char *expanded;
Jeff King4c0a89f2012-04-25 12:00:36[diff] [blame]89
Jeff King67beb602014-01-28 01:37:30[diff] [blame]90 if (!path)
91 return config_error_nonbool("include.path");
92
93 expanded = expand_user_path(path);
Jeff King4c0a89f2012-04-25 12:00:36[diff] [blame]94 if (!expanded)
95 return error("Could not expand include path '%s'", path);
96 path = expanded;
Jeff King9b25a0b2012-02-06 09:54:04[diff] [blame]97
98 /*
99 * Use an absolute path as-is, but interpret relative paths
100 * based on the including config file.
101 */
102 if (!is_absolute_path(path)) {
103 char *slash;
104
Jeff Kingd14d4242014-02-18 22:58:52[diff] [blame]105 if (!cf || !cf->path)
Jeff King9b25a0b2012-02-06 09:54:04[diff] [blame]106 return error("relative config includes must come from files");
107
Jeff Kingd14d4242014-02-18 22:58:52[diff] [blame]108 slash = find_last_dir_sep(cf->path);
Jeff King9b25a0b2012-02-06 09:54:04[diff] [blame]109 if (slash)
Jeff Kingd14d4242014-02-18 22:58:52[diff] [blame]110 strbuf_add(&buf, cf->path, slash - cf->path + 1);
Jeff King9b25a0b2012-02-06 09:54:04[diff] [blame]111 strbuf_addstr(&buf, path);
112 path = buf.buf;
113 }
114
Jonathan Nieder4698c8f2013-04-12 21:03:18[diff] [blame]115 if (!access_or_die(path, R_OK, 0)) {
Jeff King9b25a0b2012-02-06 09:54:04[diff] [blame]116 if (++inc->depth > MAX_INCLUDE_DEPTH)
117 die(include_depth_advice, MAX_INCLUDE_DEPTH, path,
118 cf && cf->name ? cf->name : "the command line");
119 ret = git_config_from_file(git_config_include, path, inc);
120 inc->depth--;
121 }
122 strbuf_release(&buf);
Jeff King4c0a89f2012-04-25 12:00:36[diff] [blame]123 free(expanded);
Jeff King9b25a0b2012-02-06 09:54:04[diff] [blame]124 return ret;
125}
126
127int git_config_include(const char *var, const char *value, void *data)
128{
129 struct config_include_data *inc = data;
130 const char *type;
131 int ret;
132
133 /*
134 * Pass along all values, including "include" directives; this makes it
135 * possible to query information on the includes themselves.
136 */
137 ret = inc->fn(var, value, inc->data);
138 if (ret < 0)
139 return ret;
140
141 type = skip_prefix(var, "include.");
142 if (!type)
143 return ret;
144
145 if (!strcmp(type, "path"))
146 ret = handle_path_include(value, inc);
147 return ret;
148}
149
Alex Riesen8b1fa772010-03-26 22:53:57[diff] [blame]150static void lowercase(char *p)
151{
152 for (; *p; p++)
153 *p = tolower(*p);
154}
Alex Riesen8b1fa772010-03-26 22:53:57[diff] [blame]155
Jeff King2b64fc82010-08-23 19:16:00[diff] [blame]156void git_config_push_parameter(const char *text)
157{
158 struct strbuf env = STRBUF_INIT;
159 const char *old = getenv(CONFIG_DATA_ENVIRONMENT);
160 if (old) {
161 strbuf_addstr(&env, old);
162 strbuf_addch(&env, ' ');
163 }
164 sq_quote_buf(&env, text);
165 setenv(CONFIG_DATA_ENVIRONMENT, env.buf, 1);
166 strbuf_release(&env);
167}
168
Jeff King24968442011-06-09 15:56:42[diff] [blame]169int git_config_parse_parameter(const char *text,
170 config_fn_t fn, void *data)
Alex Riesen8b1fa772010-03-26 22:53:57[diff] [blame]171{
Alex Riesen572e4f62010-03-26 22:56:01[diff] [blame]172 struct strbuf **pair;
Jeff Kingf77bcca2011-06-09 15:55:09[diff] [blame]173 pair = strbuf_split_str(text, '=', 2);
Jeff Kingc5d63502011-06-09 15:52:43[diff] [blame]174 if (!pair[0])
175 return error("bogus config parameter: %s", text);
Alex Riesen572e4f62010-03-26 22:56:01[diff] [blame]176 if (pair[0]->len && pair[0]->buf[pair[0]->len - 1] == '=')
177 strbuf_setlen(pair[0], pair[0]->len - 1);
178 strbuf_trim(pair[0]);
179 if (!pair[0]->len) {
180 strbuf_list_free(pair);
Jeff King06eb7082011-05-24 22:49:55[diff] [blame]181 return error("bogus config parameter: %s", text);
182 }
183 lowercase(pair[0]->buf);
184 if (fn(pair[0]->buf, pair[1] ? pair[1]->buf : NULL, data) < 0) {
185 strbuf_list_free(pair);
Alex Riesen8b1fa772010-03-26 22:53:57[diff] [blame]186 return -1;
Alex Riesen8b1fa772010-03-26 22:53:57[diff] [blame]187 }
Alex Riesen572e4f62010-03-26 22:56:01[diff] [blame]188 strbuf_list_free(pair);
Alex Riesen8b1fa772010-03-26 22:53:57[diff] [blame]189 return 0;
190}
191
Jeff King06eb7082011-05-24 22:49:55[diff] [blame]192int git_config_from_parameters(config_fn_t fn, void *data)
193{
Jeff King2b64fc82010-08-23 19:16:00[diff] [blame]194 const char *env = getenv(CONFIG_DATA_ENVIRONMENT);
195 char *envw;
196 const char **argv = NULL;
197 int nr = 0, alloc = 0;
198 int i;
199
200 if (!env)
201 return 0;
202 /* sq_dequote will write over it */
203 envw = xstrdup(env);
204
205 if (sq_dequote_to_argv(envw, &argv, &nr, &alloc) < 0) {
206 free(envw);
207 return error("bogus format in " CONFIG_DATA_ENVIRONMENT);
208 }
209
210 for (i = 0; i < nr; i++) {
Jeff King06eb7082011-05-24 22:49:55[diff] [blame]211 if (git_config_parse_parameter(argv[i], fn, data) < 0) {
Jeff King2b64fc82010-08-23 19:16:00[diff] [blame]212 free(argv);
213 free(envw);
214 return -1;
215 }
216 }
217
218 free(argv);
219 free(envw);
Jeff King06eb7082011-05-24 22:49:55[diff] [blame]220 return nr > 0;
Jeff King2b64fc82010-08-23 19:16:00[diff] [blame]221}
222
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]223static int get_next_char(void)
224{
Jeff King49d6cfa2013-08-26 21:57:18[diff] [blame]225 int c = cf->do_fgetc(cf);
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]226
Heiko Voigtdbb9a812013-05-11 13:19:29[diff] [blame]227 if (c == '\r') {
228 /* DOS like systems */
Jeff King49d6cfa2013-08-26 21:57:18[diff] [blame]229 c = cf->do_fgetc(cf);
Heiko Voigtdbb9a812013-05-11 13:19:29[diff] [blame]230 if (c != '\n') {
Jeff King49d6cfa2013-08-26 21:57:18[diff] [blame]231 cf->do_ungetc(c, cf);
Heiko Voigtdbb9a812013-05-11 13:19:29[diff] [blame]232 c = '\r';
Junio C Hamanodb2c0752005-11-02 21:02:57[diff] [blame]233 }
Heiko Voigtdbb9a812013-05-11 13:19:29[diff] [blame]234 }
235 if (c == '\n')
236 cf->linenr++;
237 if (c == EOF) {
238 cf->eof = 1;
239 c = '\n';
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]240 }
241 return c;
242}
243
244static char *parse_value(void)
245{
Erik Faye-Lunde96c19c2011-04-10 20:54:18[diff] [blame]246 int quote = 0, comment = 0, space = 0;
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]247
Ramsay Jones924aaf32011-06-16 20:24:51[diff] [blame]248 strbuf_reset(&cf->value);
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]249 for (;;) {
250 int c = get_next_char();
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]251 if (c == '\n') {
Martin Stenberg4b340592012-03-09 21:57:54[diff] [blame]252 if (quote) {
253 cf->linenr--;
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]254 return NULL;
Martin Stenberg4b340592012-03-09 21:57:54[diff] [blame]255 }
Ramsay Jones924aaf32011-06-16 20:24:51[diff] [blame]256 return cf->value.buf;
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]257 }
258 if (comment)
259 continue;
260 if (isspace(c) && !quote) {
Ramsay Jones924aaf32011-06-16 20:24:51[diff] [blame]261 if (cf->value.len)
Björn Steinbrinkebdaae32009-07-30 11:41:57[diff] [blame]262 space++;
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]263 continue;
264 }
Johannes Schindelin7ebdba62006-05-02 14:58:37[diff] [blame]265 if (!quote) {
266 if (c == ';' || c == '#') {
267 comment = 1;
268 continue;
269 }
270 }
Björn Steinbrinkebdaae32009-07-30 11:41:57[diff] [blame]271 for (; space; space--)
Ramsay Jones924aaf32011-06-16 20:24:51[diff] [blame]272 strbuf_addch(&cf->value, ' ');
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]273 if (c == '\\') {
274 c = get_next_char();
275 switch (c) {
276 case '\n':
277 continue;
278 case 't':
279 c = '\t';
280 break;
281 case 'b':
282 c = '\b';
283 break;
284 case 'n':
285 c = '\n';
286 break;
Linus Torvalds5cbb4012005-10-11 22:24:11[diff] [blame]287 /* Some characters escape as themselves */
288 case '\\': case '"':
289 break;
290 /* Reject unknown escape sequences */
291 default:
292 return NULL;
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]293 }
Ramsay Jones924aaf32011-06-16 20:24:51[diff] [blame]294 strbuf_addch(&cf->value, c);
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]295 continue;
296 }
297 if (c == '"') {
298 quote = 1-quote;
299 continue;
300 }
Ramsay Jones924aaf32011-06-16 20:24:51[diff] [blame]301 strbuf_addch(&cf->value, c);
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]302 }
303}
304
Linus Torvalds38c5afa2006-10-30 16:25:36[diff] [blame]305static inline int iskeychar(int c)
306{
307 return isalnum(c) || c == '-';
308}
309
Ben Walton0971e992012-09-30 19:44:36[diff] [blame]310static int get_value(config_fn_t fn, void *data, struct strbuf *name)
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]311{
312 int c;
313 char *value;
314
315 /* Get the full name */
316 for (;;) {
317 c = get_next_char();
Ramsay Jones924aaf32011-06-16 20:24:51[diff] [blame]318 if (cf->eof)
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]319 break;
Linus Torvalds38c5afa2006-10-30 16:25:36[diff] [blame]320 if (!iskeychar(c))
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]321 break;
Ben Walton0971e992012-09-30 19:44:36[diff] [blame]322 strbuf_addch(name, tolower(c));
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]323 }
Ben Walton0971e992012-09-30 19:44:36[diff] [blame]324
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]325 while (c == ' ' || c == '\t')
326 c = get_next_char();
327
328 value = NULL;
329 if (c != '\n') {
330 if (c != '=')
331 return -1;
332 value = parse_value();
333 if (!value)
334 return -1;
335 }
Ben Walton0971e992012-09-30 19:44:36[diff] [blame]336 return fn(name->buf, value, data);
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]337}
338
Ben Walton0971e992012-09-30 19:44:36[diff] [blame]339static int get_extended_base_var(struct strbuf *name, int c)
Linus Torvaldsd14f7762006-05-09 19:24:02[diff] [blame]340{
341 do {
342 if (c == '\n')
Martin Stenberg4b340592012-03-09 21:57:54[diff] [blame]343 goto error_incomplete_line;
Linus Torvaldsd14f7762006-05-09 19:24:02[diff] [blame]344 c = get_next_char();
345 } while (isspace(c));
346
347 /* We require the format to be '[base "extension"]' */
348 if (c != '"')
349 return -1;
Ben Walton0971e992012-09-30 19:44:36[diff] [blame]350 strbuf_addch(name, '.');
Linus Torvaldsd14f7762006-05-09 19:24:02[diff] [blame]351
352 for (;;) {
353 int c = get_next_char();
354 if (c == '\n')
Martin Stenberg4b340592012-03-09 21:57:54[diff] [blame]355 goto error_incomplete_line;
Linus Torvaldsd14f7762006-05-09 19:24:02[diff] [blame]356 if (c == '"')
357 break;
358 if (c == '\\') {
359 c = get_next_char();
360 if (c == '\n')
Martin Stenberg4b340592012-03-09 21:57:54[diff] [blame]361 goto error_incomplete_line;
Linus Torvaldsd14f7762006-05-09 19:24:02[diff] [blame]362 }
Ben Walton0971e992012-09-30 19:44:36[diff] [blame]363 strbuf_addch(name, c);
Linus Torvaldsd14f7762006-05-09 19:24:02[diff] [blame]364 }
365
366 /* Final ']' */
367 if (get_next_char() != ']')
368 return -1;
Ben Walton0971e992012-09-30 19:44:36[diff] [blame]369 return 0;
Martin Stenberg4b340592012-03-09 21:57:54[diff] [blame]370error_incomplete_line:
371 cf->linenr--;
372 return -1;
Linus Torvaldsd14f7762006-05-09 19:24:02[diff] [blame]373}
374
Ben Walton0971e992012-09-30 19:44:36[diff] [blame]375static int get_base_var(struct strbuf *name)
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]376{
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]377 for (;;) {
378 int c = get_next_char();
Ramsay Jones924aaf32011-06-16 20:24:51[diff] [blame]379 if (cf->eof)
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]380 return -1;
381 if (c == ']')
Ben Walton0971e992012-09-30 19:44:36[diff] [blame]382 return 0;
Linus Torvaldsd14f7762006-05-09 19:24:02[diff] [blame]383 if (isspace(c))
Ben Walton0971e992012-09-30 19:44:36[diff] [blame]384 return get_extended_base_var(name, c);
Linus Torvalds38c5afa2006-10-30 16:25:36[diff] [blame]385 if (!iskeychar(c) && c != '.')
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]386 return -1;
Ben Walton0971e992012-09-30 19:44:36[diff] [blame]387 strbuf_addch(name, tolower(c));
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]388 }
389}
390
Heiko Voigt4d8dd142013-07-11 22:44:39[diff] [blame]391static int git_parse_source(config_fn_t fn, void *data)
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]392{
393 int comment = 0;
394 int baselen = 0;
Ben Walton0971e992012-09-30 19:44:36[diff] [blame]395 struct strbuf *var = &cf->var;
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]396
Petr Baudisde056402008-10-01 20:13:02[diff] [blame]397 /* U+FEFF Byte Order Mark in UTF8 */
398 static const unsigned char *utf8_bom = (unsigned char *) "\xef\xbb\xbf";
399 const unsigned char *bomptr = utf8_bom;
400
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]401 for (;;) {
402 int c = get_next_char();
Petr Baudisde056402008-10-01 20:13:02[diff] [blame]403 if (bomptr && *bomptr) {
404 /* We are at the file beginning; skip UTF8-encoded BOM
405 * if present. Sane editors won't put this in on their
406 * own, but e.g. Windows Notepad will do it happily. */
407 if ((unsigned char) c == *bomptr) {
408 bomptr++;
409 continue;
410 } else {
411 /* Do not tolerate partial BOM. */
412 if (bomptr != utf8_bom)
413 break;
414 /* No BOM at file beginning. Cool. */
415 bomptr = NULL;
416 }
417 }
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]418 if (c == '\n') {
Ramsay Jones924aaf32011-06-16 20:24:51[diff] [blame]419 if (cf->eof)
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]420 return 0;
421 comment = 0;
422 continue;
423 }
424 if (comment || isspace(c))
425 continue;
426 if (c == '#' || c == ';') {
427 comment = 1;
428 continue;
429 }
430 if (c == '[') {
Ben Walton0971e992012-09-30 19:44:36[diff] [blame]431 /* Reset prior to determining a new stem */
432 strbuf_reset(var);
433 if (get_base_var(var) < 0 || var->len < 1)
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]434 break;
Ben Walton0971e992012-09-30 19:44:36[diff] [blame]435 strbuf_addch(var, '.');
436 baselen = var->len;
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]437 continue;
438 }
439 if (!isalpha(c))
440 break;
Ben Walton0971e992012-09-30 19:44:36[diff] [blame]441 /*
442 * Truncate the var name back to the section header
443 * stem prior to grabbing the suffix part of the name
444 * and the value.
445 */
446 strbuf_setlen(var, baselen);
447 strbuf_addch(var, tolower(c));
448 if (get_value(fn, data, var) < 0)
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]449 break;
450 }
Heiko Voigtb2dc0942013-07-11 22:48:30[diff] [blame]451 if (cf->die_on_error)
452 die("bad config file line %d in %s", cf->linenr, cf->name);
453 else
454 return error("bad config file line %d in %s", cf->linenr, cf->name);
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]455}
456
Nick Alcockebaa1bd2011-11-02 15:46:23[diff] [blame]457static int parse_unit_factor(const char *end, uintmax_t *val)
Brian Downing0b87b6e2007-07-12 13:32:26[diff] [blame]458{
459 if (!*end)
460 return 1;
Shawn O. Pearcec8deb5a2007-12-25 07:18:05[diff] [blame]461 else if (!strcasecmp(end, "k")) {
462 *val *= 1024;
463 return 1;
464 }
465 else if (!strcasecmp(end, "m")) {
466 *val *= 1024 * 1024;
467 return 1;
468 }
469 else if (!strcasecmp(end, "g")) {
470 *val *= 1024 * 1024 * 1024;
471 return 1;
472 }
473 return 0;
Brian Downing0b87b6e2007-07-12 13:32:26[diff] [blame]474}
475
Jeff King71927772013-09-08 08:29:27[diff] [blame]476static int git_parse_signed(const char *value, intmax_t *ret, intmax_t max)
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]477{
478 if (value && *value) {
479 char *end;
Nick Alcockebaa1bd2011-11-02 15:46:23[diff] [blame]480 intmax_t val;
481 uintmax_t uval;
482 uintmax_t factor = 1;
483
484 errno = 0;
485 val = strtoimax(value, &end, 0);
486 if (errno == ERANGE)
487 return 0;
Jeff King33fdd772013-09-08 08:36:42[diff] [blame]488 if (!parse_unit_factor(end, &factor)) {
489 errno = EINVAL;
Shawn O. Pearcec8deb5a2007-12-25 07:18:05[diff] [blame]490 return 0;
Jeff King33fdd772013-09-08 08:36:42[diff] [blame]491 }
Nick Alcockebaa1bd2011-11-02 15:46:23[diff] [blame]492 uval = abs(val);
493 uval *= factor;
Jeff King33fdd772013-09-08 08:36:42[diff] [blame]494 if (uval > max || abs(val) > uval) {
495 errno = ERANGE;
Nick Alcockebaa1bd2011-11-02 15:46:23[diff] [blame]496 return 0;
Jeff King33fdd772013-09-08 08:36:42[diff] [blame]497 }
Nick Alcockebaa1bd2011-11-02 15:46:23[diff] [blame]498 val *= factor;
499 *ret = val;
Brian Downing0b87b6e2007-07-12 13:32:26[diff] [blame]500 return 1;
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]501 }
Jeff King33fdd772013-09-08 08:36:42[diff] [blame]502 errno = EINVAL;
Brian Downing0b87b6e2007-07-12 13:32:26[diff] [blame]503 return 0;
504}
505
Ramsay Jones0b4dc662013-10-06 20:48:29[diff] [blame]506static int git_parse_unsigned(const char *value, uintmax_t *ret, uintmax_t max)
Brian Downing0b87b6e2007-07-12 13:32:26[diff] [blame]507{
508 if (value && *value) {
509 char *end;
Nick Alcockebaa1bd2011-11-02 15:46:23[diff] [blame]510 uintmax_t val;
511 uintmax_t oldval;
512
513 errno = 0;
514 val = strtoumax(value, &end, 0);
515 if (errno == ERANGE)
516 return 0;
517 oldval = val;
Jeff King33fdd772013-09-08 08:36:42[diff] [blame]518 if (!parse_unit_factor(end, &val)) {
519 errno = EINVAL;
Shawn O. Pearcec8deb5a2007-12-25 07:18:05[diff] [blame]520 return 0;
Jeff King33fdd772013-09-08 08:36:42[diff] [blame]521 }
522 if (val > max || oldval > val) {
523 errno = ERANGE;
Nick Alcockebaa1bd2011-11-02 15:46:23[diff] [blame]524 return 0;
Jeff King33fdd772013-09-08 08:36:42[diff] [blame]525 }
Shawn O. Pearcec8deb5a2007-12-25 07:18:05[diff] [blame]526 *ret = val;
Brian Downing0b87b6e2007-07-12 13:32:26[diff] [blame]527 return 1;
528 }
Jeff King33fdd772013-09-08 08:36:42[diff] [blame]529 errno = EINVAL;
Brian Downing0b87b6e2007-07-12 13:32:26[diff] [blame]530 return 0;
531}
532
Jeff King42d194e2013-09-08 08:33:08[diff] [blame]533static int git_parse_int(const char *value, int *ret)
Jeff Kingc1867ce2008-02-21 00:00:32[diff] [blame]534{
Jeff King71927772013-09-08 08:29:27[diff] [blame]535 intmax_t tmp;
Jeff King42d194e2013-09-08 08:33:08[diff] [blame]536 if (!git_parse_signed(value, &tmp, maximum_signed_value_of_type(int)))
Jeff King71927772013-09-08 08:29:27[diff] [blame]537 return 0;
538 *ret = tmp;
539 return 1;
540}
541
Jeff King00160242013-09-08 08:40:02[diff] [blame]542static int git_parse_int64(const char *value, int64_t *ret)
543{
544 intmax_t tmp;
545 if (!git_parse_signed(value, &tmp, maximum_signed_value_of_type(int64_t)))
546 return 0;
547 *ret = tmp;
548 return 1;
549}
550
Jeff King71927772013-09-08 08:29:27[diff] [blame]551int git_parse_ulong(const char *value, unsigned long *ret)
552{
553 uintmax_t tmp;
554 if (!git_parse_unsigned(value, &tmp, maximum_unsigned_value_of_type(long)))
555 return 0;
556 *ret = tmp;
557 return 1;
558}
559
Jeff King06bdc232014-04-16 16:51:47[diff] [blame]560NORETURN
Jeff King2f666582013-09-08 08:38:22[diff] [blame]561static void die_bad_number(const char *name, const char *value)
Jeff Kingc1867ce2008-02-21 00:00:32[diff] [blame]562{
Jeff King2f666582013-09-08 08:38:22[diff] [blame]563 const char *reason = errno == ERANGE ?
564 "out of range" :
565 "invalid unit";
566 if (!value)
567 value = "";
568
Ramsay Jones924aaf32011-06-16 20:24:51[diff] [blame]569 if (cf && cf->name)
Jeff King2f666582013-09-08 08:38:22[diff] [blame]570 die("bad numeric config value '%s' for '%s' in %s: %s",
571 value, name, cf->name, reason);
572 die("bad numeric config value '%s' for '%s': %s", value, name, reason);
Jeff Kingc1867ce2008-02-21 00:00:32[diff] [blame]573}
574
Brian Downing0b87b6e2007-07-12 13:32:26[diff] [blame]575int git_config_int(const char *name, const char *value)
576{
Jeff King42d194e2013-09-08 08:33:08[diff] [blame]577 int ret;
578 if (!git_parse_int(value, &ret))
Jeff King2f666582013-09-08 08:38:22[diff] [blame]579 die_bad_number(name, value);
Brian Downing0b87b6e2007-07-12 13:32:26[diff] [blame]580 return ret;
581}
582
Jeff King00160242013-09-08 08:40:02[diff] [blame]583int64_t git_config_int64(const char *name, const char *value)
584{
585 int64_t ret;
586 if (!git_parse_int64(value, &ret))
587 die_bad_number(name, value);
Brian Downing0b87b6e2007-07-12 13:32:26[diff] [blame]588 return ret;
589}
590
591unsigned long git_config_ulong(const char *name, const char *value)
592{
593 unsigned long ret;
594 if (!git_parse_ulong(value, &ret))
Jeff King2f666582013-09-08 08:38:22[diff] [blame]595 die_bad_number(name, value);
Brian Downing0b87b6e2007-07-12 13:32:26[diff] [blame]596 return ret;
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]597}
598
Jeff Kingb2be2f62010-11-17 17:00:45[diff] [blame]599static int git_config_maybe_bool_text(const char *name, const char *value)
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]600{
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]601 if (!value)
602 return 1;
603 if (!*value)
604 return 0;
Junio C Hamano8420ccd2010-02-17 07:59:46[diff] [blame]605 if (!strcasecmp(value, "true")
606 || !strcasecmp(value, "yes")
607 || !strcasecmp(value, "on"))
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]608 return 1;
Junio C Hamano8420ccd2010-02-17 07:59:46[diff] [blame]609 if (!strcasecmp(value, "false")
610 || !strcasecmp(value, "no")
611 || !strcasecmp(value, "off"))
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]612 return 0;
Junio C Hamano8420ccd2010-02-17 07:59:46[diff] [blame]613 return -1;
614}
615
Jeff Kingb2be2f62010-11-17 17:00:45[diff] [blame]616int git_config_maybe_bool(const char *name, const char *value)
617{
Jeff King42d194e2013-09-08 08:33:08[diff] [blame]618 int v = git_config_maybe_bool_text(name, value);
Jeff Kingb2be2f62010-11-17 17:00:45[diff] [blame]619 if (0 <= v)
620 return v;
Jeff King42d194e2013-09-08 08:33:08[diff] [blame]621 if (git_parse_int(value, &v))
Jeff Kingdb6195e2010-12-19 03:36:41[diff] [blame]622 return !!v;
Jeff Kingb2be2f62010-11-17 17:00:45[diff] [blame]623 return -1;
624}
625
Junio C Hamano8420ccd2010-02-17 07:59:46[diff] [blame]626int git_config_bool_or_int(const char *name, const char *value, int *is_bool)
627{
Jeff Kingb2be2f62010-11-17 17:00:45[diff] [blame]628 int v = git_config_maybe_bool_text(name, value);
Junio C Hamano8420ccd2010-02-17 07:59:46[diff] [blame]629 if (0 <= v) {
630 *is_bool = 1;
631 return v;
632 }
Junio C Hamanoa53f2ec2008-04-13 01:33:31[diff] [blame]633 *is_bool = 0;
Junio C Hamanoc35b0b52008-04-13 19:11:11[diff] [blame]634 return git_config_int(name, value);
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]635}
636
Junio C Hamanoa53f2ec2008-04-13 01:33:31[diff] [blame]637int git_config_bool(const char *name, const char *value)
638{
639 int discard;
Junio C Hamanoc35b0b52008-04-13 19:11:11[diff] [blame]640 return !!git_config_bool_or_int(name, value, &discard);
Junio C Hamanoa53f2ec2008-04-13 01:33:31[diff] [blame]641}
642
Christian Couderea5105a2008-02-16 05:00:24[diff] [blame]643int git_config_string(const char **dest, const char *var, const char *value)
644{
645 if (!value)
646 return config_error_nonbool(var);
647 *dest = xstrdup(value);
648 return 0;
649}
650
Matthieu Moy395de252009-11-17 17:24:25[diff] [blame]651int git_config_pathname(const char **dest, const char *var, const char *value)
652{
653 if (!value)
654 return config_error_nonbool(var);
655 *dest = expand_user_path(value);
656 if (!*dest)
657 die("Failed to expand user dir in: '%s'", value);
658 return 0;
659}
660
Linus Torvalds806e2ad2008-06-18 21:37:18[diff] [blame]661static int git_default_core_config(const char *var, const char *value)
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]662{
663 /* This needs a better name */
664 if (!strcmp(var, "core.filemode")) {
665 trust_executable_bit = git_config_bool(var, value);
666 return 0;
667 }
Alex Riesen1ce47902008-07-28 06:31:28[diff] [blame]668 if (!strcmp(var, "core.trustctime")) {
669 trust_ctime = git_config_bool(var, value);
670 return 0;
671 }
Junio C Hamanoc1b5d732013-05-07 05:32:58[diff] [blame]672 if (!strcmp(var, "core.checkstat")) {
Robin Rosenbergc08e4d52013-01-22 07:49:22[diff] [blame]673 if (!strcasecmp(value, "default"))
674 check_stat = 1;
675 else if (!strcasecmp(value, "minimal"))
676 check_stat = 0;
677 }
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]678
Junio C Hamano9378c162007-06-24 22:11:24[diff] [blame]679 if (!strcmp(var, "core.quotepath")) {
680 quote_path_fully = git_config_bool(var, value);
681 return 0;
682 }
683
Johannes Sixt78a8d642007-03-02 21:11:30[diff] [blame]684 if (!strcmp(var, "core.symlinks")) {
685 has_symlinks = git_config_bool(var, value);
686 return 0;
687 }
688
Linus Torvalds0a9b88b2008-03-21 23:52:46[diff] [blame]689 if (!strcmp(var, "core.ignorecase")) {
690 ignore_case = git_config_bool(var, value);
691 return 0;
692 }
693
Junio C Hamano64589a02011-10-06 18:22:24[diff] [blame]694 if (!strcmp(var, "core.attributesfile"))
695 return git_config_pathname(&git_attributes_file, var, value);
696
Junio C Hamano7d1864c2007-01-07 10:00:28[diff] [blame]697 if (!strcmp(var, "core.bare")) {
698 is_bare_repository_cfg = git_config_bool(var, value);
699 return 0;
700 }
701
Junio C Hamano5f730762006-02-09 05:15:24[diff] [blame]702 if (!strcmp(var, "core.ignorestat")) {
703 assume_unchanged = git_config_bool(var, value);
704 return 0;
705 }
706
Junio C Hamanoe388c732006-05-02 07:40:24[diff] [blame]707 if (!strcmp(var, "core.prefersymlinkrefs")) {
708 prefer_symlink_refs = git_config_bool(var, value);
Johannes Schindelinf8348be2005-11-15 18:24:19[diff] [blame]709 return 0;
710 }
711
Shawn Pearce6de08ae2006-05-17 09:55:40[diff] [blame]712 if (!strcmp(var, "core.logallrefupdates")) {
713 log_all_ref_updates = git_config_bool(var, value);
714 return 0;
715 }
716
Junio C Hamano2f8acdb2006-03-21 02:45:47[diff] [blame]717 if (!strcmp(var, "core.warnambiguousrefs")) {
718 warn_ambiguous_refs = git_config_bool(var, value);
719 return 0;
720 }
721
Junio C Hamanoa71f09f2011-03-21 05:26:24[diff] [blame]722 if (!strcmp(var, "core.abbrev")) {
Linus Torvaldsdce96482010-10-28 18:28:04[diff] [blame]723 int abbrev = git_config_int(var, value);
724 if (abbrev < minimum_abbrev || abbrev > 40)
725 return -1;
726 default_abbrev = abbrev;
727 return 0;
728 }
729
Dana How960ccca2007-05-09 20:56:50[diff] [blame]730 if (!strcmp(var, "core.loosecompression")) {
Joachim B Haga12f6c302006-07-03 20:11:47[diff] [blame]731 int level = git_config_int(var, value);
732 if (level == -1)
733 level = Z_DEFAULT_COMPRESSION;
734 else if (level < 0 || level > Z_BEST_COMPRESSION)
735 die("bad zlib compression level %d", level);
736 zlib_compression_level = level;
Dana How960ccca2007-05-09 20:56:50[diff] [blame]737 zlib_compression_seen = 1;
738 return 0;
739 }
740
741 if (!strcmp(var, "core.compression")) {
742 int level = git_config_int(var, value);
743 if (level == -1)
744 level = Z_DEFAULT_COMPRESSION;
745 else if (level < 0 || level > Z_BEST_COMPRESSION)
746 die("bad zlib compression level %d", level);
747 core_compression_level = level;
748 core_compression_seen = 1;
749 if (!zlib_compression_seen)
750 zlib_compression_level = level;
Joachim B Haga12f6c302006-07-03 20:11:47[diff] [blame]751 return 0;
752 }
753
Shawn O. Pearce60bb8b12006-12-23 07:34:28[diff] [blame]754 if (!strcmp(var, "core.packedgitwindowsize")) {
Junio C Hamano5faaf242007-02-14 21:20:41[diff] [blame]755 int pgsz_x2 = getpagesize() * 2;
Nick Alcockebaa1bd2011-11-02 15:46:23[diff] [blame]756 packed_git_window_size = git_config_ulong(var, value);
Junio C Hamano5faaf242007-02-14 21:20:41[diff] [blame]757
758 /* This value must be multiple of (pagesize * 2) */
759 packed_git_window_size /= pgsz_x2;
760 if (packed_git_window_size < 1)
761 packed_git_window_size = 1;
762 packed_git_window_size *= pgsz_x2;
Shawn O. Pearce60bb8b12006-12-23 07:34:28[diff] [blame]763 return 0;
764 }
765
Junio C Hamano15366282011-04-05 17:44:11[diff] [blame]766 if (!strcmp(var, "core.bigfilethreshold")) {
Nick Alcockebaa1bd2011-11-02 15:46:23[diff] [blame]767 big_file_threshold = git_config_ulong(var, value);
Junio C Hamano15366282011-04-05 17:44:11[diff] [blame]768 return 0;
769 }
770
Shawn O. Pearce77ccc5b2006-12-23 07:33:35[diff] [blame]771 if (!strcmp(var, "core.packedgitlimit")) {
Nick Alcockebaa1bd2011-11-02 15:46:23[diff] [blame]772 packed_git_limit = git_config_ulong(var, value);
Shawn O. Pearce77ccc5b2006-12-23 07:33:35[diff] [blame]773 return 0;
774 }
775
Shawn O. Pearce18bdec12007-03-19 05:14:37[diff] [blame]776 if (!strcmp(var, "core.deltabasecachelimit")) {
Nick Alcockebaa1bd2011-11-02 15:46:23[diff] [blame]777 delta_base_cache_limit = git_config_ulong(var, value);
Shawn O. Pearce18bdec12007-03-19 05:14:37[diff] [blame]778 return 0;
779 }
780
Linus Torvalds6c510be2007-02-13 19:07:23[diff] [blame]781 if (!strcmp(var, "core.autocrlf")) {
Linus Torvaldsd7f46332007-02-14 02:16:12[diff] [blame]782 if (value && !strcasecmp(value, "input")) {
Junio C Hamanoec70f522011-05-09 19:52:12[diff] [blame]783 if (core_eol == EOL_CRLF)
Eyvind Bernhardsen942e7742010-06-04 19:29:08[diff] [blame]784 return error("core.autocrlf=input conflicts with core.eol=crlf");
Eyvind Bernhardsenfd6cce92010-05-19 20:43:10[diff] [blame]785 auto_crlf = AUTO_CRLF_INPUT;
Linus Torvaldsd7f46332007-02-14 02:16:12[diff] [blame]786 return 0;
787 }
Linus Torvalds6c510be2007-02-13 19:07:23[diff] [blame]788 auto_crlf = git_config_bool(var, value);
789 return 0;
790 }
791
Steffen Prohaska21e5ad52008-02-06 11:25:58[diff] [blame]792 if (!strcmp(var, "core.safecrlf")) {
793 if (value && !strcasecmp(value, "warn")) {
794 safe_crlf = SAFE_CRLF_WARN;
795 return 0;
796 }
797 safe_crlf = git_config_bool(var, value);
798 return 0;
799 }
800
Eyvind Bernhardsen942e7742010-06-04 19:29:08[diff] [blame]801 if (!strcmp(var, "core.eol")) {
802 if (value && !strcasecmp(value, "lf"))
Junio C Hamanoec70f522011-05-09 19:52:12[diff] [blame]803 core_eol = EOL_LF;
Eyvind Bernhardsen942e7742010-06-04 19:29:08[diff] [blame]804 else if (value && !strcasecmp(value, "crlf"))
Junio C Hamanoec70f522011-05-09 19:52:12[diff] [blame]805 core_eol = EOL_CRLF;
Eyvind Bernhardsen942e7742010-06-04 19:29:08[diff] [blame]806 else if (value && !strcasecmp(value, "native"))
Junio C Hamanoec70f522011-05-09 19:52:12[diff] [blame]807 core_eol = EOL_NATIVE;
Eyvind Bernhardsen942e7742010-06-04 19:29:08[diff] [blame]808 else
Junio C Hamanoec70f522011-05-09 19:52:12[diff] [blame]809 core_eol = EOL_UNSET;
810 if (core_eol == EOL_CRLF && auto_crlf == AUTO_CRLF_INPUT)
Eyvind Bernhardsen942e7742010-06-04 19:29:08[diff] [blame]811 return error("core.autocrlf=input conflicts with core.eol=crlf");
812 return 0;
813 }
814
Johannes Schindelina97a7462009-10-09 10:21:57[diff] [blame]815 if (!strcmp(var, "core.notesref")) {
816 notes_ref_name = xstrdup(value);
817 return 0;
818 }
819
Linus Torvalds806e2ad2008-06-18 21:37:18[diff] [blame]820 if (!strcmp(var, "core.pager"))
821 return git_config_string(&pager_program, var, value);
822
823 if (!strcmp(var, "core.editor"))
824 return git_config_string(&editor_program, var, value);
825
Junio C Hamanoeff80a92013-01-16 19:18:48[diff] [blame]826 if (!strcmp(var, "core.commentchar")) {
827 const char *comment;
828 int ret = git_config_string(&comment, var, value);
829 if (!ret)
830 comment_line_char = comment[0];
831 return ret;
832 }
833
Anselm Kruisd3e7da82010-08-30 13:38:38[diff] [blame]834 if (!strcmp(var, "core.askpass"))
835 return git_config_string(&askpass_program, var, value);
836
Linus Torvalds806e2ad2008-06-18 21:37:18[diff] [blame]837 if (!strcmp(var, "core.excludesfile"))
Matthieu Moy395de252009-11-17 17:24:25[diff] [blame]838 return git_config_pathname(&excludes_file, var, value);
Linus Torvalds806e2ad2008-06-18 21:37:18[diff] [blame]839
840 if (!strcmp(var, "core.whitespace")) {
841 if (!value)
842 return config_error_nonbool(var);
843 whitespace_rule_cfg = parse_whitespace_rule(value);
844 return 0;
845 }
846
Linus Torvaldsaafe9fb2008-06-18 22:18:44[diff] [blame]847 if (!strcmp(var, "core.fsyncobjectfiles")) {
848 fsync_object_files = git_config_bool(var, value);
849 return 0;
850 }
851
Linus Torvalds671c9b72008-11-14 00:36:30[diff] [blame]852 if (!strcmp(var, "core.preloadindex")) {
853 core_preload_index = git_config_bool(var, value);
854 return 0;
855 }
856
Johannes Schindelin348df162009-04-27 22:32:25[diff] [blame]857 if (!strcmp(var, "core.createobject")) {
858 if (!strcmp(value, "rename"))
859 object_creation_mode = OBJECT_CREATION_USES_RENAMES;
860 else if (!strcmp(value, "link"))
861 object_creation_mode = OBJECT_CREATION_USES_HARDLINKS;
862 else
863 die("Invalid mode for object creation: %s", value);
Johannes Schindelinbe66a6c2009-04-25 09:57:14[diff] [blame]864 return 0;
865 }
866
Nguyễn Thái Ngọc Duy08aefc92009-08-20 13:47:08[diff] [blame]867 if (!strcmp(var, "core.sparsecheckout")) {
868 core_apply_sparse_checkout = git_config_bool(var, value);
869 return 0;
870 }
871
Torsten Bögershausen76759c72012-07-08 13:50:25[diff] [blame]872 if (!strcmp(var, "core.precomposeunicode")) {
873 precomposed_unicode = git_config_bool(var, value);
874 return 0;
875 }
876
Linus Torvalds806e2ad2008-06-18 21:37:18[diff] [blame]877 /* Add other config variables here and to Documentation/config.txt. */
878 return 0;
879}
880
Linus Torvalds1141f492008-06-18 22:00:11[diff] [blame]881static int git_default_i18n_config(const char *var, const char *value)
Linus Torvaldsd1364522008-06-18 21:40:35[diff] [blame]882{
Christian Couderea5105a2008-02-16 05:00:24[diff] [blame]883 if (!strcmp(var, "i18n.commitencoding"))
884 return git_config_string(&git_commit_encoding, var, value);
Junio C Hamano4e72dce2005-11-28 00:09:40[diff] [blame]885
Christian Couderea5105a2008-02-16 05:00:24[diff] [blame]886 if (!strcmp(var, "i18n.logoutputencoding"))
887 return git_config_string(&git_log_output_encoding, var, value);
Junio C Hamanod2c11a32006-12-28 00:41:33[diff] [blame]888
Linus Torvalds1141f492008-06-18 22:00:11[diff] [blame]889 /* Add other config variables here and to Documentation/config.txt. */
890 return 0;
891}
Matthias Lederhoferaa086eb2006-07-29 22:27:43[diff] [blame]892
Linus Torvalds1141f492008-06-18 22:00:11[diff] [blame]893static int git_default_branch_config(const char *var, const char *value)
894{
Jay Soffian9ed36cf2008-02-19 16:24:37[diff] [blame]895 if (!strcmp(var, "branch.autosetupmerge")) {
896 if (value && !strcasecmp(value, "always")) {
897 git_branch_track = BRANCH_TRACK_ALWAYS;
898 return 0;
899 }
900 git_branch_track = git_config_bool(var, value);
901 return 0;
902 }
Dustin Sallingsc998ae92008-05-10 22:36:29[diff] [blame]903 if (!strcmp(var, "branch.autosetuprebase")) {
904 if (!value)
905 return config_error_nonbool(var);
906 else if (!strcmp(value, "never"))
907 autorebase = AUTOREBASE_NEVER;
908 else if (!strcmp(value, "local"))
909 autorebase = AUTOREBASE_LOCAL;
910 else if (!strcmp(value, "remote"))
911 autorebase = AUTOREBASE_REMOTE;
912 else if (!strcmp(value, "always"))
913 autorebase = AUTOREBASE_ALWAYS;
914 else
915 return error("Malformed value for %s", var);
916 return 0;
917 }
Junio C Hamanoa9cc8572007-11-02 07:24:27[diff] [blame]918
Petr Baudis1ab661d2006-04-24 22:59:33[diff] [blame]919 /* Add other config variables here and to Documentation/config.txt. */
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]920 return 0;
921}
922
Finn Arne Gangstad52153742009-03-16 15:42:51[diff] [blame]923static int git_default_push_config(const char *var, const char *value)
924{
925 if (!strcmp(var, "push.default")) {
926 if (!value)
927 return config_error_nonbool(var);
928 else if (!strcmp(value, "nothing"))
929 push_default = PUSH_DEFAULT_NOTHING;
930 else if (!strcmp(value, "matching"))
931 push_default = PUSH_DEFAULT_MATCHING;
Matthieu Moyb55e67752012-04-24 07:50:03[diff] [blame]932 else if (!strcmp(value, "simple"))
933 push_default = PUSH_DEFAULT_SIMPLE;
Johan Herland53c40312011-02-16 00:54:24[diff] [blame]934 else if (!strcmp(value, "upstream"))
935 push_default = PUSH_DEFAULT_UPSTREAM;
936 else if (!strcmp(value, "tracking")) /* deprecated */
937 push_default = PUSH_DEFAULT_UPSTREAM;
Finn Arne Gangstad52153742009-03-16 15:42:51[diff] [blame]938 else if (!strcmp(value, "current"))
939 push_default = PUSH_DEFAULT_CURRENT;
940 else {
941 error("Malformed value for %s: %s", var, value);
Matthieu Moyb55e67752012-04-24 07:50:03[diff] [blame]942 return error("Must be one of nothing, matching, simple, "
943 "upstream or current.");
Finn Arne Gangstad52153742009-03-16 15:42:51[diff] [blame]944 }
945 return 0;
946 }
947
948 /* Add other config variables here and to Documentation/config.txt. */
949 return 0;
950}
951
Marius Storm-Olsend551a482009-02-08 14:34:27[diff] [blame]952static int git_default_mailmap_config(const char *var, const char *value)
953{
954 if (!strcmp(var, "mailmap.file"))
Øystein Walle9352fd52014-05-27 08:45:58[diff] [blame]955 return git_config_pathname(&git_mailmap_file, var, value);
Jeff King08610902012-12-12 11:04:04[diff] [blame]956 if (!strcmp(var, "mailmap.blob"))
957 return git_config_string(&git_mailmap_blob, var, value);
Marius Storm-Olsend551a482009-02-08 14:34:27[diff] [blame]958
959 /* Add other config variables here and to Documentation/config.txt. */
960 return 0;
961}
962
Linus Torvalds1141f492008-06-18 22:00:11[diff] [blame]963int git_default_config(const char *var, const char *value, void *dummy)
964{
Christian Couder59556542013-11-30 20:55:40[diff] [blame]965 if (starts_with(var, "core."))
Linus Torvalds1141f492008-06-18 22:00:11[diff] [blame]966 return git_default_core_config(var, value);
967
Christian Couder59556542013-11-30 20:55:40[diff] [blame]968 if (starts_with(var, "user."))
Jeff King95979212012-05-21 23:09:54[diff] [blame]969 return git_ident_config(var, value, dummy);
Linus Torvalds1141f492008-06-18 22:00:11[diff] [blame]970
Christian Couder59556542013-11-30 20:55:40[diff] [blame]971 if (starts_with(var, "i18n."))
Linus Torvalds1141f492008-06-18 22:00:11[diff] [blame]972 return git_default_i18n_config(var, value);
973
Christian Couder59556542013-11-30 20:55:40[diff] [blame]974 if (starts_with(var, "branch."))
Linus Torvalds1141f492008-06-18 22:00:11[diff] [blame]975 return git_default_branch_config(var, value);
976
Christian Couder59556542013-11-30 20:55:40[diff] [blame]977 if (starts_with(var, "push."))
Finn Arne Gangstad52153742009-03-16 15:42:51[diff] [blame]978 return git_default_push_config(var, value);
979
Christian Couder59556542013-11-30 20:55:40[diff] [blame]980 if (starts_with(var, "mailmap."))
Marius Storm-Olsend551a482009-02-08 14:34:27[diff] [blame]981 return git_default_mailmap_config(var, value);
982
Christian Couder59556542013-11-30 20:55:40[diff] [blame]983 if (starts_with(var, "advice."))
Jeff King75194432009-09-09 11:38:58[diff] [blame]984 return git_default_advice_config(var, value);
985
Linus Torvalds1141f492008-06-18 22:00:11[diff] [blame]986 if (!strcmp(var, "pager.color") || !strcmp(var, "color.pager")) {
987 pager_use_color = git_config_bool(var,value);
988 return 0;
989 }
990
Junio C Hamano568508e2011-10-28 21:48:40[diff] [blame]991 if (!strcmp(var, "pack.packsizelimit")) {
992 pack_size_limit_cfg = git_config_ulong(var, value);
993 return 0;
994 }
Linus Torvalds1141f492008-06-18 22:00:11[diff] [blame]995 /* Add other config variables here and to Documentation/config.txt. */
996 return 0;
997}
998
Heiko Voigtca4b5de2013-05-11 13:18:52[diff] [blame]999/*
Heiko Voigtb2dc0942013-07-11 22:48:30[diff] [blame]1000 * All source specific fields in the union, die_on_error, name and the callbacks
Heiko Voigt4d8dd142013-07-11 22:44:39[diff] [blame]1001 * fgetc, ungetc, ftell of top need to be initialized before calling
Heiko Voigtca4b5de2013-05-11 13:18:52[diff] [blame]1002 * this function.
1003 */
Heiko Voigt4d8dd142013-07-11 22:44:39[diff] [blame]1004static int do_config_from(struct config_source *top, config_fn_t fn, void *data)
Heiko Voigtca4b5de2013-05-11 13:18:52[diff] [blame]1005{
1006 int ret;
1007
1008 /* push config-file parsing state stack */
1009 top->prev = cf;
1010 top->linenr = 1;
1011 top->eof = 0;
1012 strbuf_init(&top->value, 1024);
1013 strbuf_init(&top->var, 1024);
1014 cf = top;
1015
Heiko Voigt4d8dd142013-07-11 22:44:39[diff] [blame]1016 ret = git_parse_source(fn, data);
Heiko Voigtca4b5de2013-05-11 13:18:52[diff] [blame]1017
1018 /* pop config-file parsing state stack */
1019 strbuf_release(&top->value);
1020 strbuf_release(&top->var);
1021 cf = top->prev;
1022
1023 return ret;
1024}
1025
Kirill A. Shutemov3caec732014-02-18 22:58:55[diff] [blame]1026static int do_config_from_file(config_fn_t fn,
1027 const char *name, const char *path, FILE *f, void *data)
1028{
1029 struct config_source top;
1030
1031 top.u.file = f;
1032 top.name = name;
1033 top.path = path;
1034 top.die_on_error = 1;
1035 top.do_fgetc = config_file_fgetc;
1036 top.do_ungetc = config_file_ungetc;
1037 top.do_ftell = config_file_ftell;
1038
1039 return do_config_from(&top, fn, data);
1040}
1041
1042static int git_config_from_stdin(config_fn_t fn, void *data)
1043{
1044 return do_config_from_file(fn, "<stdin>", NULL, stdin, data);
1045}
1046
Johannes Schindelinef90d6d2008-05-14 17:46:53[diff] [blame]1047int git_config_from_file(config_fn_t fn, const char *filename, void *data)
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]1048{
Kirill A. Shutemov3caec732014-02-18 22:58:55[diff] [blame]1049 int ret = -1;
1050 FILE *f;
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]1051
Kirill A. Shutemov3caec732014-02-18 22:58:55[diff] [blame]1052 f = fopen(filename, "r");
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]1053 if (f) {
Kirill A. Shutemov3caec732014-02-18 22:58:55[diff] [blame]1054 ret = do_config_from_file(fn, filename, filename, f, data);
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]1055 fclose(f);
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]1056 }
1057 return ret;
1058}
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1059
Heiko Voigt1bc88812013-07-11 22:46:47[diff] [blame]1060int git_config_from_buf(config_fn_t fn, const char *name, const char *buf,
1061 size_t len, void *data)
1062{
1063 struct config_source top;
1064
1065 top.u.buf.buf = buf;
1066 top.u.buf.len = len;
1067 top.u.buf.pos = 0;
1068 top.name = name;
Jeff Kingd14d4242014-02-18 22:58:52[diff] [blame]1069 top.path = NULL;
Heiko Voigtb2dc0942013-07-11 22:48:30[diff] [blame]1070 top.die_on_error = 0;
Jeff King49d6cfa2013-08-26 21:57:18[diff] [blame]1071 top.do_fgetc = config_buf_fgetc;
1072 top.do_ungetc = config_buf_ungetc;
1073 top.do_ftell = config_buf_ftell;
Heiko Voigt1bc88812013-07-11 22:46:47[diff] [blame]1074
1075 return do_config_from(&top, fn, data);
1076}
1077
1078static int git_config_from_blob_sha1(config_fn_t fn,
1079 const char *name,
1080 const unsigned char *sha1,
1081 void *data)
1082{
1083 enum object_type type;
1084 char *buf;
1085 unsigned long size;
1086 int ret;
1087
1088 buf = read_sha1_file(sha1, &type, &size);
1089 if (!buf)
1090 return error("unable to load config blob object '%s'", name);
1091 if (type != OBJ_BLOB) {
1092 free(buf);
1093 return error("reference '%s' does not point to a blob", name);
1094 }
1095
1096 ret = git_config_from_buf(fn, name, buf, size, data);
1097 free(buf);
1098
1099 return ret;
1100}
1101
1102static int git_config_from_blob_ref(config_fn_t fn,
1103 const char *name,
1104 void *data)
1105{
1106 unsigned char sha1[20];
1107
1108 if (get_sha1(name, sha1) < 0)
1109 return error("unable to resolve config blob '%s'", name);
1110 return git_config_from_blob_sha1(fn, name, sha1, data);
1111}
1112
Johannes Sixt506b17b2007-11-13 20:05:05[diff] [blame]1113const char *git_etc_gitconfig(void)
1114{
Johannes Sixt7f0e39f2007-11-13 20:05:06[diff] [blame]1115 static const char *system_wide;
Steffen Prohaska2de9de52008-07-13 20:31:18[diff] [blame]1116 if (!system_wide)
1117 system_wide = system_path(ETC_GITCONFIG);
Johannes Sixt7f0e39f2007-11-13 20:05:06[diff] [blame]1118 return system_wide;
Johannes Sixt506b17b2007-11-13 20:05:05[diff] [blame]1119}
1120
Lars R. Damerow0ef37162010-03-17 19:55:51[diff] [blame]1121int git_env_bool(const char *k, int def)
Jeff Kingab88c362008-02-06 10:11:18[diff] [blame]1122{
1123 const char *v = getenv(k);
1124 return v ? git_config_bool(k, v) : def;
1125}
1126
1127int git_config_system(void)
1128{
1129 return !git_env_bool("GIT_CONFIG_NOSYSTEM", 0);
1130}
1131
Nguyễn Thái Ngọc Duydbdf5852010-11-26 15:32:33[diff] [blame]1132int git_config_early(config_fn_t fn, void *data, const char *repo_config)
Junio C Hamano4f629532005-11-26 00:03:56[diff] [blame]1133{
Felipe Contrerasaa387402009-02-21 00:48:55[diff] [blame]1134 int ret = 0, found = 0;
Huynh Khoi Nguyen Nguyen21cf3222012-06-22 09:03:23[diff] [blame]1135 char *xdg_config = NULL;
1136 char *user_config = NULL;
1137
1138 home_config_paths(&user_config, &xdg_config, "config");
Johannes Schindelin5f1a63e2006-06-19 23:48:03[diff] [blame]1139
Jonathan Nieder4698c8f2013-04-12 21:03:18[diff] [blame]1140 if (git_config_system() && !access_or_die(git_etc_gitconfig(), R_OK, 0)) {
Daniel Barkalowdc871832008-06-30 07:37:47[diff] [blame]1141 ret += git_config_from_file(fn, git_etc_gitconfig(),
1142 data);
Felipe Contrerasaa387402009-02-21 00:48:55[diff] [blame]1143 found += 1;
1144 }
Johannes Schindelin5f1a63e2006-06-19 23:48:03[diff] [blame]1145
Jonathan Nieder4698c8f2013-04-12 21:03:18[diff] [blame]1146 if (xdg_config && !access_or_die(xdg_config, R_OK, ACCESS_EACCES_OK)) {
Huynh Khoi Nguyen Nguyen21cf3222012-06-22 09:03:23[diff] [blame]1147 ret += git_config_from_file(fn, xdg_config, data);
1148 found += 1;
1149 }
1150
Jonathan Nieder4698c8f2013-04-12 21:03:18[diff] [blame]1151 if (user_config && !access_or_die(user_config, R_OK, ACCESS_EACCES_OK)) {
Huynh Khoi Nguyen Nguyen21cf3222012-06-22 09:03:23[diff] [blame]1152 ret += git_config_from_file(fn, user_config, data);
1153 found += 1;
Johannes Schindelin5f1a63e2006-06-19 23:48:03[diff] [blame]1154 }
1155
Jonathan Nieder4698c8f2013-04-12 21:03:18[diff] [blame]1156 if (repo_config && !access_or_die(repo_config, R_OK, 0)) {
Felipe Contrerasaa387402009-02-21 00:48:55[diff] [blame]1157 ret += git_config_from_file(fn, repo_config, data);
1158 found += 1;
1159 }
Alex Riesen8b1fa772010-03-26 22:53:57[diff] [blame]1160
Jeff King5a0c9ee2011-05-24 22:49:45[diff] [blame]1161 switch (git_config_from_parameters(fn, data)) {
1162 case -1: /* error */
Jeff King1c2c9be2011-06-09 15:52:32[diff] [blame]1163 die("unable to parse command-line config");
Jeff King5a0c9ee2011-05-24 22:49:45[diff] [blame]1164 break;
1165 case 0: /* found nothing */
1166 break;
1167 default: /* found at least one item */
1168 found++;
1169 break;
1170 }
Alex Riesen8b1fa772010-03-26 22:53:57[diff] [blame]1171
Huynh Khoi Nguyen Nguyen21cf3222012-06-22 09:03:23[diff] [blame]1172 free(xdg_config);
1173 free(user_config);
Jeff King1f2baa72010-10-21 14:45:44[diff] [blame]1174 return ret == 0 ? found : ret;
Junio C Hamano4f629532005-11-26 00:03:56[diff] [blame]1175}
1176
Jeff Kingc9b5e2a2012-02-16 08:05:56[diff] [blame]1177int git_config_with_options(config_fn_t fn, void *data,
Kirill A. Shutemovc8985ce2014-02-18 22:58:54[diff] [blame]1178 struct git_config_source *config_source,
Heiko Voigt1bc88812013-07-11 22:46:47[diff] [blame]1179 int respect_includes)
Nguyễn Thái Ngọc Duydbdf5852010-11-26 15:32:33[diff] [blame]1180{
1181 char *repo_config = NULL;
1182 int ret;
Jeff King9b25a0b2012-02-06 09:54:04[diff] [blame]1183 struct config_include_data inc = CONFIG_INCLUDE_INIT;
1184
1185 if (respect_includes) {
1186 inc.fn = fn;
1187 inc.data = data;
1188 fn = git_config_include;
1189 data = &inc;
1190 }
Nguyễn Thái Ngọc Duydbdf5852010-11-26 15:32:33[diff] [blame]1191
Jeff Kingc9b5e2a2012-02-16 08:05:56[diff] [blame]1192 /*
1193 * If we have a specific filename, use it. Otherwise, follow the
1194 * regular lookup sequence.
1195 */
Kirill A. Shutemov3caec732014-02-18 22:58:55[diff] [blame]1196 if (config_source && config_source->use_stdin)
1197 return git_config_from_stdin(fn, data);
1198 else if (config_source && config_source->file)
Kirill A. Shutemovc8985ce2014-02-18 22:58:54[diff] [blame]1199 return git_config_from_file(fn, config_source->file, data);
1200 else if (config_source && config_source->blob)
1201 return git_config_from_blob_ref(fn, config_source->blob, data);
Jeff Kingc9b5e2a2012-02-16 08:05:56[diff] [blame]1202
Nguyễn Thái Ngọc Duydbdf5852010-11-26 15:32:33[diff] [blame]1203 repo_config = git_pathdup("config");
1204 ret = git_config_early(fn, data, repo_config);
1205 if (repo_config)
1206 free(repo_config);
1207 return ret;
1208}
1209
Jeff Kingc9b5e2a2012-02-16 08:05:56[diff] [blame]1210int git_config(config_fn_t fn, void *data)
1211{
Kirill A. Shutemovc8985ce2014-02-18 22:58:54[diff] [blame]1212 return git_config_with_options(fn, data, NULL, 1);
Jeff Kingc9b5e2a2012-02-16 08:05:56[diff] [blame]1213}
1214
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1215/*
1216 * Find all the stuff for git_config_set() below.
1217 */
Johannes Schindelin4ddba792005-11-20 05:52:22[diff] [blame]1218
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1219static struct {
1220 int baselen;
Felipe Contreras4b25d092009-05-01 09:06:36[diff] [blame]1221 char *key;
Johannes Schindelinf98d8632005-11-20 12:24:18[diff] [blame]1222 int do_not_match;
Felipe Contreras4b25d092009-05-01 09:06:36[diff] [blame]1223 regex_t *value_regex;
Johannes Schindelin4ddba792005-11-20 05:52:22[diff] [blame]1224 int multi_replace;
Thomas Rast83786fa2013-11-13 10:19:00[diff] [blame]1225 size_t *offset;
1226 unsigned int offset_alloc;
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1227 enum { START, SECTION_SEEN, SECTION_END_SEEN, KEY_SEEN } state;
1228 int seen;
1229} store;
1230
Felipe Contreras4b25d092009-05-01 09:06:36[diff] [blame]1231static int matches(const char *key, const char *value)
Johannes Schindelinf98d8632005-11-20 12:24:18[diff] [blame]1232{
1233 return !strcmp(key, store.key) &&
1234 (store.value_regex == NULL ||
1235 (store.do_not_match ^
1236 !regexec(store.value_regex, value, 0, NULL, 0)));
1237}
1238
Felipe Contreras4b25d092009-05-01 09:06:36[diff] [blame]1239static int store_aux(const char *key, const char *value, void *cb)
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1240{
Junio C Hamanoae9ee412007-05-13 04:49:33[diff] [blame]1241 const char *ep;
1242 size_t section_len;
Junio C Hamanoae9ee412007-05-13 04:49:33[diff] [blame]1243
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1244 switch (store.state) {
1245 case KEY_SEEN:
Johannes Schindelinf98d8632005-11-20 12:24:18[diff] [blame]1246 if (matches(key, value)) {
Johannes Schindelin4ddba792005-11-20 05:52:22[diff] [blame]1247 if (store.seen == 1 && store.multi_replace == 0) {
Alex Riesen64c0d712008-05-12 21:41:04[diff] [blame]1248 warning("%s has multiple values", key);
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1249 }
Johannes Schindelin4ddba792005-11-20 05:52:22[diff] [blame]1250
Thomas Rast83786fa2013-11-13 10:19:00[diff] [blame]1251 ALLOC_GROW(store.offset, store.seen + 1,
1252 store.offset_alloc);
1253
Jeff King49d6cfa2013-08-26 21:57:18[diff] [blame]1254 store.offset[store.seen] = cf->do_ftell(cf);
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1255 store.seen++;
1256 }
1257 break;
1258 case SECTION_SEEN:
Junio C Hamanoae9ee412007-05-13 04:49:33[diff] [blame]1259 /*
1260 * What we are looking for is in store.key (both
1261 * section and var), and its section part is baselen
1262 * long. We found key (again, both section and var).
1263 * We would want to know if this key is in the same
1264 * section as what we are looking for. We already
1265 * know we are in the same section as what should
1266 * hold store.key.
1267 */
1268 ep = strrchr(key, '.');
1269 section_len = ep - key;
1270
1271 if ((section_len != store.baselen) ||
1272 memcmp(key, store.key, section_len+1)) {
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1273 store.state = SECTION_END_SEEN;
1274 break;
Junio C Hamanoae9ee412007-05-13 04:49:33[diff] [blame]1275 }
1276
1277 /*
1278 * Do not increment matches: this is no match, but we
1279 * just made sure we are in the desired section.
1280 */
Thomas Rast83786fa2013-11-13 10:19:00[diff] [blame]1281 ALLOC_GROW(store.offset, store.seen + 1,
1282 store.offset_alloc);
Jeff King49d6cfa2013-08-26 21:57:18[diff] [blame]1283 store.offset[store.seen] = cf->do_ftell(cf);
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1284 /* fallthru */
1285 case SECTION_END_SEEN:
1286 case START:
Johannes Schindelinf98d8632005-11-20 12:24:18[diff] [blame]1287 if (matches(key, value)) {
Thomas Rast83786fa2013-11-13 10:19:00[diff] [blame]1288 ALLOC_GROW(store.offset, store.seen + 1,
1289 store.offset_alloc);
Jeff King49d6cfa2013-08-26 21:57:18[diff] [blame]1290 store.offset[store.seen] = cf->do_ftell(cf);
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1291 store.state = KEY_SEEN;
1292 store.seen++;
Linus Torvaldsd14f7762006-05-09 19:24:02[diff] [blame]1293 } else {
1294 if (strrchr(key, '.') - key == store.baselen &&
seanbdf0ef02006-05-06 18:14:02[diff] [blame]1295 !strncmp(key, store.key, store.baselen)) {
sean93ddef32006-05-05 13:49:15[diff] [blame]1296 store.state = SECTION_SEEN;
Thomas Rast83786fa2013-11-13 10:19:00[diff] [blame]1297 ALLOC_GROW(store.offset,
1298 store.seen + 1,
1299 store.offset_alloc);
Jeff King49d6cfa2013-08-26 21:57:18[diff] [blame]1300 store.offset[store.seen] = cf->do_ftell(cf);
Linus Torvaldsd14f7762006-05-09 19:24:02[diff] [blame]1301 }
seanbdf0ef02006-05-06 18:14:02[diff] [blame]1302 }
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1303 }
1304 return 0;
1305}
1306
Alex Riesen64c0d712008-05-12 21:41:04[diff] [blame]1307static int write_error(const char *filename)
Andy Whitcroft480c9e52007-01-08 15:58:38[diff] [blame]1308{
Alex Riesen64c0d712008-05-12 21:41:04[diff] [blame]1309 error("failed to write new configuration file %s", filename);
Andy Whitcroft480c9e52007-01-08 15:58:38[diff] [blame]1310
1311 /* Same error code as "failed to rename". */
1312 return 4;
1313}
1314
Felipe Contreras4b25d092009-05-01 09:06:36[diff] [blame]1315static int store_write_section(int fd, const char *key)
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1316{
Kristian Høgsbergcb891a52007-12-14 20:59:58[diff] [blame]1317 const char *dot;
1318 int i, success;
Brandon Caseyf285a2d2008-10-09 19:12:12[diff] [blame]1319 struct strbuf sb = STRBUF_INIT;
Linus Torvaldsd14f7762006-05-09 19:24:02[diff] [blame]1320
Kristian Høgsbergcb891a52007-12-14 20:59:58[diff] [blame]1321 dot = memchr(key, '.', store.baselen);
Linus Torvaldsd14f7762006-05-09 19:24:02[diff] [blame]1322 if (dot) {
Kristian Høgsbergcb891a52007-12-14 20:59:58[diff] [blame]1323 strbuf_addf(&sb, "[%.*s \"", (int)(dot - key), key);
1324 for (i = dot - key + 1; i < store.baselen; i++) {
Bryan Donlane5c349b2008-05-04 05:37:52[diff] [blame]1325 if (key[i] == '"' || key[i] == '\\')
Kristian Høgsbergcb891a52007-12-14 20:59:58[diff] [blame]1326 strbuf_addch(&sb, '\\');
1327 strbuf_addch(&sb, key[i]);
Linus Torvaldsd14f7762006-05-09 19:24:02[diff] [blame]1328 }
Kristian Høgsbergcb891a52007-12-14 20:59:58[diff] [blame]1329 strbuf_addstr(&sb, "\"]\n");
1330 } else {
1331 strbuf_addf(&sb, "[%.*s]\n", store.baselen, key);
Linus Torvaldsd14f7762006-05-09 19:24:02[diff] [blame]1332 }
1333
Kristian Høgsbergcb891a52007-12-14 20:59:58[diff] [blame]1334 success = write_in_full(fd, sb.buf, sb.len) == sb.len;
1335 strbuf_release(&sb);
Andy Whitcroft480c9e52007-01-08 15:58:38[diff] [blame]1336
Kristian Høgsbergcb891a52007-12-14 20:59:58[diff] [blame]1337 return success;
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1338}
1339
Felipe Contreras4b25d092009-05-01 09:06:36[diff] [blame]1340static int store_write_pair(int fd, const char *key, const char *value)
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1341{
Kristian Høgsbergcb891a52007-12-14 20:59:58[diff] [blame]1342 int i, success;
1343 int length = strlen(key + store.baselen + 1);
1344 const char *quote = "";
Brandon Caseyf285a2d2008-10-09 19:12:12[diff] [blame]1345 struct strbuf sb = STRBUF_INIT;
Brian Gernhardtcdd4fb12007-01-09 05:27:41[diff] [blame]1346
Jim Meyering6281f392007-12-08 15:48:05[diff] [blame]1347 /*
1348 * Check to see if the value needs to be surrounded with a dq pair.
1349 * Note that problematic characters are always backslash-quoted; this
1350 * check is about not losing leading or trailing SP and strings that
1351 * follow beginning-of-comment characters (i.e. ';' and '#') by the
1352 * configuration parser.
1353 */
Brian Gernhardtcdd4fb12007-01-09 05:27:41[diff] [blame]1354 if (value[0] == ' ')
Kristian Høgsbergcb891a52007-12-14 20:59:58[diff] [blame]1355 quote = "\"";
Brian Gernhardtcdd4fb12007-01-09 05:27:41[diff] [blame]1356 for (i = 0; value[i]; i++)
1357 if (value[i] == ';' || value[i] == '#')
Kristian Høgsbergcb891a52007-12-14 20:59:58[diff] [blame]1358 quote = "\"";
1359 if (i && value[i - 1] == ' ')
1360 quote = "\"";
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1361
Kristian Høgsbergcb891a52007-12-14 20:59:58[diff] [blame]1362 strbuf_addf(&sb, "\t%.*s = %s",
1363 length, key + store.baselen + 1, quote);
1364
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1365 for (i = 0; value[i]; i++)
1366 switch (value[i]) {
Andy Whitcroft480c9e52007-01-08 15:58:38[diff] [blame]1367 case '\n':
Kristian Høgsbergcb891a52007-12-14 20:59:58[diff] [blame]1368 strbuf_addstr(&sb, "\\n");
Andy Whitcroft480c9e52007-01-08 15:58:38[diff] [blame]1369 break;
1370 case '\t':
Kristian Høgsbergcb891a52007-12-14 20:59:58[diff] [blame]1371 strbuf_addstr(&sb, "\\t");
Andy Whitcroft480c9e52007-01-08 15:58:38[diff] [blame]1372 break;
1373 case '"':
1374 case '\\':
Kristian Høgsbergcb891a52007-12-14 20:59:58[diff] [blame]1375 strbuf_addch(&sb, '\\');
Andy Whitcroft480c9e52007-01-08 15:58:38[diff] [blame]1376 default:
Kristian Høgsbergcb891a52007-12-14 20:59:58[diff] [blame]1377 strbuf_addch(&sb, value[i]);
Andy Whitcroft480c9e52007-01-08 15:58:38[diff] [blame]1378 break;
1379 }
Kristian Høgsbergcb891a52007-12-14 20:59:58[diff] [blame]1380 strbuf_addf(&sb, "%s\n", quote);
1381
1382 success = write_in_full(fd, sb.buf, sb.len) == sb.len;
1383 strbuf_release(&sb);
1384
1385 return success;
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1386}
1387
Felipe Contreras4b25d092009-05-01 09:06:36[diff] [blame]1388static ssize_t find_beginning_of_line(const char *contents, size_t size,
1389 size_t offset_, int *found_bracket)
Johannes Schindelin4ddba792005-11-20 05:52:22[diff] [blame]1390{
Shawn O. Pearcedc49cd72007-03-07 01:44:37[diff] [blame]1391 size_t equal_offset = size, bracket_offset = size;
1392 ssize_t offset;
Johannes Schindelin4ddba792005-11-20 05:52:22[diff] [blame]1393
Frank Lichtenheld7a31cc02008-02-11 00:23:03[diff] [blame]1394contline:
Junio C Hamanoa6080a02007-06-07 07:04:01[diff] [blame]1395 for (offset = offset_-2; offset > 0
Johannes Schindelin4ddba792005-11-20 05:52:22[diff] [blame]1396 && contents[offset] != '\n'; offset--)
1397 switch (contents[offset]) {
1398 case '=': equal_offset = offset; break;
1399 case ']': bracket_offset = offset; break;
1400 }
Frank Lichtenheld7a31cc02008-02-11 00:23:03[diff] [blame]1401 if (offset > 0 && contents[offset-1] == '\\') {
1402 offset_ = offset;
1403 goto contline;
1404 }
Johannes Schindelin4ddba792005-11-20 05:52:22[diff] [blame]1405 if (bracket_offset < equal_offset) {
1406 *found_bracket = 1;
1407 offset = bracket_offset+1;
1408 } else
1409 offset++;
1410
1411 return offset;
1412}
1413
Ramkumar Ramachandra5ec31182011-08-04 10:39:00[diff] [blame]1414int git_config_set_in_file(const char *config_filename,
1415 const char *key, const char *value)
1416{
1417 return git_config_set_multivar_in_file(config_filename, key, value, NULL, 0);
1418}
1419
Felipe Contreras4b25d092009-05-01 09:06:36[diff] [blame]1420int git_config_set(const char *key, const char *value)
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1421{
Johannes Schindelin4ddba792005-11-20 05:52:22[diff] [blame]1422 return git_config_set_multivar(key, value, NULL, 0);
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1423}
1424
1425/*
Libor Pechacekb09c53a2011-01-30 19:40:41[diff] [blame]1426 * Auxiliary function to sanity-check and split the key into the section
1427 * identifier and variable name.
1428 *
1429 * Returns 0 on success, -1 when there is an invalid character in the key and
1430 * -2 if there is no section name in the key.
1431 *
1432 * store_key - pointer to char* which will hold a copy of the key with
1433 * lowercase section and variable name
1434 * baselen - pointer to int which will hold the length of the
1435 * section + subsection part, can be NULL
1436 */
1437int git_config_parse_key(const char *key, char **store_key, int *baselen_)
1438{
1439 int i, dot, baselen;
1440 const char *last_dot = strrchr(key, '.');
1441
1442 /*
1443 * Since "key" actually contains the section name and the real
1444 * key name separated by a dot, we have to know where the dot is.
1445 */
1446
Libor Pechacek2169ddc2011-02-01 07:13:47[diff] [blame]1447 if (last_dot == NULL || last_dot == key) {
Libor Pechacekb09c53a2011-01-30 19:40:41[diff] [blame]1448 error("key does not contain a section: %s", key);
Michael J Gruber7a397412011-05-17 15:38:52[diff] [blame]1449 return -CONFIG_NO_SECTION_OR_NAME;
Libor Pechacekb09c53a2011-01-30 19:40:41[diff] [blame]1450 }
1451
Libor Pechacek2169ddc2011-02-01 07:13:47[diff] [blame]1452 if (!last_dot[1]) {
1453 error("key does not contain variable name: %s", key);
Michael J Gruber7a397412011-05-17 15:38:52[diff] [blame]1454 return -CONFIG_NO_SECTION_OR_NAME;
Libor Pechacek2169ddc2011-02-01 07:13:47[diff] [blame]1455 }
1456
Libor Pechacekb09c53a2011-01-30 19:40:41[diff] [blame]1457 baselen = last_dot - key;
1458 if (baselen_)
1459 *baselen_ = baselen;
1460
1461 /*
1462 * Validate the key and while at it, lower case it for matching.
1463 */
1464 *store_key = xmalloc(strlen(key) + 1);
1465
1466 dot = 0;
1467 for (i = 0; key[i]; i++) {
1468 unsigned char c = key[i];
1469 if (c == '.')
1470 dot = 1;
1471 /* Leave the extended basename untouched.. */
1472 if (!dot || i > baselen) {
1473 if (!iskeychar(c) ||
1474 (i == baselen + 1 && !isalpha(c))) {
1475 error("invalid key: %s", key);
1476 goto out_free_ret_1;
1477 }
1478 c = tolower(c);
1479 } else if (c == '\n') {
1480 error("invalid key (newline): %s", key);
1481 goto out_free_ret_1;
1482 }
1483 (*store_key)[i] = c;
1484 }
1485 (*store_key)[i] = 0;
1486
1487 return 0;
1488
1489out_free_ret_1:
1490 free(*store_key);
Jeff King97ed50f2012-10-23 19:40:06[diff] [blame]1491 *store_key = NULL;
Michael J Gruber7a397412011-05-17 15:38:52[diff] [blame]1492 return -CONFIG_INVALID_KEY;
Libor Pechacekb09c53a2011-01-30 19:40:41[diff] [blame]1493}
1494
1495/*
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1496 * If value==NULL, unset in (remove from) config,
1497 * if value_regex!=NULL, disregard key/value pairs where value does not match.
Johannes Schindelin4ddba792005-11-20 05:52:22[diff] [blame]1498 * if multi_replace==0, nothing, or only one matching key/value is replaced,
1499 * else all matching key/values (regardless how many) are removed,
1500 * before the new pair is written.
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1501 *
1502 * Returns 0 on success.
1503 *
1504 * This function does this:
1505 *
1506 * - it locks the config file by creating ".git/config.lock"
1507 *
1508 * - it then parses the config using store_aux() as validator to find
1509 * the position on the key/value pair to replace. If it is to be unset,
1510 * it must be found exactly once.
1511 *
1512 * - the config file is mmap()ed and the part before the match (if any) is
1513 * written to the lock file, then the changed part and the rest.
1514 *
1515 * - the config file is removed and the lock file rename()d to it.
1516 *
1517 */
Ramkumar Ramachandra5ec31182011-08-04 10:39:00[diff] [blame]1518int git_config_set_multivar_in_file(const char *config_filename,
1519 const char *key, const char *value,
1520 const char *value_regex, int multi_replace)
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1521{
Junio C Hamanof8ba6552006-05-08 04:27:30[diff] [blame]1522 int fd = -1, in_fd;
Serge E. Hallyndafc88b2006-04-17 15:14:48[diff] [blame]1523 int ret;
Bradford C. Smith6cbf9732007-07-26 16:55:28[diff] [blame]1524 struct lock_file *lock = NULL;
Jeff King0a5f5752012-02-16 08:04:05[diff] [blame]1525 char *filename_buf = NULL;
Johannes Schindelin4ddba792005-11-20 05:52:22[diff] [blame]1526
Libor Pechacekb09c53a2011-01-30 19:40:41[diff] [blame]1527 /* parse-key returns negative; flip the sign to feed exit(3) */
1528 ret = 0 - git_config_parse_key(key, &store.key, &store.baselen);
1529 if (ret)
Serge E. Hallyndafc88b2006-04-17 15:14:48[diff] [blame]1530 goto out_free;
Johannes Schindelinb17e6592005-11-20 20:22:19[diff] [blame]1531
1532 store.multi_replace = multi_replace;
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1533
Jeff King0a5f5752012-02-16 08:04:05[diff] [blame]1534 if (!config_filename)
1535 config_filename = filename_buf = git_pathdup("config");
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1536
1537 /*
Bradford C. Smith6cbf9732007-07-26 16:55:28[diff] [blame]1538 * The lock serves a purpose in addition to locking: the new
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1539 * contents of .git/config will be written into it.
1540 */
Brian Gesiakf1064f62014-05-26 15:33:46[diff] [blame]1541 lock = xcalloc(1, sizeof(struct lock_file));
Bradford C. Smith6cbf9732007-07-26 16:55:28[diff] [blame]1542 fd = hold_lock_file_for_update(lock, config_filename, 0);
1543 if (fd < 0) {
Alex Riesen6ffd5672009-04-29 21:27:54[diff] [blame]1544 error("could not lock config file %s: %s", config_filename, strerror(errno));
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1545 free(store.key);
Michael J Gruber7a397412011-05-17 15:38:52[diff] [blame]1546 ret = CONFIG_NO_LOCK;
Serge E. Hallyndafc88b2006-04-17 15:14:48[diff] [blame]1547 goto out_free;
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1548 }
1549
1550 /*
1551 * If .git/config does not exist yet, write a minimal version.
1552 */
Alex Riesen88fb9582006-01-05 11:43:34[diff] [blame]1553 in_fd = open(config_filename, O_RDONLY);
1554 if ( in_fd < 0 ) {
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1555 free(store.key);
1556
Alex Riesen88fb9582006-01-05 11:43:34[diff] [blame]1557 if ( ENOENT != errno ) {
1558 error("opening %s: %s", config_filename,
1559 strerror(errno));
Michael J Gruber7a397412011-05-17 15:38:52[diff] [blame]1560 ret = CONFIG_INVALID_FILE; /* same as "invalid config file" */
Serge E. Hallyndafc88b2006-04-17 15:14:48[diff] [blame]1561 goto out_free;
Alex Riesen88fb9582006-01-05 11:43:34[diff] [blame]1562 }
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1563 /* if nothing to unset, error out */
1564 if (value == NULL) {
Michael J Gruber7a397412011-05-17 15:38:52[diff] [blame]1565 ret = CONFIG_NOTHING_SET;
Serge E. Hallyndafc88b2006-04-17 15:14:48[diff] [blame]1566 goto out_free;
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1567 }
1568
Felipe Contreras4b25d092009-05-01 09:06:36[diff] [blame]1569 store.key = (char *)key;
Andy Whitcroft480c9e52007-01-08 15:58:38[diff] [blame]1570 if (!store_write_section(fd, key) ||
Junio C Hamano93c1e072007-01-11 21:16:26[diff] [blame]1571 !store_write_pair(fd, key, value))
1572 goto write_err_out;
1573 } else {
Alex Riesen88fb9582006-01-05 11:43:34[diff] [blame]1574 struct stat st;
Felipe Contreras4b25d092009-05-01 09:06:36[diff] [blame]1575 char *contents;
Shawn O. Pearcedc49cd72007-03-07 01:44:37[diff] [blame]1576 size_t contents_sz, copy_begin, copy_end;
1577 int i, new_line = 0;
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1578
1579 if (value_regex == NULL)
1580 store.value_regex = NULL;
1581 else {
Johannes Schindelinf98d8632005-11-20 12:24:18[diff] [blame]1582 if (value_regex[0] == '!') {
1583 store.do_not_match = 1;
1584 value_regex++;
1585 } else
1586 store.do_not_match = 0;
1587
Jonas Fonseca2d7320d2006-08-31 22:32:39[diff] [blame]1588 store.value_regex = (regex_t*)xmalloc(sizeof(regex_t));
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1589 if (regcomp(store.value_regex, value_regex,
1590 REG_EXTENDED)) {
Alex Riesen64c0d712008-05-12 21:41:04[diff] [blame]1591 error("invalid pattern: %s", value_regex);
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1592 free(store.value_regex);
Michael J Gruber7a397412011-05-17 15:38:52[diff] [blame]1593 ret = CONFIG_INVALID_PATTERN;
Serge E. Hallyndafc88b2006-04-17 15:14:48[diff] [blame]1594 goto out_free;
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1595 }
1596 }
1597
Thomas Rast83786fa2013-11-13 10:19:00[diff] [blame]1598 ALLOC_GROW(store.offset, 1, store.offset_alloc);
Johannes Schindelin4ddba792005-11-20 05:52:22[diff] [blame]1599 store.offset[0] = 0;
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1600 store.state = START;
1601 store.seen = 0;
1602
1603 /*
1604 * After this, store.offset will contain the *end* offset
1605 * of the last match, or remain at 0 if no match was found.
1606 * As a side effect, we make sure to transform only a valid
1607 * existing config file.
1608 */
Johannes Schindelinef90d6d2008-05-14 17:46:53[diff] [blame]1609 if (git_config_from_file(store_aux, config_filename, NULL)) {
Alex Riesen64c0d712008-05-12 21:41:04[diff] [blame]1610 error("invalid config file %s", config_filename);
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1611 free(store.key);
1612 if (store.value_regex != NULL) {
1613 regfree(store.value_regex);
1614 free(store.value_regex);
1615 }
Michael J Gruber7a397412011-05-17 15:38:52[diff] [blame]1616 ret = CONFIG_INVALID_FILE;
Serge E. Hallyndafc88b2006-04-17 15:14:48[diff] [blame]1617 goto out_free;
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1618 }
1619
1620 free(store.key);
1621 if (store.value_regex != NULL) {
1622 regfree(store.value_regex);
1623 free(store.value_regex);
1624 }
1625
Johannes Schindelin4ddba792005-11-20 05:52:22[diff] [blame]1626 /* if nothing to unset, or too many matches, error out */
1627 if ((store.seen == 0 && value == NULL) ||
1628 (store.seen > 1 && multi_replace == 0)) {
Michael J Gruber7a397412011-05-17 15:38:52[diff] [blame]1629 ret = CONFIG_NOTHING_SET;
Serge E. Hallyndafc88b2006-04-17 15:14:48[diff] [blame]1630 goto out_free;
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1631 }
1632
Alex Riesen88fb9582006-01-05 11:43:34[diff] [blame]1633 fstat(in_fd, &st);
Shawn O. Pearcedc49cd72007-03-07 01:44:37[diff] [blame]1634 contents_sz = xsize_t(st.st_size);
1635 contents = xmmap(NULL, contents_sz, PROT_READ,
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1636 MAP_PRIVATE, in_fd, 0);
1637 close(in_fd);
1638
Johannes Schindelin4ddba792005-11-20 05:52:22[diff] [blame]1639 if (store.seen == 0)
1640 store.seen = 1;
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1641
Johannes Schindelin4ddba792005-11-20 05:52:22[diff] [blame]1642 for (i = 0, copy_begin = 0; i < store.seen; i++) {
1643 if (store.offset[i] == 0) {
Shawn O. Pearcedc49cd72007-03-07 01:44:37[diff] [blame]1644 store.offset[i] = copy_end = contents_sz;
Johannes Schindelin4ddba792005-11-20 05:52:22[diff] [blame]1645 } else if (store.state != KEY_SEEN) {
1646 copy_end = store.offset[i];
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1647 } else
Johannes Schindelin4ddba792005-11-20 05:52:22[diff] [blame]1648 copy_end = find_beginning_of_line(
Shawn O. Pearcedc49cd72007-03-07 01:44:37[diff] [blame]1649 contents, contents_sz,
Johannes Schindelin4ddba792005-11-20 05:52:22[diff] [blame]1650 store.offset[i]-2, &new_line);
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1651
Jeff King02e5ba42008-01-01 06:17:34[diff] [blame]1652 if (copy_end > 0 && contents[copy_end-1] != '\n')
1653 new_line = 1;
1654
Johannes Schindelin4ddba792005-11-20 05:52:22[diff] [blame]1655 /* write the first part of the config */
1656 if (copy_end > copy_begin) {
Junio C Hamano93c1e072007-01-11 21:16:26[diff] [blame]1657 if (write_in_full(fd, contents + copy_begin,
1658 copy_end - copy_begin) <
1659 copy_end - copy_begin)
1660 goto write_err_out;
1661 if (new_line &&
Jim Meyering2b7ca832009-09-12 08:54:32[diff] [blame]1662 write_str_in_full(fd, "\n") != 1)
Junio C Hamano93c1e072007-01-11 21:16:26[diff] [blame]1663 goto write_err_out;
Johannes Schindelin4ddba792005-11-20 05:52:22[diff] [blame]1664 }
1665 copy_begin = store.offset[i];
1666 }
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1667
1668 /* write the pair (value == NULL means unset) */
1669 if (value != NULL) {
Junio C Hamano93c1e072007-01-11 21:16:26[diff] [blame]1670 if (store.state == START) {
1671 if (!store_write_section(fd, key))
1672 goto write_err_out;
Andy Whitcroft480c9e52007-01-08 15:58:38[diff] [blame]1673 }
Junio C Hamano93c1e072007-01-11 21:16:26[diff] [blame]1674 if (!store_write_pair(fd, key, value))
1675 goto write_err_out;
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1676 }
1677
1678 /* write the rest of the config */
Shawn O. Pearcedc49cd72007-03-07 01:44:37[diff] [blame]1679 if (copy_begin < contents_sz)
Junio C Hamano93c1e072007-01-11 21:16:26[diff] [blame]1680 if (write_in_full(fd, contents + copy_begin,
Shawn O. Pearcedc49cd72007-03-07 01:44:37[diff] [blame]1681 contents_sz - copy_begin) <
1682 contents_sz - copy_begin)
Junio C Hamano93c1e072007-01-11 21:16:26[diff] [blame]1683 goto write_err_out;
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1684
Shawn O. Pearcedc49cd72007-03-07 01:44:37[diff] [blame]1685 munmap(contents, contents_sz);
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1686 }
1687
Brandon Casey4ed7cd32008-01-16 19:12:46[diff] [blame]1688 if (commit_lock_file(lock) < 0) {
Alex Riesen64c0d712008-05-12 21:41:04[diff] [blame]1689 error("could not commit config file %s", config_filename);
Michael J Gruber7a397412011-05-17 15:38:52[diff] [blame]1690 ret = CONFIG_NO_WRITE;
Serge E. Hallyndafc88b2006-04-17 15:14:48[diff] [blame]1691 goto out_free;
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1692 }
1693
Bradford C. Smith6cbf9732007-07-26 16:55:28[diff] [blame]1694 /*
1695 * lock is committed, so don't try to roll it back below.
1696 * NOTE: Since lockfile.c keeps a linked list of all created
1697 * lock_file structures, it isn't safe to free(lock). It's
1698 * better to just leave it hanging around.
1699 */
1700 lock = NULL;
Serge E. Hallyndafc88b2006-04-17 15:14:48[diff] [blame]1701 ret = 0;
1702
1703out_free:
Bradford C. Smith6cbf9732007-07-26 16:55:28[diff] [blame]1704 if (lock)
1705 rollback_lock_file(lock);
Jeff King0a5f5752012-02-16 08:04:05[diff] [blame]1706 free(filename_buf);
Serge E. Hallyndafc88b2006-04-17 15:14:48[diff] [blame]1707 return ret;
Junio C Hamano93c1e072007-01-11 21:16:26[diff] [blame]1708
1709write_err_out:
Alex Riesen64c0d712008-05-12 21:41:04[diff] [blame]1710 ret = write_error(lock->filename);
Junio C Hamano93c1e072007-01-11 21:16:26[diff] [blame]1711 goto out_free;
1712
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]1713}
1714
Ramkumar Ramachandra5ec31182011-08-04 10:39:00[diff] [blame]1715int git_config_set_multivar(const char *key, const char *value,
1716 const char *value_regex, int multi_replace)
1717{
Jeff King4a7bb5b2012-02-16 08:09:32[diff] [blame]1718 return git_config_set_multivar_in_file(NULL, key, value, value_regex,
Jeff King0a5f5752012-02-16 08:04:05[diff] [blame]1719 multi_replace);
Ramkumar Ramachandra5ec31182011-08-04 10:39:00[diff] [blame]1720}
1721
Paolo Bonzini118f8b22007-03-02 20:53:33[diff] [blame]1722static int section_name_match (const char *buf, const char *name)
1723{
1724 int i = 0, j = 0, dot = 0;
Alex Vandivera4c0d462009-07-24 21:21:43[diff] [blame]1725 if (buf[i] != '[')
1726 return 0;
1727 for (i = 1; buf[i] && buf[i] != ']'; i++) {
Paolo Bonzini118f8b22007-03-02 20:53:33[diff] [blame]1728 if (!dot && isspace(buf[i])) {
1729 dot = 1;
1730 if (name[j++] != '.')
1731 break;
1732 for (i++; isspace(buf[i]); i++)
1733 ; /* do nothing */
1734 if (buf[i] != '"')
1735 break;
1736 continue;
1737 }
1738 if (buf[i] == '\\' && dot)
1739 i++;
1740 else if (buf[i] == '"' && dot) {
1741 for (i++; isspace(buf[i]); i++)
1742 ; /* do_nothing */
1743 break;
1744 }
1745 if (buf[i] != name[j++])
1746 break;
1747 }
Alex Vandivera4c0d462009-07-24 21:21:43[diff] [blame]1748 if (buf[i] == ']' && name[j] == 0) {
1749 /*
1750 * We match, now just find the right length offset by
1751 * gobbling up any whitespace after it, as well
1752 */
1753 i++;
1754 for (; buf[i] && isspace(buf[i]); i++)
1755 ; /* do nothing */
1756 return i;
1757 }
1758 return 0;
Paolo Bonzini118f8b22007-03-02 20:53:33[diff] [blame]1759}
1760
Jeff King94a35b12012-04-26 01:47:14[diff] [blame]1761static int section_name_is_ok(const char *name)
1762{
1763 /* Empty section names are bogus. */
1764 if (!*name)
1765 return 0;
1766
1767 /*
1768 * Before a dot, we must be alphanumeric or dash. After the first dot,
1769 * anything goes, so we can stop checking.
1770 */
1771 for (; *name && *name != '.'; name++)
1772 if (*name != '-' && !isalnum(*name))
1773 return 0;
1774 return 1;
1775}
1776
Paolo Bonzini118f8b22007-03-02 20:53:33[diff] [blame]1777/* if new_name == NULL, the section is removed instead */
Jeff King42bd39b2012-02-16 08:04:25[diff] [blame]1778int git_config_rename_section_in_file(const char *config_filename,
1779 const char *old_name, const char *new_name)
Johannes Schindelin0667fcf2006-12-16 14:14:14[diff] [blame]1780{
Paolo Bonzini118f8b22007-03-02 20:53:33[diff] [blame]1781 int ret = 0, remove = 0;
Jeff King42bd39b2012-02-16 08:04:25[diff] [blame]1782 char *filename_buf = NULL;
Jeff King94a35b12012-04-26 01:47:14[diff] [blame]1783 struct lock_file *lock;
Johannes Schindelin0667fcf2006-12-16 14:14:14[diff] [blame]1784 int out_fd;
1785 char buf[1024];
Ramsay Jones924aaf32011-06-16 20:24:51[diff] [blame]1786 FILE *config_file;
Johannes Schindelin0667fcf2006-12-16 14:14:14[diff] [blame]1787
Jeff King94a35b12012-04-26 01:47:14[diff] [blame]1788 if (new_name && !section_name_is_ok(new_name)) {
1789 ret = error("invalid section name: %s", new_name);
1790 goto out;
1791 }
1792
Jeff King42bd39b2012-02-16 08:04:25[diff] [blame]1793 if (!config_filename)
1794 config_filename = filename_buf = git_pathdup("config");
1795
Brian Gesiakf1064f62014-05-26 15:33:46[diff] [blame]1796 lock = xcalloc(1, sizeof(struct lock_file));
Johannes Schindelin0667fcf2006-12-16 14:14:14[diff] [blame]1797 out_fd = hold_lock_file_for_update(lock, config_filename, 0);
Junio C Hamanofc1905b2006-12-20 05:55:27[diff] [blame]1798 if (out_fd < 0) {
Alex Riesen64c0d712008-05-12 21:41:04[diff] [blame]1799 ret = error("could not lock config file %s", config_filename);
Junio C Hamanofc1905b2006-12-20 05:55:27[diff] [blame]1800 goto out;
1801 }
Johannes Schindelin0667fcf2006-12-16 14:14:14[diff] [blame]1802
Junio C Hamanofc1905b2006-12-20 05:55:27[diff] [blame]1803 if (!(config_file = fopen(config_filename, "rb"))) {
Geert Bosch01ebb9d2007-04-05 14:20:55[diff] [blame]1804 /* no config file means nothing to rename, no error */
1805 goto unlock_and_out;
Junio C Hamanofc1905b2006-12-20 05:55:27[diff] [blame]1806 }
Johannes Schindelin0667fcf2006-12-16 14:14:14[diff] [blame]1807
1808 while (fgets(buf, sizeof(buf), config_file)) {
1809 int i;
Andy Whitcroft480c9e52007-01-08 15:58:38[diff] [blame]1810 int length;
Alex Vandiver9a5abfc2009-07-24 21:21:44[diff] [blame]1811 char *output = buf;
Johannes Schindelin0667fcf2006-12-16 14:14:14[diff] [blame]1812 for (i = 0; buf[i] && isspace(buf[i]); i++)
1813 ; /* do nothing */
1814 if (buf[i] == '[') {
1815 /* it's a section */
Alex Vandivera4c0d462009-07-24 21:21:43[diff] [blame]1816 int offset = section_name_match(&buf[i], old_name);
1817 if (offset > 0) {
Paolo Bonzini118f8b22007-03-02 20:53:33[diff] [blame]1818 ret++;
1819 if (new_name == NULL) {
1820 remove = 1;
Johannes Schindelin0667fcf2006-12-16 14:14:14[diff] [blame]1821 continue;
1822 }
Johannes Schindelin0667fcf2006-12-16 14:14:14[diff] [blame]1823 store.baselen = strlen(new_name);
Andy Whitcroft480c9e52007-01-08 15:58:38[diff] [blame]1824 if (!store_write_section(out_fd, new_name)) {
Alex Riesen64c0d712008-05-12 21:41:04[diff] [blame]1825 ret = write_error(lock->filename);
Andy Whitcroft480c9e52007-01-08 15:58:38[diff] [blame]1826 goto out;
1827 }
Alex Vandiver9a5abfc2009-07-24 21:21:44[diff] [blame]1828 /*
1829 * We wrote out the new section, with
1830 * a newline, now skip the old
1831 * section's length
1832 */
1833 output += offset + i;
1834 if (strlen(output) > 0) {
1835 /*
1836 * More content means there's
1837 * a declaration to put on the
1838 * next line; indent with a
1839 * tab
1840 */
1841 output -= 1;
1842 output[0] = '\t';
1843 }
Johannes Schindelin0667fcf2006-12-16 14:14:14[diff] [blame]1844 }
Paolo Bonzini118f8b22007-03-02 20:53:33[diff] [blame]1845 remove = 0;
Johannes Schindelin0667fcf2006-12-16 14:14:14[diff] [blame]1846 }
Paolo Bonzini118f8b22007-03-02 20:53:33[diff] [blame]1847 if (remove)
1848 continue;
Alex Vandiver9a5abfc2009-07-24 21:21:44[diff] [blame]1849 length = strlen(output);
1850 if (write_in_full(out_fd, output, length) != length) {
Alex Riesen64c0d712008-05-12 21:41:04[diff] [blame]1851 ret = write_error(lock->filename);
Andy Whitcroft480c9e52007-01-08 15:58:38[diff] [blame]1852 goto out;
1853 }
Johannes Schindelin0667fcf2006-12-16 14:14:14[diff] [blame]1854 }
Junio C Hamanofc1905b2006-12-20 05:55:27[diff] [blame]1855 fclose(config_file);
Pavan Kumar Sunkara8b590072011-07-16 21:55:52[diff] [blame]1856unlock_and_out:
Brandon Casey4ed7cd32008-01-16 19:12:46[diff] [blame]1857 if (commit_lock_file(lock) < 0)
Alex Riesen64c0d712008-05-12 21:41:04[diff] [blame]1858 ret = error("could not commit config file %s", config_filename);
Pavan Kumar Sunkara8b590072011-07-16 21:55:52[diff] [blame]1859out:
Jeff King42bd39b2012-02-16 08:04:25[diff] [blame]1860 free(filename_buf);
Johannes Schindelin0667fcf2006-12-16 14:14:14[diff] [blame]1861 return ret;
1862}
Junio C Hamano40ea4ed2008-02-11 18:41:18[diff] [blame]1863
Jeff King42bd39b2012-02-16 08:04:25[diff] [blame]1864int git_config_rename_section(const char *old_name, const char *new_name)
1865{
Jeff King4a7bb5b2012-02-16 08:09:32[diff] [blame]1866 return git_config_rename_section_in_file(NULL, old_name, new_name);
Jeff King42bd39b2012-02-16 08:04:25[diff] [blame]1867}
1868
Junio C Hamano40ea4ed2008-02-11 18:41:18[diff] [blame]1869/*
1870 * Call this to report error for your variable that should not
1871 * get a boolean value (i.e. "[my] var" means "true").
1872 */
Jeff Kinga469a102012-12-15 17:42:10[diff] [blame]1873#undef config_error_nonbool
Junio C Hamano40ea4ed2008-02-11 18:41:18[diff] [blame]1874int config_error_nonbool(const char *var)
1875{
1876 return error("Missing value for '%s'", var);
1877}
Jeff King1b86bbb2013-01-23 06:23:05[diff] [blame]1878
1879int parse_config_key(const char *var,
1880 const char *section,
1881 const char **subsection, int *subsection_len,
1882 const char **key)
1883{
1884 int section_len = strlen(section);
1885 const char *dot;
1886
1887 /* Does it start with "section." ? */
Christian Couder59556542013-11-30 20:55:40[diff] [blame]1888 if (!starts_with(var, section) || var[section_len] != '.')
Jeff King1b86bbb2013-01-23 06:23:05[diff] [blame]1889 return -1;
1890
1891 /*
1892 * Find the key; we don't know yet if we have a subsection, but we must
1893 * parse backwards from the end, since the subsection may have dots in
1894 * it, too.
1895 */
1896 dot = strrchr(var, '.');
1897 *key = dot + 1;
1898
1899 /* Did we have a subsection at all? */
1900 if (dot == var + section_len) {
1901 *subsection = NULL;
1902 *subsection_len = 0;
1903 }
1904 else {
1905 *subsection = var + section_len + 1;
1906 *subsection_len = dot - *subsection;
1907 }
1908
1909 return 0;
1910}