GIT 1.5.3.6
[git] / config.c
1 /*
2  * GIT - The information manager from hell
3  *
4  * Copyright (C) Linus Torvalds, 2005
5  * Copyright (C) Johannes Schindelin, 2005
6  *
7  */
8 #include "cache.h"
9
10 #define MAXNAME (256)
11
12 static FILE *config_file;
13 static const char *config_file_name;
14 static int config_linenr;
15 static int zlib_compression_seen;
16
17 static int get_next_char(void)
18 {
19         int c;
20         FILE *f;
21
22         c = '\n';
23         if ((f = config_file) != NULL) {
24                 c = fgetc(f);
25                 if (c == '\r') {
26                         /* DOS like systems */
27                         c = fgetc(f);
28                         if (c != '\n') {
29                                 ungetc(c, f);
30                                 c = '\r';
31                         }
32                 }
33                 if (c == '\n')
34                         config_linenr++;
35                 if (c == EOF) {
36                         config_file = NULL;
37                         c = '\n';
38                 }
39         }
40         return c;
41 }
42
43 static char *parse_value(void)
44 {
45         static char value[1024];
46         int quote = 0, comment = 0, len = 0, space = 0;
47
48         for (;;) {
49                 int c = get_next_char();
50                 if (len >= sizeof(value))
51                         return NULL;
52                 if (c == '\n') {
53                         if (quote)
54                                 return NULL;
55                         value[len] = 0;
56                         return value;
57                 }
58                 if (comment)
59                         continue;
60                 if (isspace(c) && !quote) {
61                         space = 1;
62                         continue;
63                 }
64                 if (!quote) {
65                         if (c == ';' || c == '#') {
66                                 comment = 1;
67                                 continue;
68                         }
69                 }
70                 if (space) {
71                         if (len)
72                                 value[len++] = ' ';
73                         space = 0;
74                 }
75                 if (c == '\\') {
76                         c = get_next_char();
77                         switch (c) {
78                         case '\n':
79                                 continue;
80                         case 't':
81                                 c = '\t';
82                                 break;
83                         case 'b':
84                                 c = '\b';
85                                 break;
86                         case 'n':
87                                 c = '\n';
88                                 break;
89                         /* Some characters escape as themselves */
90                         case '\\': case '"':
91                                 break;
92                         /* Reject unknown escape sequences */
93                         default:
94                                 return NULL;
95                         }
96                         value[len++] = c;
97                         continue;
98                 }
99                 if (c == '"') {
100                         quote = 1-quote;
101                         continue;
102                 }
103                 value[len++] = c;
104         }
105 }
106
107 static inline int iskeychar(int c)
108 {
109         return isalnum(c) || c == '-';
110 }
111
112 static int get_value(config_fn_t fn, char *name, unsigned int len)
113 {
114         int c;
115         char *value;
116
117         /* Get the full name */
118         for (;;) {
119                 c = get_next_char();
120                 if (c == EOF)
121                         break;
122                 if (!iskeychar(c))
123                         break;
124                 name[len++] = tolower(c);
125                 if (len >= MAXNAME)
126                         return -1;
127         }
128         name[len] = 0;
129         while (c == ' ' || c == '\t')
130                 c = get_next_char();
131
132         value = NULL;
133         if (c != '\n') {
134                 if (c != '=')
135                         return -1;
136                 value = parse_value();
137                 if (!value)
138                         return -1;
139         }
140         return fn(name, value);
141 }
142
143 static int get_extended_base_var(char *name, int baselen, int c)
144 {
145         do {
146                 if (c == '\n')
147                         return -1;
148                 c = get_next_char();
149         } while (isspace(c));
150
151         /* We require the format to be '[base "extension"]' */
152         if (c != '"')
153                 return -1;
154         name[baselen++] = '.';
155
156         for (;;) {
157                 int c = get_next_char();
158                 if (c == '\n')
159                         return -1;
160                 if (c == '"')
161                         break;
162                 if (c == '\\') {
163                         c = get_next_char();
164                         if (c == '\n')
165                                 return -1;
166                 }
167                 name[baselen++] = c;
168                 if (baselen > MAXNAME / 2)
169                         return -1;
170         }
171
172         /* Final ']' */
173         if (get_next_char() != ']')
174                 return -1;
175         return baselen;
176 }
177
178 static int get_base_var(char *name)
179 {
180         int baselen = 0;
181
182         for (;;) {
183                 int c = get_next_char();
184                 if (c == EOF)
185                         return -1;
186                 if (c == ']')
187                         return baselen;
188                 if (isspace(c))
189                         return get_extended_base_var(name, baselen, c);
190                 if (!iskeychar(c) && c != '.')
191                         return -1;
192                 if (baselen > MAXNAME / 2)
193                         return -1;
194                 name[baselen++] = tolower(c);
195         }
196 }
197
198 static int git_parse_file(config_fn_t fn)
199 {
200         int comment = 0;
201         int baselen = 0;
202         static char var[MAXNAME];
203
204         for (;;) {
205                 int c = get_next_char();
206                 if (c == '\n') {
207                         /* EOF? */
208                         if (!config_file)
209                                 return 0;
210                         comment = 0;
211                         continue;
212                 }
213                 if (comment || isspace(c))
214                         continue;
215                 if (c == '#' || c == ';') {
216                         comment = 1;
217                         continue;
218                 }
219                 if (c == '[') {
220                         baselen = get_base_var(var);
221                         if (baselen <= 0)
222                                 break;
223                         var[baselen++] = '.';
224                         var[baselen] = 0;
225                         continue;
226                 }
227                 if (!isalpha(c))
228                         break;
229                 var[baselen] = tolower(c);
230                 if (get_value(fn, var, baselen+1) < 0)
231                         break;
232         }
233         die("bad config file line %d in %s", config_linenr, config_file_name);
234 }
235
236 static unsigned long get_unit_factor(const char *end)
237 {
238         if (!*end)
239                 return 1;
240         else if (!strcasecmp(end, "k"))
241                 return 1024;
242         else if (!strcasecmp(end, "m"))
243                 return 1024 * 1024;
244         else if (!strcasecmp(end, "g"))
245                 return 1024 * 1024 * 1024;
246         die("unknown unit: '%s'", end);
247 }
248
249 int git_parse_long(const char *value, long *ret)
250 {
251         if (value && *value) {
252                 char *end;
253                 long val = strtol(value, &end, 0);
254                 *ret = val * get_unit_factor(end);
255                 return 1;
256         }
257         return 0;
258 }
259
260 int git_parse_ulong(const char *value, unsigned long *ret)
261 {
262         if (value && *value) {
263                 char *end;
264                 unsigned long val = strtoul(value, &end, 0);
265                 *ret = val * get_unit_factor(end);
266                 return 1;
267         }
268         return 0;
269 }
270
271 int git_config_int(const char *name, const char *value)
272 {
273         long ret;
274         if (!git_parse_long(value, &ret))
275                 die("bad config value for '%s' in %s", name, config_file_name);
276         return ret;
277 }
278
279 unsigned long git_config_ulong(const char *name, const char *value)
280 {
281         unsigned long ret;
282         if (!git_parse_ulong(value, &ret))
283                 die("bad config value for '%s' in %s", name, config_file_name);
284         return ret;
285 }
286
287 int git_config_bool(const char *name, const char *value)
288 {
289         if (!value)
290                 return 1;
291         if (!*value)
292                 return 0;
293         if (!strcasecmp(value, "true") || !strcasecmp(value, "yes"))
294                 return 1;
295         if (!strcasecmp(value, "false") || !strcasecmp(value, "no"))
296                 return 0;
297         return git_config_int(name, value) != 0;
298 }
299
300 int git_default_config(const char *var, const char *value)
301 {
302         /* This needs a better name */
303         if (!strcmp(var, "core.filemode")) {
304                 trust_executable_bit = git_config_bool(var, value);
305                 return 0;
306         }
307
308         if (!strcmp(var, "core.quotepath")) {
309                 quote_path_fully = git_config_bool(var, value);
310                 return 0;
311         }
312
313         if (!strcmp(var, "core.symlinks")) {
314                 has_symlinks = git_config_bool(var, value);
315                 return 0;
316         }
317
318         if (!strcmp(var, "core.bare")) {
319                 is_bare_repository_cfg = git_config_bool(var, value);
320                 return 0;
321         }
322
323         if (!strcmp(var, "core.ignorestat")) {
324                 assume_unchanged = git_config_bool(var, value);
325                 return 0;
326         }
327
328         if (!strcmp(var, "core.prefersymlinkrefs")) {
329                 prefer_symlink_refs = git_config_bool(var, value);
330                 return 0;
331         }
332
333         if (!strcmp(var, "core.logallrefupdates")) {
334                 log_all_ref_updates = git_config_bool(var, value);
335                 return 0;
336         }
337
338         if (!strcmp(var, "core.warnambiguousrefs")) {
339                 warn_ambiguous_refs = git_config_bool(var, value);
340                 return 0;
341         }
342
343         if (!strcmp(var, "core.loosecompression")) {
344                 int level = git_config_int(var, value);
345                 if (level == -1)
346                         level = Z_DEFAULT_COMPRESSION;
347                 else if (level < 0 || level > Z_BEST_COMPRESSION)
348                         die("bad zlib compression level %d", level);
349                 zlib_compression_level = level;
350                 zlib_compression_seen = 1;
351                 return 0;
352         }
353
354         if (!strcmp(var, "core.compression")) {
355                 int level = git_config_int(var, value);
356                 if (level == -1)
357                         level = Z_DEFAULT_COMPRESSION;
358                 else if (level < 0 || level > Z_BEST_COMPRESSION)
359                         die("bad zlib compression level %d", level);
360                 core_compression_level = level;
361                 core_compression_seen = 1;
362                 if (!zlib_compression_seen)
363                         zlib_compression_level = level;
364                 return 0;
365         }
366
367         if (!strcmp(var, "core.packedgitwindowsize")) {
368                 int pgsz_x2 = getpagesize() * 2;
369                 packed_git_window_size = git_config_int(var, value);
370
371                 /* This value must be multiple of (pagesize * 2) */
372                 packed_git_window_size /= pgsz_x2;
373                 if (packed_git_window_size < 1)
374                         packed_git_window_size = 1;
375                 packed_git_window_size *= pgsz_x2;
376                 return 0;
377         }
378
379         if (!strcmp(var, "core.packedgitlimit")) {
380                 packed_git_limit = git_config_int(var, value);
381                 return 0;
382         }
383
384         if (!strcmp(var, "core.deltabasecachelimit")) {
385                 delta_base_cache_limit = git_config_int(var, value);
386                 return 0;
387         }
388
389         if (!strcmp(var, "core.autocrlf")) {
390                 if (value && !strcasecmp(value, "input")) {
391                         auto_crlf = -1;
392                         return 0;
393                 }
394                 auto_crlf = git_config_bool(var, value);
395                 return 0;
396         }
397
398         if (!strcmp(var, "user.name")) {
399                 strlcpy(git_default_name, value, sizeof(git_default_name));
400                 return 0;
401         }
402
403         if (!strcmp(var, "user.email")) {
404                 strlcpy(git_default_email, value, sizeof(git_default_email));
405                 return 0;
406         }
407
408         if (!strcmp(var, "i18n.commitencoding")) {
409                 git_commit_encoding = xstrdup(value);
410                 return 0;
411         }
412
413         if (!strcmp(var, "i18n.logoutputencoding")) {
414                 git_log_output_encoding = xstrdup(value);
415                 return 0;
416         }
417
418
419         if (!strcmp(var, "pager.color") || !strcmp(var, "color.pager")) {
420                 pager_use_color = git_config_bool(var,value);
421                 return 0;
422         }
423
424         if (!strcmp(var, "core.pager")) {
425                 pager_program = xstrdup(value);
426                 return 0;
427         }
428
429         if (!strcmp(var, "core.editor")) {
430                 editor_program = xstrdup(value);
431                 return 0;
432         }
433
434         if (!strcmp(var, "core.excludesfile")) {
435                 if (!value)
436                         die("core.excludesfile without value");
437                 excludes_file = xstrdup(value);
438                 return 0;
439         }
440
441         /* Add other config variables here and to Documentation/config.txt. */
442         return 0;
443 }
444
445 int git_config_from_file(config_fn_t fn, const char *filename)
446 {
447         int ret;
448         FILE *f = fopen(filename, "r");
449
450         ret = -1;
451         if (f) {
452                 config_file = f;
453                 config_file_name = filename;
454                 config_linenr = 1;
455                 ret = git_parse_file(fn);
456                 fclose(f);
457                 config_file_name = NULL;
458         }
459         return ret;
460 }
461
462 int git_config(config_fn_t fn)
463 {
464         int ret = 0;
465         char *repo_config = NULL;
466         const char *home = NULL, *filename;
467
468         /* $GIT_CONFIG makes git read _only_ the given config file,
469          * $GIT_CONFIG_LOCAL will make it process it in addition to the
470          * global config file, the same way it would the per-repository
471          * config file otherwise. */
472         filename = getenv(CONFIG_ENVIRONMENT);
473         if (!filename) {
474                 if (!access(ETC_GITCONFIG, R_OK))
475                         ret += git_config_from_file(fn, ETC_GITCONFIG);
476                 home = getenv("HOME");
477                 filename = getenv(CONFIG_LOCAL_ENVIRONMENT);
478                 if (!filename)
479                         filename = repo_config = xstrdup(git_path("config"));
480         }
481
482         if (home) {
483                 char *user_config = xstrdup(mkpath("%s/.gitconfig", home));
484                 if (!access(user_config, R_OK))
485                         ret = git_config_from_file(fn, user_config);
486                 free(user_config);
487         }
488
489         ret += git_config_from_file(fn, filename);
490         free(repo_config);
491         return ret;
492 }
493
494 /*
495  * Find all the stuff for git_config_set() below.
496  */
497
498 #define MAX_MATCHES 512
499
500 static struct {
501         int baselen;
502         char* key;
503         int do_not_match;
504         regex_t* value_regex;
505         int multi_replace;
506         size_t offset[MAX_MATCHES];
507         enum { START, SECTION_SEEN, SECTION_END_SEEN, KEY_SEEN } state;
508         int seen;
509 } store;
510
511 static int matches(const char* key, const char* value)
512 {
513         return !strcmp(key, store.key) &&
514                 (store.value_regex == NULL ||
515                  (store.do_not_match ^
516                   !regexec(store.value_regex, value, 0, NULL, 0)));
517 }
518
519 static int store_aux(const char* key, const char* value)
520 {
521         const char *ep;
522         size_t section_len;
523
524         switch (store.state) {
525         case KEY_SEEN:
526                 if (matches(key, value)) {
527                         if (store.seen == 1 && store.multi_replace == 0) {
528                                 fprintf(stderr,
529                                         "Warning: %s has multiple values\n",
530                                         key);
531                         } else if (store.seen >= MAX_MATCHES) {
532                                 fprintf(stderr, "Too many matches\n");
533                                 return 1;
534                         }
535
536                         store.offset[store.seen] = ftell(config_file);
537                         store.seen++;
538                 }
539                 break;
540         case SECTION_SEEN:
541                 /*
542                  * What we are looking for is in store.key (both
543                  * section and var), and its section part is baselen
544                  * long.  We found key (again, both section and var).
545                  * We would want to know if this key is in the same
546                  * section as what we are looking for.  We already
547                  * know we are in the same section as what should
548                  * hold store.key.
549                  */
550                 ep = strrchr(key, '.');
551                 section_len = ep - key;
552
553                 if ((section_len != store.baselen) ||
554                     memcmp(key, store.key, section_len+1)) {
555                         store.state = SECTION_END_SEEN;
556                         break;
557                 }
558
559                 /*
560                  * Do not increment matches: this is no match, but we
561                  * just made sure we are in the desired section.
562                  */
563                 store.offset[store.seen] = ftell(config_file);
564                 /* fallthru */
565         case SECTION_END_SEEN:
566         case START:
567                 if (matches(key, value)) {
568                         store.offset[store.seen] = ftell(config_file);
569                         store.state = KEY_SEEN;
570                         store.seen++;
571                 } else {
572                         if (strrchr(key, '.') - key == store.baselen &&
573                               !strncmp(key, store.key, store.baselen)) {
574                                         store.state = SECTION_SEEN;
575                                         store.offset[store.seen] = ftell(config_file);
576                         }
577                 }
578         }
579         return 0;
580 }
581
582 static int write_error(void)
583 {
584         fprintf(stderr, "Failed to write new configuration file\n");
585
586         /* Same error code as "failed to rename". */
587         return 4;
588 }
589
590 static int store_write_section(int fd, const char* key)
591 {
592         const char *dot = strchr(key, '.');
593         int len1 = store.baselen, len2 = -1;
594
595         dot = strchr(key, '.');
596         if (dot) {
597                 int dotlen = dot - key;
598                 if (dotlen < len1) {
599                         len2 = len1 - dotlen - 1;
600                         len1 = dotlen;
601                 }
602         }
603
604         if (write_in_full(fd, "[", 1) != 1 ||
605             write_in_full(fd, key, len1) != len1)
606                 return 0;
607         if (len2 >= 0) {
608                 if (write_in_full(fd, " \"", 2) != 2)
609                         return 0;
610                 while (--len2 >= 0) {
611                         unsigned char c = *++dot;
612                         if (c == '"')
613                                 if (write_in_full(fd, "\\", 1) != 1)
614                                         return 0;
615                         if (write_in_full(fd, &c, 1) != 1)
616                                 return 0;
617                 }
618                 if (write_in_full(fd, "\"", 1) != 1)
619                         return 0;
620         }
621         if (write_in_full(fd, "]\n", 2) != 2)
622                 return 0;
623
624         return 1;
625 }
626
627 static int store_write_pair(int fd, const char* key, const char* value)
628 {
629         int i;
630         int length = strlen(key+store.baselen+1);
631         int quote = 0;
632
633         /* Check to see if the value needs to be quoted. */
634         if (value[0] == ' ')
635                 quote = 1;
636         for (i = 0; value[i]; i++)
637                 if (value[i] == ';' || value[i] == '#')
638                         quote = 1;
639         if (value[i-1] == ' ')
640                 quote = 1;
641
642         if (write_in_full(fd, "\t", 1) != 1 ||
643             write_in_full(fd, key+store.baselen+1, length) != length ||
644             write_in_full(fd, " = ", 3) != 3)
645                 return 0;
646         if (quote && write_in_full(fd, "\"", 1) != 1)
647                 return 0;
648         for (i = 0; value[i]; i++)
649                 switch (value[i]) {
650                 case '\n':
651                         if (write_in_full(fd, "\\n", 2) != 2)
652                                 return 0;
653                         break;
654                 case '\t':
655                         if (write_in_full(fd, "\\t", 2) != 2)
656                                 return 0;
657                         break;
658                 case '"':
659                 case '\\':
660                         if (write_in_full(fd, "\\", 1) != 1)
661                                 return 0;
662                 default:
663                         if (write_in_full(fd, value+i, 1) != 1)
664                                 return 0;
665                         break;
666                 }
667         if (quote && write_in_full(fd, "\"", 1) != 1)
668                 return 0;
669         if (write_in_full(fd, "\n", 1) != 1)
670                 return 0;
671         return 1;
672 }
673
674 static ssize_t find_beginning_of_line(const char* contents, size_t size,
675         size_t offset_, int* found_bracket)
676 {
677         size_t equal_offset = size, bracket_offset = size;
678         ssize_t offset;
679
680         for (offset = offset_-2; offset > 0
681                         && contents[offset] != '\n'; offset--)
682                 switch (contents[offset]) {
683                         case '=': equal_offset = offset; break;
684                         case ']': bracket_offset = offset; break;
685                 }
686         if (bracket_offset < equal_offset) {
687                 *found_bracket = 1;
688                 offset = bracket_offset+1;
689         } else
690                 offset++;
691
692         return offset;
693 }
694
695 int git_config_set(const char* key, const char* value)
696 {
697         return git_config_set_multivar(key, value, NULL, 0);
698 }
699
700 /*
701  * If value==NULL, unset in (remove from) config,
702  * if value_regex!=NULL, disregard key/value pairs where value does not match.
703  * if multi_replace==0, nothing, or only one matching key/value is replaced,
704  *     else all matching key/values (regardless how many) are removed,
705  *     before the new pair is written.
706  *
707  * Returns 0 on success.
708  *
709  * This function does this:
710  *
711  * - it locks the config file by creating ".git/config.lock"
712  *
713  * - it then parses the config using store_aux() as validator to find
714  *   the position on the key/value pair to replace. If it is to be unset,
715  *   it must be found exactly once.
716  *
717  * - the config file is mmap()ed and the part before the match (if any) is
718  *   written to the lock file, then the changed part and the rest.
719  *
720  * - the config file is removed and the lock file rename()d to it.
721  *
722  */
723 int git_config_set_multivar(const char* key, const char* value,
724         const char* value_regex, int multi_replace)
725 {
726         int i, dot;
727         int fd = -1, in_fd;
728         int ret;
729         char* config_filename;
730         struct lock_file *lock = NULL;
731         const char* last_dot = strrchr(key, '.');
732
733         config_filename = getenv(CONFIG_ENVIRONMENT);
734         if (!config_filename) {
735                 config_filename = getenv(CONFIG_LOCAL_ENVIRONMENT);
736                 if (!config_filename)
737                         config_filename  = git_path("config");
738         }
739         config_filename = xstrdup(config_filename);
740
741         /*
742          * Since "key" actually contains the section name and the real
743          * key name separated by a dot, we have to know where the dot is.
744          */
745
746         if (last_dot == NULL) {
747                 fprintf(stderr, "key does not contain a section: %s\n", key);
748                 ret = 2;
749                 goto out_free;
750         }
751         store.baselen = last_dot - key;
752
753         store.multi_replace = multi_replace;
754
755         /*
756          * Validate the key and while at it, lower case it for matching.
757          */
758         store.key = xmalloc(strlen(key) + 1);
759         dot = 0;
760         for (i = 0; key[i]; i++) {
761                 unsigned char c = key[i];
762                 if (c == '.')
763                         dot = 1;
764                 /* Leave the extended basename untouched.. */
765                 if (!dot || i > store.baselen) {
766                         if (!iskeychar(c) || (i == store.baselen+1 && !isalpha(c))) {
767                                 fprintf(stderr, "invalid key: %s\n", key);
768                                 free(store.key);
769                                 ret = 1;
770                                 goto out_free;
771                         }
772                         c = tolower(c);
773                 } else if (c == '\n') {
774                         fprintf(stderr, "invalid key (newline): %s\n", key);
775                         free(store.key);
776                         ret = 1;
777                         goto out_free;
778                 }
779                 store.key[i] = c;
780         }
781         store.key[i] = 0;
782
783         /*
784          * The lock serves a purpose in addition to locking: the new
785          * contents of .git/config will be written into it.
786          */
787         lock = xcalloc(sizeof(struct lock_file), 1);
788         fd = hold_lock_file_for_update(lock, config_filename, 0);
789         if (fd < 0) {
790                 fprintf(stderr, "could not lock config file\n");
791                 free(store.key);
792                 ret = -1;
793                 goto out_free;
794         }
795
796         /*
797          * If .git/config does not exist yet, write a minimal version.
798          */
799         in_fd = open(config_filename, O_RDONLY);
800         if ( in_fd < 0 ) {
801                 free(store.key);
802
803                 if ( ENOENT != errno ) {
804                         error("opening %s: %s", config_filename,
805                               strerror(errno));
806                         ret = 3; /* same as "invalid config file" */
807                         goto out_free;
808                 }
809                 /* if nothing to unset, error out */
810                 if (value == NULL) {
811                         ret = 5;
812                         goto out_free;
813                 }
814
815                 store.key = (char*)key;
816                 if (!store_write_section(fd, key) ||
817                     !store_write_pair(fd, key, value))
818                         goto write_err_out;
819         } else {
820                 struct stat st;
821                 char* contents;
822                 size_t contents_sz, copy_begin, copy_end;
823                 int i, new_line = 0;
824
825                 if (value_regex == NULL)
826                         store.value_regex = NULL;
827                 else {
828                         if (value_regex[0] == '!') {
829                                 store.do_not_match = 1;
830                                 value_regex++;
831                         } else
832                                 store.do_not_match = 0;
833
834                         store.value_regex = (regex_t*)xmalloc(sizeof(regex_t));
835                         if (regcomp(store.value_regex, value_regex,
836                                         REG_EXTENDED)) {
837                                 fprintf(stderr, "Invalid pattern: %s\n",
838                                         value_regex);
839                                 free(store.value_regex);
840                                 ret = 6;
841                                 goto out_free;
842                         }
843                 }
844
845                 store.offset[0] = 0;
846                 store.state = START;
847                 store.seen = 0;
848
849                 /*
850                  * After this, store.offset will contain the *end* offset
851                  * of the last match, or remain at 0 if no match was found.
852                  * As a side effect, we make sure to transform only a valid
853                  * existing config file.
854                  */
855                 if (git_config_from_file(store_aux, config_filename)) {
856                         fprintf(stderr, "invalid config file\n");
857                         free(store.key);
858                         if (store.value_regex != NULL) {
859                                 regfree(store.value_regex);
860                                 free(store.value_regex);
861                         }
862                         ret = 3;
863                         goto out_free;
864                 }
865
866                 free(store.key);
867                 if (store.value_regex != NULL) {
868                         regfree(store.value_regex);
869                         free(store.value_regex);
870                 }
871
872                 /* if nothing to unset, or too many matches, error out */
873                 if ((store.seen == 0 && value == NULL) ||
874                                 (store.seen > 1 && multi_replace == 0)) {
875                         ret = 5;
876                         goto out_free;
877                 }
878
879                 fstat(in_fd, &st);
880                 contents_sz = xsize_t(st.st_size);
881                 contents = xmmap(NULL, contents_sz, PROT_READ,
882                         MAP_PRIVATE, in_fd, 0);
883                 close(in_fd);
884
885                 if (store.seen == 0)
886                         store.seen = 1;
887
888                 for (i = 0, copy_begin = 0; i < store.seen; i++) {
889                         if (store.offset[i] == 0) {
890                                 store.offset[i] = copy_end = contents_sz;
891                         } else if (store.state != KEY_SEEN) {
892                                 copy_end = store.offset[i];
893                         } else
894                                 copy_end = find_beginning_of_line(
895                                         contents, contents_sz,
896                                         store.offset[i]-2, &new_line);
897
898                         /* write the first part of the config */
899                         if (copy_end > copy_begin) {
900                                 if (write_in_full(fd, contents + copy_begin,
901                                                   copy_end - copy_begin) <
902                                     copy_end - copy_begin)
903                                         goto write_err_out;
904                                 if (new_line &&
905                                     write_in_full(fd, "\n", 1) != 1)
906                                         goto write_err_out;
907                         }
908                         copy_begin = store.offset[i];
909                 }
910
911                 /* write the pair (value == NULL means unset) */
912                 if (value != NULL) {
913                         if (store.state == START) {
914                                 if (!store_write_section(fd, key))
915                                         goto write_err_out;
916                         }
917                         if (!store_write_pair(fd, key, value))
918                                 goto write_err_out;
919                 }
920
921                 /* write the rest of the config */
922                 if (copy_begin < contents_sz)
923                         if (write_in_full(fd, contents + copy_begin,
924                                           contents_sz - copy_begin) <
925                             contents_sz - copy_begin)
926                                 goto write_err_out;
927
928                 munmap(contents, contents_sz);
929         }
930
931         if (close(fd) || commit_lock_file(lock) < 0) {
932                 fprintf(stderr, "Cannot commit config file!\n");
933                 ret = 4;
934                 goto out_free;
935         }
936
937         /* fd is closed, so don't try to close it below. */
938         fd = -1;
939         /*
940          * lock is committed, so don't try to roll it back below.
941          * NOTE: Since lockfile.c keeps a linked list of all created
942          * lock_file structures, it isn't safe to free(lock).  It's
943          * better to just leave it hanging around.
944          */
945         lock = NULL;
946         ret = 0;
947
948 out_free:
949         if (0 <= fd)
950                 close(fd);
951         if (lock)
952                 rollback_lock_file(lock);
953         free(config_filename);
954         return ret;
955
956 write_err_out:
957         ret = write_error();
958         goto out_free;
959
960 }
961
962 static int section_name_match (const char *buf, const char *name)
963 {
964         int i = 0, j = 0, dot = 0;
965         for (; buf[i] && buf[i] != ']'; i++) {
966                 if (!dot && isspace(buf[i])) {
967                         dot = 1;
968                         if (name[j++] != '.')
969                                 break;
970                         for (i++; isspace(buf[i]); i++)
971                                 ; /* do nothing */
972                         if (buf[i] != '"')
973                                 break;
974                         continue;
975                 }
976                 if (buf[i] == '\\' && dot)
977                         i++;
978                 else if (buf[i] == '"' && dot) {
979                         for (i++; isspace(buf[i]); i++)
980                                 ; /* do_nothing */
981                         break;
982                 }
983                 if (buf[i] != name[j++])
984                         break;
985         }
986         return (buf[i] == ']' && name[j] == 0);
987 }
988
989 /* if new_name == NULL, the section is removed instead */
990 int git_config_rename_section(const char *old_name, const char *new_name)
991 {
992         int ret = 0, remove = 0;
993         char *config_filename;
994         struct lock_file *lock = xcalloc(sizeof(struct lock_file), 1);
995         int out_fd;
996         char buf[1024];
997
998         config_filename = getenv(CONFIG_ENVIRONMENT);
999         if (!config_filename) {
1000                 config_filename = getenv(CONFIG_LOCAL_ENVIRONMENT);
1001                 if (!config_filename)
1002                         config_filename  = git_path("config");
1003         }
1004         config_filename = xstrdup(config_filename);
1005         out_fd = hold_lock_file_for_update(lock, config_filename, 0);
1006         if (out_fd < 0) {
1007                 ret = error("Could not lock config file!");
1008                 goto out;
1009         }
1010
1011         if (!(config_file = fopen(config_filename, "rb"))) {
1012                 /* no config file means nothing to rename, no error */
1013                 goto unlock_and_out;
1014         }
1015
1016         while (fgets(buf, sizeof(buf), config_file)) {
1017                 int i;
1018                 int length;
1019                 for (i = 0; buf[i] && isspace(buf[i]); i++)
1020                         ; /* do nothing */
1021                 if (buf[i] == '[') {
1022                         /* it's a section */
1023                         if (section_name_match (&buf[i+1], old_name)) {
1024                                 ret++;
1025                                 if (new_name == NULL) {
1026                                         remove = 1;
1027                                         continue;
1028                                 }
1029                                 store.baselen = strlen(new_name);
1030                                 if (!store_write_section(out_fd, new_name)) {
1031                                         ret = write_error();
1032                                         goto out;
1033                                 }
1034                                 continue;
1035                         }
1036                         remove = 0;
1037                 }
1038                 if (remove)
1039                         continue;
1040                 length = strlen(buf);
1041                 if (write_in_full(out_fd, buf, length) != length) {
1042                         ret = write_error();
1043                         goto out;
1044                 }
1045         }
1046         fclose(config_file);
1047  unlock_and_out:
1048         if (close(out_fd) || commit_lock_file(lock) < 0)
1049                         ret = error("Cannot commit config file!");
1050  out:
1051         free(config_filename);
1052         return ret;
1053 }