Merge branch 'bc/attr-ignore-case'
[git] / refs.c
1 #include "cache.h"
2 #include "refs.h"
3 #include "object.h"
4 #include "tag.h"
5 #include "dir.h"
6
7 /* ISSYMREF=01 and ISPACKED=02 are public interfaces */
8 #define REF_KNOWS_PEELED 04
9 #define REF_BROKEN 010
10
11 struct ref_entry {
12         unsigned char flag; /* ISSYMREF? ISPACKED? */
13         unsigned char sha1[20];
14         unsigned char peeled[20];
15         char name[FLEX_ARRAY];
16 };
17
18 struct ref_array {
19         int nr, alloc;
20         struct ref_entry **refs;
21 };
22
23 static const char *parse_ref_line(char *line, unsigned char *sha1)
24 {
25         /*
26          * 42: the answer to everything.
27          *
28          * In this case, it happens to be the answer to
29          *  40 (length of sha1 hex representation)
30          *  +1 (space in between hex and name)
31          *  +1 (newline at the end of the line)
32          */
33         int len = strlen(line) - 42;
34
35         if (len <= 0)
36                 return NULL;
37         if (get_sha1_hex(line, sha1) < 0)
38                 return NULL;
39         if (!isspace(line[40]))
40                 return NULL;
41         line += 41;
42         if (isspace(*line))
43                 return NULL;
44         if (line[len] != '\n')
45                 return NULL;
46         line[len] = 0;
47
48         return line;
49 }
50
51 static void add_ref(const char *name, const unsigned char *sha1,
52                     int flag, struct ref_array *refs,
53                     struct ref_entry **new_entry)
54 {
55         int len;
56         struct ref_entry *entry;
57
58         /* Allocate it and add it in.. */
59         len = strlen(name) + 1;
60         entry = xmalloc(sizeof(struct ref_entry) + len);
61         hashcpy(entry->sha1, sha1);
62         hashclr(entry->peeled);
63         if (check_refname_format(name, REFNAME_ALLOW_ONELEVEL|REFNAME_DOT_COMPONENT))
64                 die("Reference has invalid format: '%s'", name);
65         memcpy(entry->name, name, len);
66         entry->flag = flag;
67         if (new_entry)
68                 *new_entry = entry;
69         ALLOC_GROW(refs->refs, refs->nr + 1, refs->alloc);
70         refs->refs[refs->nr++] = entry;
71 }
72
73 static int ref_entry_cmp(const void *a, const void *b)
74 {
75         struct ref_entry *one = *(struct ref_entry **)a;
76         struct ref_entry *two = *(struct ref_entry **)b;
77         return strcmp(one->name, two->name);
78 }
79
80 static void sort_ref_array(struct ref_array *array)
81 {
82         int i = 0, j = 1;
83
84         /* Nothing to sort unless there are at least two entries */
85         if (array->nr < 2)
86                 return;
87
88         qsort(array->refs, array->nr, sizeof(*array->refs), ref_entry_cmp);
89
90         /* Remove any duplicates from the ref_array */
91         for (; j < array->nr; j++) {
92                 struct ref_entry *a = array->refs[i];
93                 struct ref_entry *b = array->refs[j];
94                 if (!strcmp(a->name, b->name)) {
95                         if (hashcmp(a->sha1, b->sha1))
96                                 die("Duplicated ref, and SHA1s don't match: %s",
97                                     a->name);
98                         warning("Duplicated ref: %s", a->name);
99                         free(b);
100                         continue;
101                 }
102                 i++;
103                 array->refs[i] = array->refs[j];
104         }
105         array->nr = i + 1;
106 }
107
108 static struct ref_entry *search_ref_array(struct ref_array *array, const char *name)
109 {
110         struct ref_entry *e, **r;
111         int len;
112
113         if (name == NULL)
114                 return NULL;
115
116         if (!array->nr)
117                 return NULL;
118
119         len = strlen(name) + 1;
120         e = xmalloc(sizeof(struct ref_entry) + len);
121         memcpy(e->name, name, len);
122
123         r = bsearch(&e, array->refs, array->nr, sizeof(*array->refs), ref_entry_cmp);
124
125         free(e);
126
127         if (r == NULL)
128                 return NULL;
129
130         return *r;
131 }
132
133 /*
134  * Future: need to be in "struct repository"
135  * when doing a full libification.
136  */
137 static struct cached_refs {
138         struct cached_refs *next;
139         char did_loose;
140         char did_packed;
141         struct ref_array loose;
142         struct ref_array packed;
143         /* The submodule name, or "" for the main repo. */
144         char name[FLEX_ARRAY];
145 } *cached_refs;
146
147 static struct ref_entry *current_ref;
148
149 static struct ref_array extra_refs;
150
151 static void free_ref_array(struct ref_array *array)
152 {
153         int i;
154         for (i = 0; i < array->nr; i++)
155                 free(array->refs[i]);
156         free(array->refs);
157         array->nr = array->alloc = 0;
158         array->refs = NULL;
159 }
160
161 static void clear_cached_refs(struct cached_refs *ca)
162 {
163         if (ca->did_loose)
164                 free_ref_array(&ca->loose);
165         if (ca->did_packed)
166                 free_ref_array(&ca->packed);
167         ca->did_loose = ca->did_packed = 0;
168 }
169
170 static struct cached_refs *create_cached_refs(const char *submodule)
171 {
172         int len;
173         struct cached_refs *refs;
174         if (!submodule)
175                 submodule = "";
176         len = strlen(submodule) + 1;
177         refs = xcalloc(1, sizeof(struct cached_refs) + len);
178         memcpy(refs->name, submodule, len);
179         return refs;
180 }
181
182 /*
183  * Return a pointer to a cached_refs for the specified submodule. For
184  * the main repository, use submodule==NULL. The returned structure
185  * will be allocated and initialized but not necessarily populated; it
186  * should not be freed.
187  */
188 static struct cached_refs *get_cached_refs(const char *submodule)
189 {
190         struct cached_refs *refs = cached_refs;
191         if (!submodule)
192                 submodule = "";
193         while (refs) {
194                 if (!strcmp(submodule, refs->name))
195                         return refs;
196                 refs = refs->next;
197         }
198
199         refs = create_cached_refs(submodule);
200         refs->next = cached_refs;
201         cached_refs = refs;
202         return refs;
203 }
204
205 static void invalidate_cached_refs(void)
206 {
207         struct cached_refs *refs = cached_refs;
208         while (refs) {
209                 clear_cached_refs(refs);
210                 refs = refs->next;
211         }
212 }
213
214 static void read_packed_refs(FILE *f, struct ref_array *array)
215 {
216         struct ref_entry *last = NULL;
217         char refline[PATH_MAX];
218         int flag = REF_ISPACKED;
219
220         while (fgets(refline, sizeof(refline), f)) {
221                 unsigned char sha1[20];
222                 const char *name;
223                 static const char header[] = "# pack-refs with:";
224
225                 if (!strncmp(refline, header, sizeof(header)-1)) {
226                         const char *traits = refline + sizeof(header) - 1;
227                         if (strstr(traits, " peeled "))
228                                 flag |= REF_KNOWS_PEELED;
229                         /* perhaps other traits later as well */
230                         continue;
231                 }
232
233                 name = parse_ref_line(refline, sha1);
234                 if (name) {
235                         add_ref(name, sha1, flag, array, &last);
236                         continue;
237                 }
238                 if (last &&
239                     refline[0] == '^' &&
240                     strlen(refline) == 42 &&
241                     refline[41] == '\n' &&
242                     !get_sha1_hex(refline + 1, sha1))
243                         hashcpy(last->peeled, sha1);
244         }
245         sort_ref_array(array);
246 }
247
248 void add_extra_ref(const char *name, const unsigned char *sha1, int flag)
249 {
250         add_ref(name, sha1, flag, &extra_refs, NULL);
251 }
252
253 void clear_extra_refs(void)
254 {
255         free_ref_array(&extra_refs);
256 }
257
258 static struct ref_array *get_packed_refs(const char *submodule)
259 {
260         struct cached_refs *refs = get_cached_refs(submodule);
261
262         if (!refs->did_packed) {
263                 const char *packed_refs_file;
264                 FILE *f;
265
266                 if (submodule)
267                         packed_refs_file = git_path_submodule(submodule, "packed-refs");
268                 else
269                         packed_refs_file = git_path("packed-refs");
270                 f = fopen(packed_refs_file, "r");
271                 if (f) {
272                         read_packed_refs(f, &refs->packed);
273                         fclose(f);
274                 }
275                 refs->did_packed = 1;
276         }
277         return &refs->packed;
278 }
279
280 static void get_ref_dir(const char *submodule, const char *base,
281                         struct ref_array *array)
282 {
283         DIR *dir;
284         const char *path;
285
286         if (submodule)
287                 path = git_path_submodule(submodule, "%s", base);
288         else
289                 path = git_path("%s", base);
290
291
292         dir = opendir(path);
293
294         if (dir) {
295                 struct dirent *de;
296                 int baselen = strlen(base);
297                 char *ref = xmalloc(baselen + 257);
298
299                 memcpy(ref, base, baselen);
300                 if (baselen && base[baselen-1] != '/')
301                         ref[baselen++] = '/';
302
303                 while ((de = readdir(dir)) != NULL) {
304                         unsigned char sha1[20];
305                         struct stat st;
306                         int flag;
307                         int namelen;
308                         const char *refdir;
309
310                         if (de->d_name[0] == '.')
311                                 continue;
312                         namelen = strlen(de->d_name);
313                         if (namelen > 255)
314                                 continue;
315                         if (has_extension(de->d_name, ".lock"))
316                                 continue;
317                         memcpy(ref + baselen, de->d_name, namelen+1);
318                         refdir = submodule
319                                 ? git_path_submodule(submodule, "%s", ref)
320                                 : git_path("%s", ref);
321                         if (stat(refdir, &st) < 0)
322                                 continue;
323                         if (S_ISDIR(st.st_mode)) {
324                                 get_ref_dir(submodule, ref, array);
325                                 continue;
326                         }
327                         if (submodule) {
328                                 hashclr(sha1);
329                                 flag = 0;
330                                 if (resolve_gitlink_ref(submodule, ref, sha1) < 0) {
331                                         hashclr(sha1);
332                                         flag |= REF_BROKEN;
333                                 }
334                         } else
335                                 if (!resolve_ref(ref, sha1, 1, &flag)) {
336                                         hashclr(sha1);
337                                         flag |= REF_BROKEN;
338                                 }
339                         add_ref(ref, sha1, flag, array, NULL);
340                 }
341                 free(ref);
342                 closedir(dir);
343         }
344 }
345
346 struct warn_if_dangling_data {
347         FILE *fp;
348         const char *refname;
349         const char *msg_fmt;
350 };
351
352 static int warn_if_dangling_symref(const char *refname, const unsigned char *sha1,
353                                    int flags, void *cb_data)
354 {
355         struct warn_if_dangling_data *d = cb_data;
356         const char *resolves_to;
357         unsigned char junk[20];
358
359         if (!(flags & REF_ISSYMREF))
360                 return 0;
361
362         resolves_to = resolve_ref(refname, junk, 0, NULL);
363         if (!resolves_to || strcmp(resolves_to, d->refname))
364                 return 0;
365
366         fprintf(d->fp, d->msg_fmt, refname);
367         return 0;
368 }
369
370 void warn_dangling_symref(FILE *fp, const char *msg_fmt, const char *refname)
371 {
372         struct warn_if_dangling_data data;
373
374         data.fp = fp;
375         data.refname = refname;
376         data.msg_fmt = msg_fmt;
377         for_each_rawref(warn_if_dangling_symref, &data);
378 }
379
380 static struct ref_array *get_loose_refs(const char *submodule)
381 {
382         struct cached_refs *refs = get_cached_refs(submodule);
383
384         if (!refs->did_loose) {
385                 get_ref_dir(submodule, "refs", &refs->loose);
386                 sort_ref_array(&refs->loose);
387                 refs->did_loose = 1;
388         }
389         return &refs->loose;
390 }
391
392 /* We allow "recursive" symbolic refs. Only within reason, though */
393 #define MAXDEPTH 5
394 #define MAXREFLEN (1024)
395
396 /*
397  * Called by resolve_gitlink_ref_recursive() after it failed to read
398  * from "name", which is "module/.git/<refname>". Find <refname> in
399  * the packed-refs file for the submodule.
400  */
401 static int resolve_gitlink_packed_ref(char *name, int pathlen, const char *refname, unsigned char *result)
402 {
403         int retval = -1;
404         struct ref_entry *ref;
405         struct ref_array *array;
406
407         /* being defensive: resolve_gitlink_ref() did this for us */
408         if (pathlen < 6 || memcmp(name + pathlen - 6, "/.git/", 6))
409                 die("Oops");
410         name[pathlen - 6] = '\0'; /* make it path to the submodule */
411         array = get_packed_refs(name);
412         ref = search_ref_array(array, refname);
413         if (ref != NULL) {
414                 memcpy(result, ref->sha1, 20);
415                 retval = 0;
416         }
417         return retval;
418 }
419
420 static int resolve_gitlink_ref_recursive(char *name, int pathlen, const char *refname, unsigned char *result, int recursion)
421 {
422         int fd, len = strlen(refname);
423         char buffer[128], *p;
424
425         if (recursion > MAXDEPTH || len > MAXREFLEN)
426                 return -1;
427         memcpy(name + pathlen, refname, len+1);
428         fd = open(name, O_RDONLY);
429         if (fd < 0)
430                 return resolve_gitlink_packed_ref(name, pathlen, refname, result);
431
432         len = read(fd, buffer, sizeof(buffer)-1);
433         close(fd);
434         if (len < 0)
435                 return -1;
436         while (len && isspace(buffer[len-1]))
437                 len--;
438         buffer[len] = 0;
439
440         /* Was it a detached head or an old-fashioned symlink? */
441         if (!get_sha1_hex(buffer, result))
442                 return 0;
443
444         /* Symref? */
445         if (strncmp(buffer, "ref:", 4))
446                 return -1;
447         p = buffer + 4;
448         while (isspace(*p))
449                 p++;
450
451         return resolve_gitlink_ref_recursive(name, pathlen, p, result, recursion+1);
452 }
453
454 int resolve_gitlink_ref(const char *path, const char *refname, unsigned char *result)
455 {
456         int len = strlen(path), retval;
457         char *gitdir;
458         const char *tmp;
459
460         while (len && path[len-1] == '/')
461                 len--;
462         if (!len)
463                 return -1;
464         gitdir = xmalloc(len + MAXREFLEN + 8);
465         memcpy(gitdir, path, len);
466         memcpy(gitdir + len, "/.git", 6);
467         len += 5;
468
469         tmp = read_gitfile(gitdir);
470         if (tmp) {
471                 free(gitdir);
472                 len = strlen(tmp);
473                 gitdir = xmalloc(len + MAXREFLEN + 3);
474                 memcpy(gitdir, tmp, len);
475         }
476         gitdir[len] = '/';
477         gitdir[++len] = '\0';
478         retval = resolve_gitlink_ref_recursive(gitdir, len, refname, result, 0);
479         free(gitdir);
480         return retval;
481 }
482
483 /*
484  * Try to read ref from the packed references.  On success, set sha1
485  * and return 0; otherwise, return -1.
486  */
487 static int get_packed_ref(const char *ref, unsigned char *sha1)
488 {
489         struct ref_array *packed = get_packed_refs(NULL);
490         struct ref_entry *entry = search_ref_array(packed, ref);
491         if (entry) {
492                 hashcpy(sha1, entry->sha1);
493                 return 0;
494         }
495         return -1;
496 }
497
498 const char *resolve_ref(const char *ref, unsigned char *sha1, int reading, int *flag)
499 {
500         int depth = MAXDEPTH;
501         ssize_t len;
502         char buffer[256];
503         static char ref_buffer[256];
504         char path[PATH_MAX];
505
506         if (flag)
507                 *flag = 0;
508
509         if (check_refname_format(ref, REFNAME_ALLOW_ONELEVEL))
510                 return NULL;
511
512         for (;;) {
513                 struct stat st;
514                 char *buf;
515                 int fd;
516
517                 if (--depth < 0)
518                         return NULL;
519
520                 git_snpath(path, sizeof(path), "%s", ref);
521
522                 if (lstat(path, &st) < 0) {
523                         if (errno != ENOENT)
524                                 return NULL;
525                         /*
526                          * The loose reference file does not exist;
527                          * check for a packed reference.
528                          */
529                         if (!get_packed_ref(ref, sha1)) {
530                                 if (flag)
531                                         *flag |= REF_ISPACKED;
532                                 return ref;
533                         }
534                         /* The reference is not a packed reference, either. */
535                         if (reading) {
536                                 return NULL;
537                         } else {
538                                 hashclr(sha1);
539                                 return ref;
540                         }
541                 }
542
543                 /* Follow "normalized" - ie "refs/.." symlinks by hand */
544                 if (S_ISLNK(st.st_mode)) {
545                         len = readlink(path, buffer, sizeof(buffer)-1);
546                         if (len < 0)
547                                 return NULL;
548                         buffer[len] = 0;
549                         if (!prefixcmp(buffer, "refs/") &&
550                                         !check_refname_format(buffer, 0)) {
551                                 strcpy(ref_buffer, buffer);
552                                 ref = ref_buffer;
553                                 if (flag)
554                                         *flag |= REF_ISSYMREF;
555                                 continue;
556                         }
557                 }
558
559                 /* Is it a directory? */
560                 if (S_ISDIR(st.st_mode)) {
561                         errno = EISDIR;
562                         return NULL;
563                 }
564
565                 /*
566                  * Anything else, just open it and try to use it as
567                  * a ref
568                  */
569                 fd = open(path, O_RDONLY);
570                 if (fd < 0)
571                         return NULL;
572                 len = read_in_full(fd, buffer, sizeof(buffer)-1);
573                 close(fd);
574                 if (len < 0)
575                         return NULL;
576                 while (len && isspace(buffer[len-1]))
577                         len--;
578                 buffer[len] = '\0';
579
580                 /*
581                  * Is it a symbolic ref?
582                  */
583                 if (prefixcmp(buffer, "ref:"))
584                         break;
585                 buf = buffer + 4;
586                 while (isspace(*buf))
587                         buf++;
588                 if (check_refname_format(buf, REFNAME_ALLOW_ONELEVEL)) {
589                         warning("symbolic reference in %s is formatted incorrectly",
590                                 path);
591                         return NULL;
592                 }
593                 ref = strcpy(ref_buffer, buf);
594                 if (flag)
595                         *flag |= REF_ISSYMREF;
596         }
597         /* Please note that FETCH_HEAD has a second line containing other data. */
598         if (get_sha1_hex(buffer, sha1) || (buffer[40] != '\0' && !isspace(buffer[40]))) {
599                 warning("reference in %s is formatted incorrectly", path);
600                 return NULL;
601         }
602         return ref;
603 }
604
605 /* The argument to filter_refs */
606 struct ref_filter {
607         const char *pattern;
608         each_ref_fn *fn;
609         void *cb_data;
610 };
611
612 int read_ref(const char *ref, unsigned char *sha1)
613 {
614         if (resolve_ref(ref, sha1, 1, NULL))
615                 return 0;
616         return -1;
617 }
618
619 #define DO_FOR_EACH_INCLUDE_BROKEN 01
620 static int do_one_ref(const char *base, each_ref_fn fn, int trim,
621                       int flags, void *cb_data, struct ref_entry *entry)
622 {
623         if (prefixcmp(entry->name, base))
624                 return 0;
625
626         if (!(flags & DO_FOR_EACH_INCLUDE_BROKEN)) {
627                 if (entry->flag & REF_BROKEN)
628                         return 0; /* ignore dangling symref */
629                 if (!has_sha1_file(entry->sha1)) {
630                         error("%s does not point to a valid object!", entry->name);
631                         return 0;
632                 }
633         }
634         current_ref = entry;
635         return fn(entry->name + trim, entry->sha1, entry->flag, cb_data);
636 }
637
638 static int filter_refs(const char *ref, const unsigned char *sha, int flags,
639         void *data)
640 {
641         struct ref_filter *filter = (struct ref_filter *)data;
642         if (fnmatch(filter->pattern, ref, 0))
643                 return 0;
644         return filter->fn(ref, sha, flags, filter->cb_data);
645 }
646
647 int peel_ref(const char *ref, unsigned char *sha1)
648 {
649         int flag;
650         unsigned char base[20];
651         struct object *o;
652
653         if (current_ref && (current_ref->name == ref
654                 || !strcmp(current_ref->name, ref))) {
655                 if (current_ref->flag & REF_KNOWS_PEELED) {
656                         hashcpy(sha1, current_ref->peeled);
657                         return 0;
658                 }
659                 hashcpy(base, current_ref->sha1);
660                 goto fallback;
661         }
662
663         if (!resolve_ref(ref, base, 1, &flag))
664                 return -1;
665
666         if ((flag & REF_ISPACKED)) {
667                 struct ref_array *array = get_packed_refs(NULL);
668                 struct ref_entry *r = search_ref_array(array, ref);
669
670                 if (r != NULL && r->flag & REF_KNOWS_PEELED) {
671                         hashcpy(sha1, r->peeled);
672                         return 0;
673                 }
674         }
675
676 fallback:
677         o = parse_object(base);
678         if (o && o->type == OBJ_TAG) {
679                 o = deref_tag(o, ref, 0);
680                 if (o) {
681                         hashcpy(sha1, o->sha1);
682                         return 0;
683                 }
684         }
685         return -1;
686 }
687
688 static int do_for_each_ref(const char *submodule, const char *base, each_ref_fn fn,
689                            int trim, int flags, void *cb_data)
690 {
691         int retval = 0, i, p = 0, l = 0;
692         struct ref_array *packed = get_packed_refs(submodule);
693         struct ref_array *loose = get_loose_refs(submodule);
694
695         struct ref_array *extra = &extra_refs;
696
697         for (i = 0; i < extra->nr; i++)
698                 retval = do_one_ref(base, fn, trim, flags, cb_data, extra->refs[i]);
699
700         while (p < packed->nr && l < loose->nr) {
701                 struct ref_entry *entry;
702                 int cmp = strcmp(packed->refs[p]->name, loose->refs[l]->name);
703                 if (!cmp) {
704                         p++;
705                         continue;
706                 }
707                 if (cmp > 0) {
708                         entry = loose->refs[l++];
709                 } else {
710                         entry = packed->refs[p++];
711                 }
712                 retval = do_one_ref(base, fn, trim, flags, cb_data, entry);
713                 if (retval)
714                         goto end_each;
715         }
716
717         if (l < loose->nr) {
718                 p = l;
719                 packed = loose;
720         }
721
722         for (; p < packed->nr; p++) {
723                 retval = do_one_ref(base, fn, trim, flags, cb_data, packed->refs[p]);
724                 if (retval)
725                         goto end_each;
726         }
727
728 end_each:
729         current_ref = NULL;
730         return retval;
731 }
732
733
734 static int do_head_ref(const char *submodule, each_ref_fn fn, void *cb_data)
735 {
736         unsigned char sha1[20];
737         int flag;
738
739         if (submodule) {
740                 if (resolve_gitlink_ref(submodule, "HEAD", sha1) == 0)
741                         return fn("HEAD", sha1, 0, cb_data);
742
743                 return 0;
744         }
745
746         if (resolve_ref("HEAD", sha1, 1, &flag))
747                 return fn("HEAD", sha1, flag, cb_data);
748
749         return 0;
750 }
751
752 int head_ref(each_ref_fn fn, void *cb_data)
753 {
754         return do_head_ref(NULL, fn, cb_data);
755 }
756
757 int head_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
758 {
759         return do_head_ref(submodule, fn, cb_data);
760 }
761
762 int for_each_ref(each_ref_fn fn, void *cb_data)
763 {
764         return do_for_each_ref(NULL, "", fn, 0, 0, cb_data);
765 }
766
767 int for_each_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
768 {
769         return do_for_each_ref(submodule, "", fn, 0, 0, cb_data);
770 }
771
772 int for_each_ref_in(const char *prefix, each_ref_fn fn, void *cb_data)
773 {
774         return do_for_each_ref(NULL, prefix, fn, strlen(prefix), 0, cb_data);
775 }
776
777 int for_each_ref_in_submodule(const char *submodule, const char *prefix,
778                 each_ref_fn fn, void *cb_data)
779 {
780         return do_for_each_ref(submodule, prefix, fn, strlen(prefix), 0, cb_data);
781 }
782
783 int for_each_tag_ref(each_ref_fn fn, void *cb_data)
784 {
785         return for_each_ref_in("refs/tags/", fn, cb_data);
786 }
787
788 int for_each_tag_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
789 {
790         return for_each_ref_in_submodule(submodule, "refs/tags/", fn, cb_data);
791 }
792
793 int for_each_branch_ref(each_ref_fn fn, void *cb_data)
794 {
795         return for_each_ref_in("refs/heads/", fn, cb_data);
796 }
797
798 int for_each_branch_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
799 {
800         return for_each_ref_in_submodule(submodule, "refs/heads/", fn, cb_data);
801 }
802
803 int for_each_remote_ref(each_ref_fn fn, void *cb_data)
804 {
805         return for_each_ref_in("refs/remotes/", fn, cb_data);
806 }
807
808 int for_each_remote_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
809 {
810         return for_each_ref_in_submodule(submodule, "refs/remotes/", fn, cb_data);
811 }
812
813 int for_each_replace_ref(each_ref_fn fn, void *cb_data)
814 {
815         return do_for_each_ref(NULL, "refs/replace/", fn, 13, 0, cb_data);
816 }
817
818 int head_ref_namespaced(each_ref_fn fn, void *cb_data)
819 {
820         struct strbuf buf = STRBUF_INIT;
821         int ret = 0;
822         unsigned char sha1[20];
823         int flag;
824
825         strbuf_addf(&buf, "%sHEAD", get_git_namespace());
826         if (resolve_ref(buf.buf, sha1, 1, &flag))
827                 ret = fn(buf.buf, sha1, flag, cb_data);
828         strbuf_release(&buf);
829
830         return ret;
831 }
832
833 int for_each_namespaced_ref(each_ref_fn fn, void *cb_data)
834 {
835         struct strbuf buf = STRBUF_INIT;
836         int ret;
837         strbuf_addf(&buf, "%srefs/", get_git_namespace());
838         ret = do_for_each_ref(NULL, buf.buf, fn, 0, 0, cb_data);
839         strbuf_release(&buf);
840         return ret;
841 }
842
843 int for_each_glob_ref_in(each_ref_fn fn, const char *pattern,
844         const char *prefix, void *cb_data)
845 {
846         struct strbuf real_pattern = STRBUF_INIT;
847         struct ref_filter filter;
848         int ret;
849
850         if (!prefix && prefixcmp(pattern, "refs/"))
851                 strbuf_addstr(&real_pattern, "refs/");
852         else if (prefix)
853                 strbuf_addstr(&real_pattern, prefix);
854         strbuf_addstr(&real_pattern, pattern);
855
856         if (!has_glob_specials(pattern)) {
857                 /* Append implied '/' '*' if not present. */
858                 if (real_pattern.buf[real_pattern.len - 1] != '/')
859                         strbuf_addch(&real_pattern, '/');
860                 /* No need to check for '*', there is none. */
861                 strbuf_addch(&real_pattern, '*');
862         }
863
864         filter.pattern = real_pattern.buf;
865         filter.fn = fn;
866         filter.cb_data = cb_data;
867         ret = for_each_ref(filter_refs, &filter);
868
869         strbuf_release(&real_pattern);
870         return ret;
871 }
872
873 int for_each_glob_ref(each_ref_fn fn, const char *pattern, void *cb_data)
874 {
875         return for_each_glob_ref_in(fn, pattern, NULL, cb_data);
876 }
877
878 int for_each_rawref(each_ref_fn fn, void *cb_data)
879 {
880         return do_for_each_ref(NULL, "", fn, 0,
881                                DO_FOR_EACH_INCLUDE_BROKEN, cb_data);
882 }
883
884 /*
885  * Make sure "ref" is something reasonable to have under ".git/refs/";
886  * We do not like it if:
887  *
888  * - any path component of it begins with ".", or
889  * - it has double dots "..", or
890  * - it has ASCII control character, "~", "^", ":" or SP, anywhere, or
891  * - it ends with a "/".
892  * - it ends with ".lock"
893  * - it contains a "\" (backslash)
894  */
895
896 /* Return true iff ch is not allowed in reference names. */
897 static inline int bad_ref_char(int ch)
898 {
899         if (((unsigned) ch) <= ' ' || ch == 0x7f ||
900             ch == '~' || ch == '^' || ch == ':' || ch == '\\')
901                 return 1;
902         /* 2.13 Pattern Matching Notation */
903         if (ch == '*' || ch == '?' || ch == '[') /* Unsupported */
904                 return 1;
905         return 0;
906 }
907
908 /*
909  * Try to read one refname component from the front of ref.  Return
910  * the length of the component found, or -1 if the component is not
911  * legal.
912  */
913 static int check_refname_component(const char *ref, int flags)
914 {
915         const char *cp;
916         char last = '\0';
917
918         for (cp = ref; ; cp++) {
919                 char ch = *cp;
920                 if (ch == '\0' || ch == '/')
921                         break;
922                 if (bad_ref_char(ch))
923                         return -1; /* Illegal character in refname. */
924                 if (last == '.' && ch == '.')
925                         return -1; /* Refname contains "..". */
926                 if (last == '@' && ch == '{')
927                         return -1; /* Refname contains "@{". */
928                 last = ch;
929         }
930         if (cp == ref)
931                 return -1; /* Component has zero length. */
932         if (ref[0] == '.') {
933                 if (!(flags & REFNAME_DOT_COMPONENT))
934                         return -1; /* Component starts with '.'. */
935                 /*
936                  * Even if leading dots are allowed, don't allow "."
937                  * as a component (".." is prevented by a rule above).
938                  */
939                 if (ref[1] == '\0')
940                         return -1; /* Component equals ".". */
941         }
942         if (cp - ref >= 5 && !memcmp(cp - 5, ".lock", 5))
943                 return -1; /* Refname ends with ".lock". */
944         return cp - ref;
945 }
946
947 int check_refname_format(const char *ref, int flags)
948 {
949         int component_len, component_count = 0;
950
951         while (1) {
952                 /* We are at the start of a path component. */
953                 component_len = check_refname_component(ref, flags);
954                 if (component_len < 0) {
955                         if ((flags & REFNAME_REFSPEC_PATTERN) &&
956                                         ref[0] == '*' &&
957                                         (ref[1] == '\0' || ref[1] == '/')) {
958                                 /* Accept one wildcard as a full refname component. */
959                                 flags &= ~REFNAME_REFSPEC_PATTERN;
960                                 component_len = 1;
961                         } else {
962                                 return -1;
963                         }
964                 }
965                 component_count++;
966                 if (ref[component_len] == '\0')
967                         break;
968                 /* Skip to next component. */
969                 ref += component_len + 1;
970         }
971
972         if (ref[component_len - 1] == '.')
973                 return -1; /* Refname ends with '.'. */
974         if (!(flags & REFNAME_ALLOW_ONELEVEL) && component_count < 2)
975                 return -1; /* Refname has only one component. */
976         return 0;
977 }
978
979 const char *prettify_refname(const char *name)
980 {
981         return name + (
982                 !prefixcmp(name, "refs/heads/") ? 11 :
983                 !prefixcmp(name, "refs/tags/") ? 10 :
984                 !prefixcmp(name, "refs/remotes/") ? 13 :
985                 0);
986 }
987
988 const char *ref_rev_parse_rules[] = {
989         "%.*s",
990         "refs/%.*s",
991         "refs/tags/%.*s",
992         "refs/heads/%.*s",
993         "refs/remotes/%.*s",
994         "refs/remotes/%.*s/HEAD",
995         NULL
996 };
997
998 const char *ref_fetch_rules[] = {
999         "%.*s",
1000         "refs/%.*s",
1001         "refs/heads/%.*s",
1002         NULL
1003 };
1004
1005 int refname_match(const char *abbrev_name, const char *full_name, const char **rules)
1006 {
1007         const char **p;
1008         const int abbrev_name_len = strlen(abbrev_name);
1009
1010         for (p = rules; *p; p++) {
1011                 if (!strcmp(full_name, mkpath(*p, abbrev_name_len, abbrev_name))) {
1012                         return 1;
1013                 }
1014         }
1015
1016         return 0;
1017 }
1018
1019 static struct ref_lock *verify_lock(struct ref_lock *lock,
1020         const unsigned char *old_sha1, int mustexist)
1021 {
1022         if (!resolve_ref(lock->ref_name, lock->old_sha1, mustexist, NULL)) {
1023                 error("Can't verify ref %s", lock->ref_name);
1024                 unlock_ref(lock);
1025                 return NULL;
1026         }
1027         if (hashcmp(lock->old_sha1, old_sha1)) {
1028                 error("Ref %s is at %s but expected %s", lock->ref_name,
1029                         sha1_to_hex(lock->old_sha1), sha1_to_hex(old_sha1));
1030                 unlock_ref(lock);
1031                 return NULL;
1032         }
1033         return lock;
1034 }
1035
1036 static int remove_empty_directories(const char *file)
1037 {
1038         /* we want to create a file but there is a directory there;
1039          * if that is an empty directory (or a directory that contains
1040          * only empty directories), remove them.
1041          */
1042         struct strbuf path;
1043         int result;
1044
1045         strbuf_init(&path, 20);
1046         strbuf_addstr(&path, file);
1047
1048         result = remove_dir_recursively(&path, REMOVE_DIR_EMPTY_ONLY);
1049
1050         strbuf_release(&path);
1051
1052         return result;
1053 }
1054
1055 static int is_refname_available(const char *ref, const char *oldref,
1056                                 struct ref_array *array, int quiet)
1057 {
1058         int i, namlen = strlen(ref); /* e.g. 'foo/bar' */
1059         for (i = 0; i < array->nr; i++ ) {
1060                 struct ref_entry *entry = array->refs[i];
1061                 /* entry->name could be 'foo' or 'foo/bar/baz' */
1062                 if (!oldref || strcmp(oldref, entry->name)) {
1063                         int len = strlen(entry->name);
1064                         int cmplen = (namlen < len) ? namlen : len;
1065                         const char *lead = (namlen < len) ? entry->name : ref;
1066                         if (!strncmp(ref, entry->name, cmplen) &&
1067                             lead[cmplen] == '/') {
1068                                 if (!quiet)
1069                                         error("'%s' exists; cannot create '%s'",
1070                                               entry->name, ref);
1071                                 return 0;
1072                         }
1073                 }
1074         }
1075         return 1;
1076 }
1077
1078 static struct ref_lock *lock_ref_sha1_basic(const char *ref, const unsigned char *old_sha1, int flags, int *type_p)
1079 {
1080         char *ref_file;
1081         const char *orig_ref = ref;
1082         struct ref_lock *lock;
1083         int last_errno = 0;
1084         int type, lflags;
1085         int mustexist = (old_sha1 && !is_null_sha1(old_sha1));
1086         int missing = 0;
1087
1088         lock = xcalloc(1, sizeof(struct ref_lock));
1089         lock->lock_fd = -1;
1090
1091         ref = resolve_ref(ref, lock->old_sha1, mustexist, &type);
1092         if (!ref && errno == EISDIR) {
1093                 /* we are trying to lock foo but we used to
1094                  * have foo/bar which now does not exist;
1095                  * it is normal for the empty directory 'foo'
1096                  * to remain.
1097                  */
1098                 ref_file = git_path("%s", orig_ref);
1099                 if (remove_empty_directories(ref_file)) {
1100                         last_errno = errno;
1101                         error("there are still refs under '%s'", orig_ref);
1102                         goto error_return;
1103                 }
1104                 ref = resolve_ref(orig_ref, lock->old_sha1, mustexist, &type);
1105         }
1106         if (type_p)
1107             *type_p = type;
1108         if (!ref) {
1109                 last_errno = errno;
1110                 error("unable to resolve reference %s: %s",
1111                         orig_ref, strerror(errno));
1112                 goto error_return;
1113         }
1114         missing = is_null_sha1(lock->old_sha1);
1115         /* When the ref did not exist and we are creating it,
1116          * make sure there is no existing ref that is packed
1117          * whose name begins with our refname, nor a ref whose
1118          * name is a proper prefix of our refname.
1119          */
1120         if (missing &&
1121              !is_refname_available(ref, NULL, get_packed_refs(NULL), 0)) {
1122                 last_errno = ENOTDIR;
1123                 goto error_return;
1124         }
1125
1126         lock->lk = xcalloc(1, sizeof(struct lock_file));
1127
1128         lflags = LOCK_DIE_ON_ERROR;
1129         if (flags & REF_NODEREF) {
1130                 ref = orig_ref;
1131                 lflags |= LOCK_NODEREF;
1132         }
1133         lock->ref_name = xstrdup(ref);
1134         lock->orig_ref_name = xstrdup(orig_ref);
1135         ref_file = git_path("%s", ref);
1136         if (missing)
1137                 lock->force_write = 1;
1138         if ((flags & REF_NODEREF) && (type & REF_ISSYMREF))
1139                 lock->force_write = 1;
1140
1141         if (safe_create_leading_directories(ref_file)) {
1142                 last_errno = errno;
1143                 error("unable to create directory for %s", ref_file);
1144                 goto error_return;
1145         }
1146
1147         lock->lock_fd = hold_lock_file_for_update(lock->lk, ref_file, lflags);
1148         return old_sha1 ? verify_lock(lock, old_sha1, mustexist) : lock;
1149
1150  error_return:
1151         unlock_ref(lock);
1152         errno = last_errno;
1153         return NULL;
1154 }
1155
1156 struct ref_lock *lock_ref_sha1(const char *ref, const unsigned char *old_sha1)
1157 {
1158         char refpath[PATH_MAX];
1159         if (check_refname_format(ref, 0))
1160                 return NULL;
1161         strcpy(refpath, mkpath("refs/%s", ref));
1162         return lock_ref_sha1_basic(refpath, old_sha1, 0, NULL);
1163 }
1164
1165 struct ref_lock *lock_any_ref_for_update(const char *ref, const unsigned char *old_sha1, int flags)
1166 {
1167         if (check_refname_format(ref, REFNAME_ALLOW_ONELEVEL))
1168                 return NULL;
1169         return lock_ref_sha1_basic(ref, old_sha1, flags, NULL);
1170 }
1171
1172 static struct lock_file packlock;
1173
1174 static int repack_without_ref(const char *refname)
1175 {
1176         struct ref_array *packed;
1177         struct ref_entry *ref;
1178         int fd, i;
1179
1180         packed = get_packed_refs(NULL);
1181         ref = search_ref_array(packed, refname);
1182         if (ref == NULL)
1183                 return 0;
1184         fd = hold_lock_file_for_update(&packlock, git_path("packed-refs"), 0);
1185         if (fd < 0) {
1186                 unable_to_lock_error(git_path("packed-refs"), errno);
1187                 return error("cannot delete '%s' from packed refs", refname);
1188         }
1189
1190         for (i = 0; i < packed->nr; i++) {
1191                 char line[PATH_MAX + 100];
1192                 int len;
1193
1194                 ref = packed->refs[i];
1195
1196                 if (!strcmp(refname, ref->name))
1197                         continue;
1198                 len = snprintf(line, sizeof(line), "%s %s\n",
1199                                sha1_to_hex(ref->sha1), ref->name);
1200                 /* this should not happen but just being defensive */
1201                 if (len > sizeof(line))
1202                         die("too long a refname '%s'", ref->name);
1203                 write_or_die(fd, line, len);
1204         }
1205         return commit_lock_file(&packlock);
1206 }
1207
1208 int delete_ref(const char *refname, const unsigned char *sha1, int delopt)
1209 {
1210         struct ref_lock *lock;
1211         int err, i = 0, ret = 0, flag = 0;
1212
1213         lock = lock_ref_sha1_basic(refname, sha1, 0, &flag);
1214         if (!lock)
1215                 return 1;
1216         if (!(flag & REF_ISPACKED) || flag & REF_ISSYMREF) {
1217                 /* loose */
1218                 const char *path;
1219
1220                 if (!(delopt & REF_NODEREF)) {
1221                         i = strlen(lock->lk->filename) - 5; /* .lock */
1222                         lock->lk->filename[i] = 0;
1223                         path = lock->lk->filename;
1224                 } else {
1225                         path = git_path("%s", refname);
1226                 }
1227                 err = unlink_or_warn(path);
1228                 if (err && errno != ENOENT)
1229                         ret = 1;
1230
1231                 if (!(delopt & REF_NODEREF))
1232                         lock->lk->filename[i] = '.';
1233         }
1234         /* removing the loose one could have resurrected an earlier
1235          * packed one.  Also, if it was not loose we need to repack
1236          * without it.
1237          */
1238         ret |= repack_without_ref(refname);
1239
1240         unlink_or_warn(git_path("logs/%s", lock->ref_name));
1241         invalidate_cached_refs();
1242         unlock_ref(lock);
1243         return ret;
1244 }
1245
1246 /*
1247  * People using contrib's git-new-workdir have .git/logs/refs ->
1248  * /some/other/path/.git/logs/refs, and that may live on another device.
1249  *
1250  * IOW, to avoid cross device rename errors, the temporary renamed log must
1251  * live into logs/refs.
1252  */
1253 #define TMP_RENAMED_LOG  "logs/refs/.tmp-renamed-log"
1254
1255 int rename_ref(const char *oldref, const char *newref, const char *logmsg)
1256 {
1257         static const char renamed_ref[] = "RENAMED-REF";
1258         unsigned char sha1[20], orig_sha1[20];
1259         int flag = 0, logmoved = 0;
1260         struct ref_lock *lock;
1261         struct stat loginfo;
1262         int log = !lstat(git_path("logs/%s", oldref), &loginfo);
1263         const char *symref = NULL;
1264
1265         if (log && S_ISLNK(loginfo.st_mode))
1266                 return error("reflog for %s is a symlink", oldref);
1267
1268         symref = resolve_ref(oldref, orig_sha1, 1, &flag);
1269         if (flag & REF_ISSYMREF)
1270                 return error("refname %s is a symbolic ref, renaming it is not supported",
1271                         oldref);
1272         if (!symref)
1273                 return error("refname %s not found", oldref);
1274
1275         if (!is_refname_available(newref, oldref, get_packed_refs(NULL), 0))
1276                 return 1;
1277
1278         if (!is_refname_available(newref, oldref, get_loose_refs(NULL), 0))
1279                 return 1;
1280
1281         lock = lock_ref_sha1_basic(renamed_ref, NULL, 0, NULL);
1282         if (!lock)
1283                 return error("unable to lock %s", renamed_ref);
1284         lock->force_write = 1;
1285         if (write_ref_sha1(lock, orig_sha1, logmsg))
1286                 return error("unable to save current sha1 in %s", renamed_ref);
1287
1288         if (log && rename(git_path("logs/%s", oldref), git_path(TMP_RENAMED_LOG)))
1289                 return error("unable to move logfile logs/%s to "TMP_RENAMED_LOG": %s",
1290                         oldref, strerror(errno));
1291
1292         if (delete_ref(oldref, orig_sha1, REF_NODEREF)) {
1293                 error("unable to delete old %s", oldref);
1294                 goto rollback;
1295         }
1296
1297         if (resolve_ref(newref, sha1, 1, &flag) && delete_ref(newref, sha1, REF_NODEREF)) {
1298                 if (errno==EISDIR) {
1299                         if (remove_empty_directories(git_path("%s", newref))) {
1300                                 error("Directory not empty: %s", newref);
1301                                 goto rollback;
1302                         }
1303                 } else {
1304                         error("unable to delete existing %s", newref);
1305                         goto rollback;
1306                 }
1307         }
1308
1309         if (log && safe_create_leading_directories(git_path("logs/%s", newref))) {
1310                 error("unable to create directory for %s", newref);
1311                 goto rollback;
1312         }
1313
1314  retry:
1315         if (log && rename(git_path(TMP_RENAMED_LOG), git_path("logs/%s", newref))) {
1316                 if (errno==EISDIR || errno==ENOTDIR) {
1317                         /*
1318                          * rename(a, b) when b is an existing
1319                          * directory ought to result in ISDIR, but
1320                          * Solaris 5.8 gives ENOTDIR.  Sheesh.
1321                          */
1322                         if (remove_empty_directories(git_path("logs/%s", newref))) {
1323                                 error("Directory not empty: logs/%s", newref);
1324                                 goto rollback;
1325                         }
1326                         goto retry;
1327                 } else {
1328                         error("unable to move logfile "TMP_RENAMED_LOG" to logs/%s: %s",
1329                                 newref, strerror(errno));
1330                         goto rollback;
1331                 }
1332         }
1333         logmoved = log;
1334
1335         lock = lock_ref_sha1_basic(newref, NULL, 0, NULL);
1336         if (!lock) {
1337                 error("unable to lock %s for update", newref);
1338                 goto rollback;
1339         }
1340         lock->force_write = 1;
1341         hashcpy(lock->old_sha1, orig_sha1);
1342         if (write_ref_sha1(lock, orig_sha1, logmsg)) {
1343                 error("unable to write current sha1 into %s", newref);
1344                 goto rollback;
1345         }
1346
1347         return 0;
1348
1349  rollback:
1350         lock = lock_ref_sha1_basic(oldref, NULL, 0, NULL);
1351         if (!lock) {
1352                 error("unable to lock %s for rollback", oldref);
1353                 goto rollbacklog;
1354         }
1355
1356         lock->force_write = 1;
1357         flag = log_all_ref_updates;
1358         log_all_ref_updates = 0;
1359         if (write_ref_sha1(lock, orig_sha1, NULL))
1360                 error("unable to write current sha1 into %s", oldref);
1361         log_all_ref_updates = flag;
1362
1363  rollbacklog:
1364         if (logmoved && rename(git_path("logs/%s", newref), git_path("logs/%s", oldref)))
1365                 error("unable to restore logfile %s from %s: %s",
1366                         oldref, newref, strerror(errno));
1367         if (!logmoved && log &&
1368             rename(git_path(TMP_RENAMED_LOG), git_path("logs/%s", oldref)))
1369                 error("unable to restore logfile %s from "TMP_RENAMED_LOG": %s",
1370                         oldref, strerror(errno));
1371
1372         return 1;
1373 }
1374
1375 int close_ref(struct ref_lock *lock)
1376 {
1377         if (close_lock_file(lock->lk))
1378                 return -1;
1379         lock->lock_fd = -1;
1380         return 0;
1381 }
1382
1383 int commit_ref(struct ref_lock *lock)
1384 {
1385         if (commit_lock_file(lock->lk))
1386                 return -1;
1387         lock->lock_fd = -1;
1388         return 0;
1389 }
1390
1391 void unlock_ref(struct ref_lock *lock)
1392 {
1393         /* Do not free lock->lk -- atexit() still looks at them */
1394         if (lock->lk)
1395                 rollback_lock_file(lock->lk);
1396         free(lock->ref_name);
1397         free(lock->orig_ref_name);
1398         free(lock);
1399 }
1400
1401 /*
1402  * copy the reflog message msg to buf, which has been allocated sufficiently
1403  * large, while cleaning up the whitespaces.  Especially, convert LF to space,
1404  * because reflog file is one line per entry.
1405  */
1406 static int copy_msg(char *buf, const char *msg)
1407 {
1408         char *cp = buf;
1409         char c;
1410         int wasspace = 1;
1411
1412         *cp++ = '\t';
1413         while ((c = *msg++)) {
1414                 if (wasspace && isspace(c))
1415                         continue;
1416                 wasspace = isspace(c);
1417                 if (wasspace)
1418                         c = ' ';
1419                 *cp++ = c;
1420         }
1421         while (buf < cp && isspace(cp[-1]))
1422                 cp--;
1423         *cp++ = '\n';
1424         return cp - buf;
1425 }
1426
1427 int log_ref_setup(const char *ref_name, char *logfile, int bufsize)
1428 {
1429         int logfd, oflags = O_APPEND | O_WRONLY;
1430
1431         git_snpath(logfile, bufsize, "logs/%s", ref_name);
1432         if (log_all_ref_updates &&
1433             (!prefixcmp(ref_name, "refs/heads/") ||
1434              !prefixcmp(ref_name, "refs/remotes/") ||
1435              !prefixcmp(ref_name, "refs/notes/") ||
1436              !strcmp(ref_name, "HEAD"))) {
1437                 if (safe_create_leading_directories(logfile) < 0)
1438                         return error("unable to create directory for %s",
1439                                      logfile);
1440                 oflags |= O_CREAT;
1441         }
1442
1443         logfd = open(logfile, oflags, 0666);
1444         if (logfd < 0) {
1445                 if (!(oflags & O_CREAT) && errno == ENOENT)
1446                         return 0;
1447
1448                 if ((oflags & O_CREAT) && errno == EISDIR) {
1449                         if (remove_empty_directories(logfile)) {
1450                                 return error("There are still logs under '%s'",
1451                                              logfile);
1452                         }
1453                         logfd = open(logfile, oflags, 0666);
1454                 }
1455
1456                 if (logfd < 0)
1457                         return error("Unable to append to %s: %s",
1458                                      logfile, strerror(errno));
1459         }
1460
1461         adjust_shared_perm(logfile);
1462         close(logfd);
1463         return 0;
1464 }
1465
1466 static int log_ref_write(const char *ref_name, const unsigned char *old_sha1,
1467                          const unsigned char *new_sha1, const char *msg)
1468 {
1469         int logfd, result, written, oflags = O_APPEND | O_WRONLY;
1470         unsigned maxlen, len;
1471         int msglen;
1472         char log_file[PATH_MAX];
1473         char *logrec;
1474         const char *committer;
1475
1476         if (log_all_ref_updates < 0)
1477                 log_all_ref_updates = !is_bare_repository();
1478
1479         result = log_ref_setup(ref_name, log_file, sizeof(log_file));
1480         if (result)
1481                 return result;
1482
1483         logfd = open(log_file, oflags);
1484         if (logfd < 0)
1485                 return 0;
1486         msglen = msg ? strlen(msg) : 0;
1487         committer = git_committer_info(0);
1488         maxlen = strlen(committer) + msglen + 100;
1489         logrec = xmalloc(maxlen);
1490         len = sprintf(logrec, "%s %s %s\n",
1491                       sha1_to_hex(old_sha1),
1492                       sha1_to_hex(new_sha1),
1493                       committer);
1494         if (msglen)
1495                 len += copy_msg(logrec + len - 1, msg) - 1;
1496         written = len <= maxlen ? write_in_full(logfd, logrec, len) : -1;
1497         free(logrec);
1498         if (close(logfd) != 0 || written != len)
1499                 return error("Unable to append to %s", log_file);
1500         return 0;
1501 }
1502
1503 static int is_branch(const char *refname)
1504 {
1505         return !strcmp(refname, "HEAD") || !prefixcmp(refname, "refs/heads/");
1506 }
1507
1508 int write_ref_sha1(struct ref_lock *lock,
1509         const unsigned char *sha1, const char *logmsg)
1510 {
1511         static char term = '\n';
1512         struct object *o;
1513
1514         if (!lock)
1515                 return -1;
1516         if (!lock->force_write && !hashcmp(lock->old_sha1, sha1)) {
1517                 unlock_ref(lock);
1518                 return 0;
1519         }
1520         o = parse_object(sha1);
1521         if (!o) {
1522                 error("Trying to write ref %s with nonexistent object %s",
1523                         lock->ref_name, sha1_to_hex(sha1));
1524                 unlock_ref(lock);
1525                 return -1;
1526         }
1527         if (o->type != OBJ_COMMIT && is_branch(lock->ref_name)) {
1528                 error("Trying to write non-commit object %s to branch %s",
1529                         sha1_to_hex(sha1), lock->ref_name);
1530                 unlock_ref(lock);
1531                 return -1;
1532         }
1533         if (write_in_full(lock->lock_fd, sha1_to_hex(sha1), 40) != 40 ||
1534             write_in_full(lock->lock_fd, &term, 1) != 1
1535                 || close_ref(lock) < 0) {
1536                 error("Couldn't write %s", lock->lk->filename);
1537                 unlock_ref(lock);
1538                 return -1;
1539         }
1540         invalidate_cached_refs();
1541         if (log_ref_write(lock->ref_name, lock->old_sha1, sha1, logmsg) < 0 ||
1542             (strcmp(lock->ref_name, lock->orig_ref_name) &&
1543              log_ref_write(lock->orig_ref_name, lock->old_sha1, sha1, logmsg) < 0)) {
1544                 unlock_ref(lock);
1545                 return -1;
1546         }
1547         if (strcmp(lock->orig_ref_name, "HEAD") != 0) {
1548                 /*
1549                  * Special hack: If a branch is updated directly and HEAD
1550                  * points to it (may happen on the remote side of a push
1551                  * for example) then logically the HEAD reflog should be
1552                  * updated too.
1553                  * A generic solution implies reverse symref information,
1554                  * but finding all symrefs pointing to the given branch
1555                  * would be rather costly for this rare event (the direct
1556                  * update of a branch) to be worth it.  So let's cheat and
1557                  * check with HEAD only which should cover 99% of all usage
1558                  * scenarios (even 100% of the default ones).
1559                  */
1560                 unsigned char head_sha1[20];
1561                 int head_flag;
1562                 const char *head_ref;
1563                 head_ref = resolve_ref("HEAD", head_sha1, 1, &head_flag);
1564                 if (head_ref && (head_flag & REF_ISSYMREF) &&
1565                     !strcmp(head_ref, lock->ref_name))
1566                         log_ref_write("HEAD", lock->old_sha1, sha1, logmsg);
1567         }
1568         if (commit_ref(lock)) {
1569                 error("Couldn't set %s", lock->ref_name);
1570                 unlock_ref(lock);
1571                 return -1;
1572         }
1573         unlock_ref(lock);
1574         return 0;
1575 }
1576
1577 int create_symref(const char *ref_target, const char *refs_heads_master,
1578                   const char *logmsg)
1579 {
1580         const char *lockpath;
1581         char ref[1000];
1582         int fd, len, written;
1583         char *git_HEAD = git_pathdup("%s", ref_target);
1584         unsigned char old_sha1[20], new_sha1[20];
1585
1586         if (logmsg && read_ref(ref_target, old_sha1))
1587                 hashclr(old_sha1);
1588
1589         if (safe_create_leading_directories(git_HEAD) < 0)
1590                 return error("unable to create directory for %s", git_HEAD);
1591
1592 #ifndef NO_SYMLINK_HEAD
1593         if (prefer_symlink_refs) {
1594                 unlink(git_HEAD);
1595                 if (!symlink(refs_heads_master, git_HEAD))
1596                         goto done;
1597                 fprintf(stderr, "no symlink - falling back to symbolic ref\n");
1598         }
1599 #endif
1600
1601         len = snprintf(ref, sizeof(ref), "ref: %s\n", refs_heads_master);
1602         if (sizeof(ref) <= len) {
1603                 error("refname too long: %s", refs_heads_master);
1604                 goto error_free_return;
1605         }
1606         lockpath = mkpath("%s.lock", git_HEAD);
1607         fd = open(lockpath, O_CREAT | O_EXCL | O_WRONLY, 0666);
1608         if (fd < 0) {
1609                 error("Unable to open %s for writing", lockpath);
1610                 goto error_free_return;
1611         }
1612         written = write_in_full(fd, ref, len);
1613         if (close(fd) != 0 || written != len) {
1614                 error("Unable to write to %s", lockpath);
1615                 goto error_unlink_return;
1616         }
1617         if (rename(lockpath, git_HEAD) < 0) {
1618                 error("Unable to create %s", git_HEAD);
1619                 goto error_unlink_return;
1620         }
1621         if (adjust_shared_perm(git_HEAD)) {
1622                 error("Unable to fix permissions on %s", lockpath);
1623         error_unlink_return:
1624                 unlink_or_warn(lockpath);
1625         error_free_return:
1626                 free(git_HEAD);
1627                 return -1;
1628         }
1629
1630 #ifndef NO_SYMLINK_HEAD
1631         done:
1632 #endif
1633         if (logmsg && !read_ref(refs_heads_master, new_sha1))
1634                 log_ref_write(ref_target, old_sha1, new_sha1, logmsg);
1635
1636         free(git_HEAD);
1637         return 0;
1638 }
1639
1640 static char *ref_msg(const char *line, const char *endp)
1641 {
1642         const char *ep;
1643         line += 82;
1644         ep = memchr(line, '\n', endp - line);
1645         if (!ep)
1646                 ep = endp;
1647         return xmemdupz(line, ep - line);
1648 }
1649
1650 int read_ref_at(const char *ref, unsigned long at_time, int cnt, unsigned char *sha1, char **msg, unsigned long *cutoff_time, int *cutoff_tz, int *cutoff_cnt)
1651 {
1652         const char *logfile, *logdata, *logend, *rec, *lastgt, *lastrec;
1653         char *tz_c;
1654         int logfd, tz, reccnt = 0;
1655         struct stat st;
1656         unsigned long date;
1657         unsigned char logged_sha1[20];
1658         void *log_mapped;
1659         size_t mapsz;
1660
1661         logfile = git_path("logs/%s", ref);
1662         logfd = open(logfile, O_RDONLY, 0);
1663         if (logfd < 0)
1664                 die_errno("Unable to read log '%s'", logfile);
1665         fstat(logfd, &st);
1666         if (!st.st_size)
1667                 die("Log %s is empty.", logfile);
1668         mapsz = xsize_t(st.st_size);
1669         log_mapped = xmmap(NULL, mapsz, PROT_READ, MAP_PRIVATE, logfd, 0);
1670         logdata = log_mapped;
1671         close(logfd);
1672
1673         lastrec = NULL;
1674         rec = logend = logdata + st.st_size;
1675         while (logdata < rec) {
1676                 reccnt++;
1677                 if (logdata < rec && *(rec-1) == '\n')
1678                         rec--;
1679                 lastgt = NULL;
1680                 while (logdata < rec && *(rec-1) != '\n') {
1681                         rec--;
1682                         if (*rec == '>')
1683                                 lastgt = rec;
1684                 }
1685                 if (!lastgt)
1686                         die("Log %s is corrupt.", logfile);
1687                 date = strtoul(lastgt + 1, &tz_c, 10);
1688                 if (date <= at_time || cnt == 0) {
1689                         tz = strtoul(tz_c, NULL, 10);
1690                         if (msg)
1691                                 *msg = ref_msg(rec, logend);
1692                         if (cutoff_time)
1693                                 *cutoff_time = date;
1694                         if (cutoff_tz)
1695                                 *cutoff_tz = tz;
1696                         if (cutoff_cnt)
1697                                 *cutoff_cnt = reccnt - 1;
1698                         if (lastrec) {
1699                                 if (get_sha1_hex(lastrec, logged_sha1))
1700                                         die("Log %s is corrupt.", logfile);
1701                                 if (get_sha1_hex(rec + 41, sha1))
1702                                         die("Log %s is corrupt.", logfile);
1703                                 if (hashcmp(logged_sha1, sha1)) {
1704                                         warning("Log %s has gap after %s.",
1705                                                 logfile, show_date(date, tz, DATE_RFC2822));
1706                                 }
1707                         }
1708                         else if (date == at_time) {
1709                                 if (get_sha1_hex(rec + 41, sha1))
1710                                         die("Log %s is corrupt.", logfile);
1711                         }
1712                         else {
1713                                 if (get_sha1_hex(rec + 41, logged_sha1))
1714                                         die("Log %s is corrupt.", logfile);
1715                                 if (hashcmp(logged_sha1, sha1)) {
1716                                         warning("Log %s unexpectedly ended on %s.",
1717                                                 logfile, show_date(date, tz, DATE_RFC2822));
1718                                 }
1719                         }
1720                         munmap(log_mapped, mapsz);
1721                         return 0;
1722                 }
1723                 lastrec = rec;
1724                 if (cnt > 0)
1725                         cnt--;
1726         }
1727
1728         rec = logdata;
1729         while (rec < logend && *rec != '>' && *rec != '\n')
1730                 rec++;
1731         if (rec == logend || *rec == '\n')
1732                 die("Log %s is corrupt.", logfile);
1733         date = strtoul(rec + 1, &tz_c, 10);
1734         tz = strtoul(tz_c, NULL, 10);
1735         if (get_sha1_hex(logdata, sha1))
1736                 die("Log %s is corrupt.", logfile);
1737         if (is_null_sha1(sha1)) {
1738                 if (get_sha1_hex(logdata + 41, sha1))
1739                         die("Log %s is corrupt.", logfile);
1740         }
1741         if (msg)
1742                 *msg = ref_msg(logdata, logend);
1743         munmap(log_mapped, mapsz);
1744
1745         if (cutoff_time)
1746                 *cutoff_time = date;
1747         if (cutoff_tz)
1748                 *cutoff_tz = tz;
1749         if (cutoff_cnt)
1750                 *cutoff_cnt = reccnt;
1751         return 1;
1752 }
1753
1754 int for_each_recent_reflog_ent(const char *ref, each_reflog_ent_fn fn, long ofs, void *cb_data)
1755 {
1756         const char *logfile;
1757         FILE *logfp;
1758         struct strbuf sb = STRBUF_INIT;
1759         int ret = 0;
1760
1761         logfile = git_path("logs/%s", ref);
1762         logfp = fopen(logfile, "r");
1763         if (!logfp)
1764                 return -1;
1765
1766         if (ofs) {
1767                 struct stat statbuf;
1768                 if (fstat(fileno(logfp), &statbuf) ||
1769                     statbuf.st_size < ofs ||
1770                     fseek(logfp, -ofs, SEEK_END) ||
1771                     strbuf_getwholeline(&sb, logfp, '\n')) {
1772                         fclose(logfp);
1773                         strbuf_release(&sb);
1774                         return -1;
1775                 }
1776         }
1777
1778         while (!strbuf_getwholeline(&sb, logfp, '\n')) {
1779                 unsigned char osha1[20], nsha1[20];
1780                 char *email_end, *message;
1781                 unsigned long timestamp;
1782                 int tz;
1783
1784                 /* old SP new SP name <email> SP time TAB msg LF */
1785                 if (sb.len < 83 || sb.buf[sb.len - 1] != '\n' ||
1786                     get_sha1_hex(sb.buf, osha1) || sb.buf[40] != ' ' ||
1787                     get_sha1_hex(sb.buf + 41, nsha1) || sb.buf[81] != ' ' ||
1788                     !(email_end = strchr(sb.buf + 82, '>')) ||
1789                     email_end[1] != ' ' ||
1790                     !(timestamp = strtoul(email_end + 2, &message, 10)) ||
1791                     !message || message[0] != ' ' ||
1792                     (message[1] != '+' && message[1] != '-') ||
1793                     !isdigit(message[2]) || !isdigit(message[3]) ||
1794                     !isdigit(message[4]) || !isdigit(message[5]))
1795                         continue; /* corrupt? */
1796                 email_end[1] = '\0';
1797                 tz = strtol(message + 1, NULL, 10);
1798                 if (message[6] != '\t')
1799                         message += 6;
1800                 else
1801                         message += 7;
1802                 ret = fn(osha1, nsha1, sb.buf + 82, timestamp, tz, message,
1803                          cb_data);
1804                 if (ret)
1805                         break;
1806         }
1807         fclose(logfp);
1808         strbuf_release(&sb);
1809         return ret;
1810 }
1811
1812 int for_each_reflog_ent(const char *ref, each_reflog_ent_fn fn, void *cb_data)
1813 {
1814         return for_each_recent_reflog_ent(ref, fn, 0, cb_data);
1815 }
1816
1817 static int do_for_each_reflog(const char *base, each_ref_fn fn, void *cb_data)
1818 {
1819         DIR *dir = opendir(git_path("logs/%s", base));
1820         int retval = 0;
1821
1822         if (dir) {
1823                 struct dirent *de;
1824                 int baselen = strlen(base);
1825                 char *log = xmalloc(baselen + 257);
1826
1827                 memcpy(log, base, baselen);
1828                 if (baselen && base[baselen-1] != '/')
1829                         log[baselen++] = '/';
1830
1831                 while ((de = readdir(dir)) != NULL) {
1832                         struct stat st;
1833                         int namelen;
1834
1835                         if (de->d_name[0] == '.')
1836                                 continue;
1837                         namelen = strlen(de->d_name);
1838                         if (namelen > 255)
1839                                 continue;
1840                         if (has_extension(de->d_name, ".lock"))
1841                                 continue;
1842                         memcpy(log + baselen, de->d_name, namelen+1);
1843                         if (stat(git_path("logs/%s", log), &st) < 0)
1844                                 continue;
1845                         if (S_ISDIR(st.st_mode)) {
1846                                 retval = do_for_each_reflog(log, fn, cb_data);
1847                         } else {
1848                                 unsigned char sha1[20];
1849                                 if (!resolve_ref(log, sha1, 0, NULL))
1850                                         retval = error("bad ref for %s", log);
1851                                 else
1852                                         retval = fn(log, sha1, 0, cb_data);
1853                         }
1854                         if (retval)
1855                                 break;
1856                 }
1857                 free(log);
1858                 closedir(dir);
1859         }
1860         else if (*base)
1861                 return errno;
1862         return retval;
1863 }
1864
1865 int for_each_reflog(each_ref_fn fn, void *cb_data)
1866 {
1867         return do_for_each_reflog("", fn, cb_data);
1868 }
1869
1870 int update_ref(const char *action, const char *refname,
1871                 const unsigned char *sha1, const unsigned char *oldval,
1872                 int flags, enum action_on_err onerr)
1873 {
1874         static struct ref_lock *lock;
1875         lock = lock_any_ref_for_update(refname, oldval, flags);
1876         if (!lock) {
1877                 const char *str = "Cannot lock the ref '%s'.";
1878                 switch (onerr) {
1879                 case MSG_ON_ERR: error(str, refname); break;
1880                 case DIE_ON_ERR: die(str, refname); break;
1881                 case QUIET_ON_ERR: break;
1882                 }
1883                 return 1;
1884         }
1885         if (write_ref_sha1(lock, sha1, action) < 0) {
1886                 const char *str = "Cannot update the ref '%s'.";
1887                 switch (onerr) {
1888                 case MSG_ON_ERR: error(str, refname); break;
1889                 case DIE_ON_ERR: die(str, refname); break;
1890                 case QUIET_ON_ERR: break;
1891                 }
1892                 return 1;
1893         }
1894         return 0;
1895 }
1896
1897 int ref_exists(const char *refname)
1898 {
1899         unsigned char sha1[20];
1900         return !!resolve_ref(refname, sha1, 1, NULL);
1901 }
1902
1903 struct ref *find_ref_by_name(const struct ref *list, const char *name)
1904 {
1905         for ( ; list; list = list->next)
1906                 if (!strcmp(list->name, name))
1907                         return (struct ref *)list;
1908         return NULL;
1909 }
1910
1911 /*
1912  * generate a format suitable for scanf from a ref_rev_parse_rules
1913  * rule, that is replace the "%.*s" spec with a "%s" spec
1914  */
1915 static void gen_scanf_fmt(char *scanf_fmt, const char *rule)
1916 {
1917         char *spec;
1918
1919         spec = strstr(rule, "%.*s");
1920         if (!spec || strstr(spec + 4, "%.*s"))
1921                 die("invalid rule in ref_rev_parse_rules: %s", rule);
1922
1923         /* copy all until spec */
1924         strncpy(scanf_fmt, rule, spec - rule);
1925         scanf_fmt[spec - rule] = '\0';
1926         /* copy new spec */
1927         strcat(scanf_fmt, "%s");
1928         /* copy remaining rule */
1929         strcat(scanf_fmt, spec + 4);
1930
1931         return;
1932 }
1933
1934 char *shorten_unambiguous_ref(const char *ref, int strict)
1935 {
1936         int i;
1937         static char **scanf_fmts;
1938         static int nr_rules;
1939         char *short_name;
1940
1941         /* pre generate scanf formats from ref_rev_parse_rules[] */
1942         if (!nr_rules) {
1943                 size_t total_len = 0;
1944
1945                 /* the rule list is NULL terminated, count them first */
1946                 for (; ref_rev_parse_rules[nr_rules]; nr_rules++)
1947                         /* no +1 because strlen("%s") < strlen("%.*s") */
1948                         total_len += strlen(ref_rev_parse_rules[nr_rules]);
1949
1950                 scanf_fmts = xmalloc(nr_rules * sizeof(char *) + total_len);
1951
1952                 total_len = 0;
1953                 for (i = 0; i < nr_rules; i++) {
1954                         scanf_fmts[i] = (char *)&scanf_fmts[nr_rules]
1955                                         + total_len;
1956                         gen_scanf_fmt(scanf_fmts[i], ref_rev_parse_rules[i]);
1957                         total_len += strlen(ref_rev_parse_rules[i]);
1958                 }
1959         }
1960
1961         /* bail out if there are no rules */
1962         if (!nr_rules)
1963                 return xstrdup(ref);
1964
1965         /* buffer for scanf result, at most ref must fit */
1966         short_name = xstrdup(ref);
1967
1968         /* skip first rule, it will always match */
1969         for (i = nr_rules - 1; i > 0 ; --i) {
1970                 int j;
1971                 int rules_to_fail = i;
1972                 int short_name_len;
1973
1974                 if (1 != sscanf(ref, scanf_fmts[i], short_name))
1975                         continue;
1976
1977                 short_name_len = strlen(short_name);
1978
1979                 /*
1980                  * in strict mode, all (except the matched one) rules
1981                  * must fail to resolve to a valid non-ambiguous ref
1982                  */
1983                 if (strict)
1984                         rules_to_fail = nr_rules;
1985
1986                 /*
1987                  * check if the short name resolves to a valid ref,
1988                  * but use only rules prior to the matched one
1989                  */
1990                 for (j = 0; j < rules_to_fail; j++) {
1991                         const char *rule = ref_rev_parse_rules[j];
1992                         unsigned char short_objectname[20];
1993                         char refname[PATH_MAX];
1994
1995                         /* skip matched rule */
1996                         if (i == j)
1997                                 continue;
1998
1999                         /*
2000                          * the short name is ambiguous, if it resolves
2001                          * (with this previous rule) to a valid ref
2002                          * read_ref() returns 0 on success
2003                          */
2004                         mksnpath(refname, sizeof(refname),
2005                                  rule, short_name_len, short_name);
2006                         if (!read_ref(refname, short_objectname))
2007                                 break;
2008                 }
2009
2010                 /*
2011                  * short name is non-ambiguous if all previous rules
2012                  * haven't resolved to a valid ref
2013                  */
2014                 if (j == rules_to_fail)
2015                         return short_name;
2016         }
2017
2018         free(short_name);
2019         return xstrdup(ref);
2020 }