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