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