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