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