Documentation: fix a grammatical error in api-builtin.txt
[git/mingw.git] / refs.c
blobbe095cb07d23ca9f0e20d2cc46df33827a123274
1 #include "cache.h"
2 #include "refs.h"
3 #include "object.h"
4 #include "tag.h"
5 #include "dir.h"
7 /* ISSYMREF=01 and ISPACKED=02 are public interfaces */
8 #define REF_KNOWS_PEELED 04
10 struct ref_list {
11 struct ref_list *next;
12 unsigned char flag; /* ISSYMREF? ISPACKED? */
13 unsigned char sha1[20];
14 unsigned char peeled[20];
15 char name[FLEX_ARRAY];
18 static const char *parse_ref_line(char *line, unsigned char *sha1)
21 * 42: the answer to everything.
23 * In this case, it happens to be the answer to
24 * 40 (length of sha1 hex representation)
25 * +1 (space in between hex and name)
26 * +1 (newline at the end of the line)
28 int len = strlen(line) - 42;
30 if (len <= 0)
31 return NULL;
32 if (get_sha1_hex(line, sha1) < 0)
33 return NULL;
34 if (!isspace(line[40]))
35 return NULL;
36 line += 41;
37 if (isspace(*line))
38 return NULL;
39 if (line[len] != '\n')
40 return NULL;
41 line[len] = 0;
43 return line;
46 static struct ref_list *add_ref(const char *name, const unsigned char *sha1,
47 int flag, struct ref_list *list,
48 struct ref_list **new_entry)
50 int len;
51 struct ref_list *entry;
53 /* Allocate it and add it in.. */
54 len = strlen(name) + 1;
55 entry = xmalloc(sizeof(struct ref_list) + len);
56 hashcpy(entry->sha1, sha1);
57 hashclr(entry->peeled);
58 memcpy(entry->name, name, len);
59 entry->flag = flag;
60 entry->next = list;
61 if (new_entry)
62 *new_entry = entry;
63 return entry;
66 /* merge sort the ref list */
67 static struct ref_list *sort_ref_list(struct ref_list *list)
69 int psize, qsize, last_merge_count, cmp;
70 struct ref_list *p, *q, *l, *e;
71 struct ref_list *new_list = list;
72 int k = 1;
73 int merge_count = 0;
75 if (!list)
76 return list;
78 do {
79 last_merge_count = merge_count;
80 merge_count = 0;
82 psize = 0;
84 p = new_list;
85 q = new_list;
86 new_list = NULL;
87 l = NULL;
89 while (p) {
90 merge_count++;
92 while (psize < k && q->next) {
93 q = q->next;
94 psize++;
96 qsize = k;
98 while ((psize > 0) || (qsize > 0 && q)) {
99 if (qsize == 0 || !q) {
100 e = p;
101 p = p->next;
102 psize--;
103 } else if (psize == 0) {
104 e = q;
105 q = q->next;
106 qsize--;
107 } else {
108 cmp = strcmp(q->name, p->name);
109 if (cmp < 0) {
110 e = q;
111 q = q->next;
112 qsize--;
113 } else if (cmp > 0) {
114 e = p;
115 p = p->next;
116 psize--;
117 } else {
118 if (hashcmp(q->sha1, p->sha1))
119 die("Duplicated ref, and SHA1s don't match: %s",
120 q->name);
121 warning("Duplicated ref: %s", q->name);
122 e = q;
123 q = q->next;
124 qsize--;
125 free(e);
126 e = p;
127 p = p->next;
128 psize--;
132 e->next = NULL;
134 if (l)
135 l->next = e;
136 if (!new_list)
137 new_list = e;
138 l = e;
141 p = q;
144 k = k * 2;
145 } while ((last_merge_count != merge_count) || (last_merge_count != 1));
147 return new_list;
151 * Future: need to be in "struct repository"
152 * when doing a full libification.
154 static struct cached_refs {
155 char did_loose;
156 char did_packed;
157 struct ref_list *loose;
158 struct ref_list *packed;
159 } cached_refs;
160 static struct ref_list *current_ref;
162 static struct ref_list *extra_refs;
164 static void free_ref_list(struct ref_list *list)
166 struct ref_list *next;
167 for ( ; list; list = next) {
168 next = list->next;
169 free(list);
173 static void invalidate_cached_refs(void)
175 struct cached_refs *ca = &cached_refs;
177 if (ca->did_loose && ca->loose)
178 free_ref_list(ca->loose);
179 if (ca->did_packed && ca->packed)
180 free_ref_list(ca->packed);
181 ca->loose = ca->packed = NULL;
182 ca->did_loose = ca->did_packed = 0;
185 static void read_packed_refs(FILE *f, struct cached_refs *cached_refs)
187 struct ref_list *list = NULL;
188 struct ref_list *last = NULL;
189 char refline[PATH_MAX];
190 int flag = REF_ISPACKED;
192 while (fgets(refline, sizeof(refline), f)) {
193 unsigned char sha1[20];
194 const char *name;
195 static const char header[] = "# pack-refs with:";
197 if (!strncmp(refline, header, sizeof(header)-1)) {
198 const char *traits = refline + sizeof(header) - 1;
199 if (strstr(traits, " peeled "))
200 flag |= REF_KNOWS_PEELED;
201 /* perhaps other traits later as well */
202 continue;
205 name = parse_ref_line(refline, sha1);
206 if (name) {
207 list = add_ref(name, sha1, flag, list, &last);
208 continue;
210 if (last &&
211 refline[0] == '^' &&
212 strlen(refline) == 42 &&
213 refline[41] == '\n' &&
214 !get_sha1_hex(refline + 1, sha1))
215 hashcpy(last->peeled, sha1);
217 cached_refs->packed = sort_ref_list(list);
220 void add_extra_ref(const char *name, const unsigned char *sha1, int flag)
222 extra_refs = add_ref(name, sha1, flag, extra_refs, NULL);
225 void clear_extra_refs(void)
227 free_ref_list(extra_refs);
228 extra_refs = NULL;
231 static struct ref_list *get_packed_refs(void)
233 if (!cached_refs.did_packed) {
234 FILE *f = fopen(git_path("packed-refs"), "r");
235 cached_refs.packed = NULL;
236 if (f) {
237 read_packed_refs(f, &cached_refs);
238 fclose(f);
240 cached_refs.did_packed = 1;
242 return cached_refs.packed;
245 static struct ref_list *get_ref_dir(const char *base, struct ref_list *list)
247 DIR *dir = opendir(git_path("%s", base));
249 if (dir) {
250 struct dirent *de;
251 int baselen = strlen(base);
252 char *ref = xmalloc(baselen + 257);
254 memcpy(ref, base, baselen);
255 if (baselen && base[baselen-1] != '/')
256 ref[baselen++] = '/';
258 while ((de = readdir(dir)) != NULL) {
259 unsigned char sha1[20];
260 struct stat st;
261 int flag;
262 int namelen;
264 if (de->d_name[0] == '.')
265 continue;
266 namelen = strlen(de->d_name);
267 if (namelen > 255)
268 continue;
269 if (has_extension(de->d_name, ".lock"))
270 continue;
271 memcpy(ref + baselen, de->d_name, namelen+1);
272 if (stat(git_path("%s", ref), &st) < 0)
273 continue;
274 if (S_ISDIR(st.st_mode)) {
275 list = get_ref_dir(ref, list);
276 continue;
278 if (!resolve_ref(ref, sha1, 1, &flag)) {
279 error("%s points nowhere!", ref);
280 continue;
282 list = add_ref(ref, sha1, flag, list, NULL);
284 free(ref);
285 closedir(dir);
287 return sort_ref_list(list);
290 static struct ref_list *get_loose_refs(void)
292 if (!cached_refs.did_loose) {
293 cached_refs.loose = get_ref_dir("refs", NULL);
294 cached_refs.did_loose = 1;
296 return cached_refs.loose;
299 /* We allow "recursive" symbolic refs. Only within reason, though */
300 #define MAXDEPTH 5
301 #define MAXREFLEN (1024)
303 static int resolve_gitlink_packed_ref(char *name, int pathlen, const char *refname, unsigned char *result)
305 FILE *f;
306 struct cached_refs refs;
307 struct ref_list *ref;
308 int retval;
310 strcpy(name + pathlen, "packed-refs");
311 f = fopen(name, "r");
312 if (!f)
313 return -1;
314 read_packed_refs(f, &refs);
315 fclose(f);
316 ref = refs.packed;
317 retval = -1;
318 while (ref) {
319 if (!strcmp(ref->name, refname)) {
320 retval = 0;
321 memcpy(result, ref->sha1, 20);
322 break;
324 ref = ref->next;
326 free_ref_list(refs.packed);
327 return retval;
330 static int resolve_gitlink_ref_recursive(char *name, int pathlen, const char *refname, unsigned char *result, int recursion)
332 int fd, len = strlen(refname);
333 char buffer[128], *p;
335 if (recursion > MAXDEPTH || len > MAXREFLEN)
336 return -1;
337 memcpy(name + pathlen, refname, len+1);
338 fd = open(name, O_RDONLY);
339 if (fd < 0)
340 return resolve_gitlink_packed_ref(name, pathlen, refname, result);
342 len = read(fd, buffer, sizeof(buffer)-1);
343 close(fd);
344 if (len < 0)
345 return -1;
346 while (len && isspace(buffer[len-1]))
347 len--;
348 buffer[len] = 0;
350 /* Was it a detached head or an old-fashioned symlink? */
351 if (!get_sha1_hex(buffer, result))
352 return 0;
354 /* Symref? */
355 if (strncmp(buffer, "ref:", 4))
356 return -1;
357 p = buffer + 4;
358 while (isspace(*p))
359 p++;
361 return resolve_gitlink_ref_recursive(name, pathlen, p, result, recursion+1);
364 int resolve_gitlink_ref(const char *path, const char *refname, unsigned char *result)
366 int len = strlen(path), retval;
367 char *gitdir;
368 const char *tmp;
370 while (len && path[len-1] == '/')
371 len--;
372 if (!len)
373 return -1;
374 gitdir = xmalloc(len + MAXREFLEN + 8);
375 memcpy(gitdir, path, len);
376 memcpy(gitdir + len, "/.git", 6);
377 len += 5;
379 tmp = read_gitfile_gently(gitdir);
380 if (tmp) {
381 free(gitdir);
382 len = strlen(tmp);
383 gitdir = xmalloc(len + MAXREFLEN + 3);
384 memcpy(gitdir, tmp, len);
386 gitdir[len] = '/';
387 gitdir[++len] = '\0';
388 retval = resolve_gitlink_ref_recursive(gitdir, len, refname, result, 0);
389 free(gitdir);
390 return retval;
393 const char *resolve_ref(const char *ref, unsigned char *sha1, int reading, int *flag)
395 int depth = MAXDEPTH;
396 ssize_t len;
397 char buffer[256];
398 static char ref_buffer[256];
400 if (flag)
401 *flag = 0;
403 for (;;) {
404 char path[PATH_MAX];
405 struct stat st;
406 char *buf;
407 int fd;
409 if (--depth < 0)
410 return NULL;
412 git_snpath(path, sizeof(path), "%s", ref);
413 /* Special case: non-existing file.
414 * Not having the refs/heads/new-branch is OK
415 * if we are writing into it, so is .git/HEAD
416 * that points at refs/heads/master still to be
417 * born. It is NOT OK if we are resolving for
418 * reading.
420 if (lstat(path, &st) < 0) {
421 struct ref_list *list = get_packed_refs();
422 while (list) {
423 if (!strcmp(ref, list->name)) {
424 hashcpy(sha1, list->sha1);
425 if (flag)
426 *flag |= REF_ISPACKED;
427 return ref;
429 list = list->next;
431 if (reading || errno != ENOENT)
432 return NULL;
433 hashclr(sha1);
434 return ref;
437 /* Follow "normalized" - ie "refs/.." symlinks by hand */
438 if (S_ISLNK(st.st_mode)) {
439 len = readlink(path, buffer, sizeof(buffer)-1);
440 if (len >= 5 && !memcmp("refs/", buffer, 5)) {
441 buffer[len] = 0;
442 strcpy(ref_buffer, buffer);
443 ref = ref_buffer;
444 if (flag)
445 *flag |= REF_ISSYMREF;
446 continue;
450 /* Is it a directory? */
451 if (S_ISDIR(st.st_mode)) {
452 errno = EISDIR;
453 return NULL;
457 * Anything else, just open it and try to use it as
458 * a ref
460 fd = open(path, O_RDONLY);
461 if (fd < 0)
462 return NULL;
463 len = read_in_full(fd, buffer, sizeof(buffer)-1);
464 close(fd);
467 * Is it a symbolic ref?
469 if (len < 4 || memcmp("ref:", buffer, 4))
470 break;
471 buf = buffer + 4;
472 len -= 4;
473 while (len && isspace(*buf))
474 buf++, len--;
475 while (len && isspace(buf[len-1]))
476 len--;
477 buf[len] = 0;
478 memcpy(ref_buffer, buf, len + 1);
479 ref = ref_buffer;
480 if (flag)
481 *flag |= REF_ISSYMREF;
483 if (len < 40 || get_sha1_hex(buffer, sha1))
484 return NULL;
485 return ref;
488 int read_ref(const char *ref, unsigned char *sha1)
490 if (resolve_ref(ref, sha1, 1, NULL))
491 return 0;
492 return -1;
495 static int do_one_ref(const char *base, each_ref_fn fn, int trim,
496 void *cb_data, struct ref_list *entry)
498 if (strncmp(base, entry->name, trim))
499 return 0;
500 if (is_null_sha1(entry->sha1))
501 return 0;
502 if (!has_sha1_file(entry->sha1)) {
503 error("%s does not point to a valid object!", entry->name);
504 return 0;
506 current_ref = entry;
507 return fn(entry->name + trim, entry->sha1, entry->flag, cb_data);
510 int peel_ref(const char *ref, unsigned char *sha1)
512 int flag;
513 unsigned char base[20];
514 struct object *o;
516 if (current_ref && (current_ref->name == ref
517 || !strcmp(current_ref->name, ref))) {
518 if (current_ref->flag & REF_KNOWS_PEELED) {
519 hashcpy(sha1, current_ref->peeled);
520 return 0;
522 hashcpy(base, current_ref->sha1);
523 goto fallback;
526 if (!resolve_ref(ref, base, 1, &flag))
527 return -1;
529 if ((flag & REF_ISPACKED)) {
530 struct ref_list *list = get_packed_refs();
532 while (list) {
533 if (!strcmp(list->name, ref)) {
534 if (list->flag & REF_KNOWS_PEELED) {
535 hashcpy(sha1, list->peeled);
536 return 0;
538 /* older pack-refs did not leave peeled ones */
539 break;
541 list = list->next;
545 fallback:
546 o = parse_object(base);
547 if (o && o->type == OBJ_TAG) {
548 o = deref_tag(o, ref, 0);
549 if (o) {
550 hashcpy(sha1, o->sha1);
551 return 0;
554 return -1;
557 static int do_for_each_ref(const char *base, each_ref_fn fn, int trim,
558 void *cb_data)
560 int retval = 0;
561 struct ref_list *packed = get_packed_refs();
562 struct ref_list *loose = get_loose_refs();
564 struct ref_list *extra;
566 for (extra = extra_refs; extra; extra = extra->next)
567 retval = do_one_ref(base, fn, trim, cb_data, extra);
569 while (packed && loose) {
570 struct ref_list *entry;
571 int cmp = strcmp(packed->name, loose->name);
572 if (!cmp) {
573 packed = packed->next;
574 continue;
576 if (cmp > 0) {
577 entry = loose;
578 loose = loose->next;
579 } else {
580 entry = packed;
581 packed = packed->next;
583 retval = do_one_ref(base, fn, trim, cb_data, entry);
584 if (retval)
585 goto end_each;
588 for (packed = packed ? packed : loose; packed; packed = packed->next) {
589 retval = do_one_ref(base, fn, trim, cb_data, packed);
590 if (retval)
591 goto end_each;
594 end_each:
595 current_ref = NULL;
596 return retval;
599 int head_ref(each_ref_fn fn, void *cb_data)
601 unsigned char sha1[20];
602 int flag;
604 if (resolve_ref("HEAD", sha1, 1, &flag))
605 return fn("HEAD", sha1, flag, cb_data);
606 return 0;
609 int for_each_ref(each_ref_fn fn, void *cb_data)
611 return do_for_each_ref("refs/", fn, 0, cb_data);
614 int for_each_tag_ref(each_ref_fn fn, void *cb_data)
616 return do_for_each_ref("refs/tags/", fn, 10, cb_data);
619 int for_each_branch_ref(each_ref_fn fn, void *cb_data)
621 return do_for_each_ref("refs/heads/", fn, 11, cb_data);
624 int for_each_remote_ref(each_ref_fn fn, void *cb_data)
626 return do_for_each_ref("refs/remotes/", fn, 13, cb_data);
630 * Make sure "ref" is something reasonable to have under ".git/refs/";
631 * We do not like it if:
633 * - any path component of it begins with ".", or
634 * - it has double dots "..", or
635 * - it has ASCII control character, "~", "^", ":" or SP, anywhere, or
636 * - it ends with a "/".
639 static inline int bad_ref_char(int ch)
641 if (((unsigned) ch) <= ' ' ||
642 ch == '~' || ch == '^' || ch == ':')
643 return 1;
644 /* 2.13 Pattern Matching Notation */
645 if (ch == '?' || ch == '[') /* Unsupported */
646 return 1;
647 if (ch == '*') /* Supported at the end */
648 return 2;
649 return 0;
652 int check_ref_format(const char *ref)
654 int ch, level, bad_type;
655 const char *cp = ref;
657 level = 0;
658 while (1) {
659 while ((ch = *cp++) == '/')
660 ; /* tolerate duplicated slashes */
661 if (!ch)
662 /* should not end with slashes */
663 return CHECK_REF_FORMAT_ERROR;
665 /* we are at the beginning of the path component */
666 if (ch == '.')
667 return CHECK_REF_FORMAT_ERROR;
668 bad_type = bad_ref_char(ch);
669 if (bad_type) {
670 return (bad_type == 2 && !*cp)
671 ? CHECK_REF_FORMAT_WILDCARD
672 : CHECK_REF_FORMAT_ERROR;
675 /* scan the rest of the path component */
676 while ((ch = *cp++) != 0) {
677 bad_type = bad_ref_char(ch);
678 if (bad_type) {
679 return (bad_type == 2 && !*cp)
680 ? CHECK_REF_FORMAT_WILDCARD
681 : CHECK_REF_FORMAT_ERROR;
683 if (ch == '/')
684 break;
685 if (ch == '.' && *cp == '.')
686 return CHECK_REF_FORMAT_ERROR;
688 level++;
689 if (!ch) {
690 if (level < 2)
691 return CHECK_REF_FORMAT_ONELEVEL;
692 return CHECK_REF_FORMAT_OK;
697 const char *ref_rev_parse_rules[] = {
698 "%.*s",
699 "refs/%.*s",
700 "refs/tags/%.*s",
701 "refs/heads/%.*s",
702 "refs/remotes/%.*s",
703 "refs/remotes/%.*s/HEAD",
704 NULL
707 const char *ref_fetch_rules[] = {
708 "%.*s",
709 "refs/%.*s",
710 "refs/heads/%.*s",
711 NULL
714 int refname_match(const char *abbrev_name, const char *full_name, const char **rules)
716 const char **p;
717 const int abbrev_name_len = strlen(abbrev_name);
719 for (p = rules; *p; p++) {
720 if (!strcmp(full_name, mkpath(*p, abbrev_name_len, abbrev_name))) {
721 return 1;
725 return 0;
728 static struct ref_lock *verify_lock(struct ref_lock *lock,
729 const unsigned char *old_sha1, int mustexist)
731 if (!resolve_ref(lock->ref_name, lock->old_sha1, mustexist, NULL)) {
732 error("Can't verify ref %s", lock->ref_name);
733 unlock_ref(lock);
734 return NULL;
736 if (hashcmp(lock->old_sha1, old_sha1)) {
737 error("Ref %s is at %s but expected %s", lock->ref_name,
738 sha1_to_hex(lock->old_sha1), sha1_to_hex(old_sha1));
739 unlock_ref(lock);
740 return NULL;
742 return lock;
745 static int remove_empty_directories(const char *file)
747 /* we want to create a file but there is a directory there;
748 * if that is an empty directory (or a directory that contains
749 * only empty directories), remove them.
751 struct strbuf path;
752 int result;
754 strbuf_init(&path, 20);
755 strbuf_addstr(&path, file);
757 result = remove_dir_recursively(&path, 1);
759 strbuf_release(&path);
761 return result;
764 static int is_refname_available(const char *ref, const char *oldref,
765 struct ref_list *list, int quiet)
767 int namlen = strlen(ref); /* e.g. 'foo/bar' */
768 while (list) {
769 /* list->name could be 'foo' or 'foo/bar/baz' */
770 if (!oldref || strcmp(oldref, list->name)) {
771 int len = strlen(list->name);
772 int cmplen = (namlen < len) ? namlen : len;
773 const char *lead = (namlen < len) ? list->name : ref;
774 if (!strncmp(ref, list->name, cmplen) &&
775 lead[cmplen] == '/') {
776 if (!quiet)
777 error("'%s' exists; cannot create '%s'",
778 list->name, ref);
779 return 0;
782 list = list->next;
784 return 1;
787 static struct ref_lock *lock_ref_sha1_basic(const char *ref, const unsigned char *old_sha1, int flags, int *type_p)
789 char *ref_file;
790 const char *orig_ref = ref;
791 struct ref_lock *lock;
792 int last_errno = 0;
793 int type, lflags;
794 int mustexist = (old_sha1 && !is_null_sha1(old_sha1));
795 int missing = 0;
797 lock = xcalloc(1, sizeof(struct ref_lock));
798 lock->lock_fd = -1;
800 ref = resolve_ref(ref, lock->old_sha1, mustexist, &type);
801 if (!ref && errno == EISDIR) {
802 /* we are trying to lock foo but we used to
803 * have foo/bar which now does not exist;
804 * it is normal for the empty directory 'foo'
805 * to remain.
807 ref_file = git_path("%s", orig_ref);
808 if (remove_empty_directories(ref_file)) {
809 last_errno = errno;
810 error("there are still refs under '%s'", orig_ref);
811 goto error_return;
813 ref = resolve_ref(orig_ref, lock->old_sha1, mustexist, &type);
815 if (type_p)
816 *type_p = type;
817 if (!ref) {
818 last_errno = errno;
819 error("unable to resolve reference %s: %s",
820 orig_ref, strerror(errno));
821 goto error_return;
823 missing = is_null_sha1(lock->old_sha1);
824 /* When the ref did not exist and we are creating it,
825 * make sure there is no existing ref that is packed
826 * whose name begins with our refname, nor a ref whose
827 * name is a proper prefix of our refname.
829 if (missing &&
830 !is_refname_available(ref, NULL, get_packed_refs(), 0))
831 goto error_return;
833 lock->lk = xcalloc(1, sizeof(struct lock_file));
835 lflags = LOCK_DIE_ON_ERROR;
836 if (flags & REF_NODEREF) {
837 ref = orig_ref;
838 lflags |= LOCK_NODEREF;
840 lock->ref_name = xstrdup(ref);
841 lock->orig_ref_name = xstrdup(orig_ref);
842 ref_file = git_path("%s", ref);
843 if (missing)
844 lock->force_write = 1;
845 if ((flags & REF_NODEREF) && (type & REF_ISSYMREF))
846 lock->force_write = 1;
848 if (safe_create_leading_directories(ref_file)) {
849 last_errno = errno;
850 error("unable to create directory for %s", ref_file);
851 goto error_return;
854 lock->lock_fd = hold_lock_file_for_update(lock->lk, ref_file, lflags);
855 return old_sha1 ? verify_lock(lock, old_sha1, mustexist) : lock;
857 error_return:
858 unlock_ref(lock);
859 errno = last_errno;
860 return NULL;
863 struct ref_lock *lock_ref_sha1(const char *ref, const unsigned char *old_sha1)
865 char refpath[PATH_MAX];
866 if (check_ref_format(ref))
867 return NULL;
868 strcpy(refpath, mkpath("refs/%s", ref));
869 return lock_ref_sha1_basic(refpath, old_sha1, 0, NULL);
872 struct ref_lock *lock_any_ref_for_update(const char *ref, const unsigned char *old_sha1, int flags)
874 switch (check_ref_format(ref)) {
875 default:
876 return NULL;
877 case 0:
878 case CHECK_REF_FORMAT_ONELEVEL:
879 return lock_ref_sha1_basic(ref, old_sha1, flags, NULL);
883 static struct lock_file packlock;
885 static int repack_without_ref(const char *refname)
887 struct ref_list *list, *packed_ref_list;
888 int fd;
889 int found = 0;
891 packed_ref_list = get_packed_refs();
892 for (list = packed_ref_list; list; list = list->next) {
893 if (!strcmp(refname, list->name)) {
894 found = 1;
895 break;
898 if (!found)
899 return 0;
900 fd = hold_lock_file_for_update(&packlock, git_path("packed-refs"), 0);
901 if (fd < 0)
902 return error("cannot delete '%s' from packed refs", refname);
904 for (list = packed_ref_list; list; list = list->next) {
905 char line[PATH_MAX + 100];
906 int len;
908 if (!strcmp(refname, list->name))
909 continue;
910 len = snprintf(line, sizeof(line), "%s %s\n",
911 sha1_to_hex(list->sha1), list->name);
912 /* this should not happen but just being defensive */
913 if (len > sizeof(line))
914 die("too long a refname '%s'", list->name);
915 write_or_die(fd, line, len);
917 return commit_lock_file(&packlock);
920 int delete_ref(const char *refname, const unsigned char *sha1, int delopt)
922 struct ref_lock *lock;
923 int err, i = 0, ret = 0, flag = 0;
925 lock = lock_ref_sha1_basic(refname, sha1, 0, &flag);
926 if (!lock)
927 return 1;
928 if (!(flag & REF_ISPACKED) || flag & REF_ISSYMREF) {
929 /* loose */
930 const char *path;
932 if (!(delopt & REF_NODEREF)) {
933 i = strlen(lock->lk->filename) - 5; /* .lock */
934 lock->lk->filename[i] = 0;
935 path = lock->lk->filename;
936 } else {
937 path = git_path("%s", refname);
939 err = unlink(path);
940 if (err && errno != ENOENT) {
941 ret = 1;
942 error("unlink(%s) failed: %s",
943 path, strerror(errno));
945 if (!(delopt & REF_NODEREF))
946 lock->lk->filename[i] = '.';
948 /* removing the loose one could have resurrected an earlier
949 * packed one. Also, if it was not loose we need to repack
950 * without it.
952 ret |= repack_without_ref(refname);
954 err = unlink(git_path("logs/%s", lock->ref_name));
955 if (err && errno != ENOENT)
956 fprintf(stderr, "warning: unlink(%s) failed: %s",
957 git_path("logs/%s", lock->ref_name), strerror(errno));
958 invalidate_cached_refs();
959 unlock_ref(lock);
960 return ret;
963 int rename_ref(const char *oldref, const char *newref, const char *logmsg)
965 static const char renamed_ref[] = "RENAMED-REF";
966 unsigned char sha1[20], orig_sha1[20];
967 int flag = 0, logmoved = 0;
968 struct ref_lock *lock;
969 struct stat loginfo;
970 int log = !lstat(git_path("logs/%s", oldref), &loginfo);
971 const char *symref = NULL;
973 if (log && S_ISLNK(loginfo.st_mode))
974 return error("reflog for %s is a symlink", oldref);
976 symref = resolve_ref(oldref, orig_sha1, 1, &flag);
977 if (flag & REF_ISSYMREF)
978 return error("refname %s is a symbolic ref, renaming it is not supported",
979 oldref);
980 if (!symref)
981 return error("refname %s not found", oldref);
983 if (!is_refname_available(newref, oldref, get_packed_refs(), 0))
984 return 1;
986 if (!is_refname_available(newref, oldref, get_loose_refs(), 0))
987 return 1;
989 lock = lock_ref_sha1_basic(renamed_ref, NULL, 0, NULL);
990 if (!lock)
991 return error("unable to lock %s", renamed_ref);
992 lock->force_write = 1;
993 if (write_ref_sha1(lock, orig_sha1, logmsg))
994 return error("unable to save current sha1 in %s", renamed_ref);
996 if (log && rename(git_path("logs/%s", oldref), git_path("tmp-renamed-log")))
997 return error("unable to move logfile logs/%s to tmp-renamed-log: %s",
998 oldref, strerror(errno));
1000 if (delete_ref(oldref, orig_sha1, REF_NODEREF)) {
1001 error("unable to delete old %s", oldref);
1002 goto rollback;
1005 if (resolve_ref(newref, sha1, 1, &flag) && delete_ref(newref, sha1, REF_NODEREF)) {
1006 if (errno==EISDIR) {
1007 if (remove_empty_directories(git_path("%s", newref))) {
1008 error("Directory not empty: %s", newref);
1009 goto rollback;
1011 } else {
1012 error("unable to delete existing %s", newref);
1013 goto rollback;
1017 if (log && safe_create_leading_directories(git_path("logs/%s", newref))) {
1018 error("unable to create directory for %s", newref);
1019 goto rollback;
1022 retry:
1023 if (log && rename(git_path("tmp-renamed-log"), git_path("logs/%s", newref))) {
1024 if (errno==EISDIR || errno==ENOTDIR) {
1026 * rename(a, b) when b is an existing
1027 * directory ought to result in ISDIR, but
1028 * Solaris 5.8 gives ENOTDIR. Sheesh.
1030 if (remove_empty_directories(git_path("logs/%s", newref))) {
1031 error("Directory not empty: logs/%s", newref);
1032 goto rollback;
1034 goto retry;
1035 } else {
1036 error("unable to move logfile tmp-renamed-log to logs/%s: %s",
1037 newref, strerror(errno));
1038 goto rollback;
1041 logmoved = log;
1043 lock = lock_ref_sha1_basic(newref, NULL, 0, NULL);
1044 if (!lock) {
1045 error("unable to lock %s for update", newref);
1046 goto rollback;
1048 lock->force_write = 1;
1049 hashcpy(lock->old_sha1, orig_sha1);
1050 if (write_ref_sha1(lock, orig_sha1, logmsg)) {
1051 error("unable to write current sha1 into %s", newref);
1052 goto rollback;
1055 return 0;
1057 rollback:
1058 lock = lock_ref_sha1_basic(oldref, NULL, 0, NULL);
1059 if (!lock) {
1060 error("unable to lock %s for rollback", oldref);
1061 goto rollbacklog;
1064 lock->force_write = 1;
1065 flag = log_all_ref_updates;
1066 log_all_ref_updates = 0;
1067 if (write_ref_sha1(lock, orig_sha1, NULL))
1068 error("unable to write current sha1 into %s", oldref);
1069 log_all_ref_updates = flag;
1071 rollbacklog:
1072 if (logmoved && rename(git_path("logs/%s", newref), git_path("logs/%s", oldref)))
1073 error("unable to restore logfile %s from %s: %s",
1074 oldref, newref, strerror(errno));
1075 if (!logmoved && log &&
1076 rename(git_path("tmp-renamed-log"), git_path("logs/%s", oldref)))
1077 error("unable to restore logfile %s from tmp-renamed-log: %s",
1078 oldref, strerror(errno));
1080 return 1;
1083 int close_ref(struct ref_lock *lock)
1085 if (close_lock_file(lock->lk))
1086 return -1;
1087 lock->lock_fd = -1;
1088 return 0;
1091 int commit_ref(struct ref_lock *lock)
1093 if (commit_lock_file(lock->lk))
1094 return -1;
1095 lock->lock_fd = -1;
1096 return 0;
1099 void unlock_ref(struct ref_lock *lock)
1101 /* Do not free lock->lk -- atexit() still looks at them */
1102 if (lock->lk)
1103 rollback_lock_file(lock->lk);
1104 free(lock->ref_name);
1105 free(lock->orig_ref_name);
1106 free(lock);
1110 * copy the reflog message msg to buf, which has been allocated sufficiently
1111 * large, while cleaning up the whitespaces. Especially, convert LF to space,
1112 * because reflog file is one line per entry.
1114 static int copy_msg(char *buf, const char *msg)
1116 char *cp = buf;
1117 char c;
1118 int wasspace = 1;
1120 *cp++ = '\t';
1121 while ((c = *msg++)) {
1122 if (wasspace && isspace(c))
1123 continue;
1124 wasspace = isspace(c);
1125 if (wasspace)
1126 c = ' ';
1127 *cp++ = c;
1129 while (buf < cp && isspace(cp[-1]))
1130 cp--;
1131 *cp++ = '\n';
1132 return cp - buf;
1135 static int log_ref_write(const char *ref_name, const unsigned char *old_sha1,
1136 const unsigned char *new_sha1, const char *msg)
1138 int logfd, written, oflags = O_APPEND | O_WRONLY;
1139 unsigned maxlen, len;
1140 int msglen;
1141 char log_file[PATH_MAX];
1142 char *logrec;
1143 const char *committer;
1145 if (log_all_ref_updates < 0)
1146 log_all_ref_updates = !is_bare_repository();
1148 git_snpath(log_file, sizeof(log_file), "logs/%s", ref_name);
1150 if (log_all_ref_updates &&
1151 (!prefixcmp(ref_name, "refs/heads/") ||
1152 !prefixcmp(ref_name, "refs/remotes/") ||
1153 !strcmp(ref_name, "HEAD"))) {
1154 if (safe_create_leading_directories(log_file) < 0)
1155 return error("unable to create directory for %s",
1156 log_file);
1157 oflags |= O_CREAT;
1160 logfd = open(log_file, oflags, 0666);
1161 if (logfd < 0) {
1162 if (!(oflags & O_CREAT) && errno == ENOENT)
1163 return 0;
1165 if ((oflags & O_CREAT) && errno == EISDIR) {
1166 if (remove_empty_directories(log_file)) {
1167 return error("There are still logs under '%s'",
1168 log_file);
1170 logfd = open(log_file, oflags, 0666);
1173 if (logfd < 0)
1174 return error("Unable to append to %s: %s",
1175 log_file, strerror(errno));
1178 adjust_shared_perm(log_file);
1180 msglen = msg ? strlen(msg) : 0;
1181 committer = git_committer_info(0);
1182 maxlen = strlen(committer) + msglen + 100;
1183 logrec = xmalloc(maxlen);
1184 len = sprintf(logrec, "%s %s %s\n",
1185 sha1_to_hex(old_sha1),
1186 sha1_to_hex(new_sha1),
1187 committer);
1188 if (msglen)
1189 len += copy_msg(logrec + len - 1, msg) - 1;
1190 written = len <= maxlen ? write_in_full(logfd, logrec, len) : -1;
1191 free(logrec);
1192 if (close(logfd) != 0 || written != len)
1193 return error("Unable to append to %s", log_file);
1194 return 0;
1197 static int is_branch(const char *refname)
1199 return !strcmp(refname, "HEAD") || !prefixcmp(refname, "refs/heads/");
1202 int write_ref_sha1(struct ref_lock *lock,
1203 const unsigned char *sha1, const char *logmsg)
1205 static char term = '\n';
1206 struct object *o;
1208 if (!lock)
1209 return -1;
1210 if (!lock->force_write && !hashcmp(lock->old_sha1, sha1)) {
1211 unlock_ref(lock);
1212 return 0;
1214 o = parse_object(sha1);
1215 if (!o) {
1216 error("Trying to write ref %s with nonexistant object %s",
1217 lock->ref_name, sha1_to_hex(sha1));
1218 unlock_ref(lock);
1219 return -1;
1221 if (o->type != OBJ_COMMIT && is_branch(lock->ref_name)) {
1222 error("Trying to write non-commit object %s to branch %s",
1223 sha1_to_hex(sha1), lock->ref_name);
1224 unlock_ref(lock);
1225 return -1;
1227 if (write_in_full(lock->lock_fd, sha1_to_hex(sha1), 40) != 40 ||
1228 write_in_full(lock->lock_fd, &term, 1) != 1
1229 || close_ref(lock) < 0) {
1230 error("Couldn't write %s", lock->lk->filename);
1231 unlock_ref(lock);
1232 return -1;
1234 invalidate_cached_refs();
1235 if (log_ref_write(lock->ref_name, lock->old_sha1, sha1, logmsg) < 0 ||
1236 (strcmp(lock->ref_name, lock->orig_ref_name) &&
1237 log_ref_write(lock->orig_ref_name, lock->old_sha1, sha1, logmsg) < 0)) {
1238 unlock_ref(lock);
1239 return -1;
1241 if (strcmp(lock->orig_ref_name, "HEAD") != 0) {
1243 * Special hack: If a branch is updated directly and HEAD
1244 * points to it (may happen on the remote side of a push
1245 * for example) then logically the HEAD reflog should be
1246 * updated too.
1247 * A generic solution implies reverse symref information,
1248 * but finding all symrefs pointing to the given branch
1249 * would be rather costly for this rare event (the direct
1250 * update of a branch) to be worth it. So let's cheat and
1251 * check with HEAD only which should cover 99% of all usage
1252 * scenarios (even 100% of the default ones).
1254 unsigned char head_sha1[20];
1255 int head_flag;
1256 const char *head_ref;
1257 head_ref = resolve_ref("HEAD", head_sha1, 1, &head_flag);
1258 if (head_ref && (head_flag & REF_ISSYMREF) &&
1259 !strcmp(head_ref, lock->ref_name))
1260 log_ref_write("HEAD", lock->old_sha1, sha1, logmsg);
1262 if (commit_ref(lock)) {
1263 error("Couldn't set %s", lock->ref_name);
1264 unlock_ref(lock);
1265 return -1;
1267 unlock_ref(lock);
1268 return 0;
1271 int create_symref(const char *ref_target, const char *refs_heads_master,
1272 const char *logmsg)
1274 const char *lockpath;
1275 char ref[1000];
1276 int fd, len, written;
1277 char *git_HEAD = git_pathdup("%s", ref_target);
1278 unsigned char old_sha1[20], new_sha1[20];
1280 if (logmsg && read_ref(ref_target, old_sha1))
1281 hashclr(old_sha1);
1283 if (safe_create_leading_directories(git_HEAD) < 0)
1284 return error("unable to create directory for %s", git_HEAD);
1286 #ifndef NO_SYMLINK_HEAD
1287 if (prefer_symlink_refs) {
1288 unlink(git_HEAD);
1289 if (!symlink(refs_heads_master, git_HEAD))
1290 goto done;
1291 fprintf(stderr, "no symlink - falling back to symbolic ref\n");
1293 #endif
1295 len = snprintf(ref, sizeof(ref), "ref: %s\n", refs_heads_master);
1296 if (sizeof(ref) <= len) {
1297 error("refname too long: %s", refs_heads_master);
1298 goto error_free_return;
1300 lockpath = mkpath("%s.lock", git_HEAD);
1301 fd = open(lockpath, O_CREAT | O_EXCL | O_WRONLY, 0666);
1302 if (fd < 0) {
1303 error("Unable to open %s for writing", lockpath);
1304 goto error_free_return;
1306 written = write_in_full(fd, ref, len);
1307 if (close(fd) != 0 || written != len) {
1308 error("Unable to write to %s", lockpath);
1309 goto error_unlink_return;
1311 if (rename(lockpath, git_HEAD) < 0) {
1312 error("Unable to create %s", git_HEAD);
1313 goto error_unlink_return;
1315 if (adjust_shared_perm(git_HEAD)) {
1316 error("Unable to fix permissions on %s", lockpath);
1317 error_unlink_return:
1318 unlink(lockpath);
1319 error_free_return:
1320 free(git_HEAD);
1321 return -1;
1324 #ifndef NO_SYMLINK_HEAD
1325 done:
1326 #endif
1327 if (logmsg && !read_ref(refs_heads_master, new_sha1))
1328 log_ref_write(ref_target, old_sha1, new_sha1, logmsg);
1330 free(git_HEAD);
1331 return 0;
1334 static char *ref_msg(const char *line, const char *endp)
1336 const char *ep;
1337 line += 82;
1338 ep = memchr(line, '\n', endp - line);
1339 if (!ep)
1340 ep = endp;
1341 return xmemdupz(line, ep - line);
1344 int read_ref_at(const char *ref, unsigned long at_time, int cnt, unsigned char *sha1, char **msg, unsigned long *cutoff_time, int *cutoff_tz, int *cutoff_cnt)
1346 const char *logfile, *logdata, *logend, *rec, *lastgt, *lastrec;
1347 char *tz_c;
1348 int logfd, tz, reccnt = 0;
1349 struct stat st;
1350 unsigned long date;
1351 unsigned char logged_sha1[20];
1352 void *log_mapped;
1353 size_t mapsz;
1355 logfile = git_path("logs/%s", ref);
1356 logfd = open(logfile, O_RDONLY, 0);
1357 if (logfd < 0)
1358 die("Unable to read log %s: %s", logfile, strerror(errno));
1359 fstat(logfd, &st);
1360 if (!st.st_size)
1361 die("Log %s is empty.", logfile);
1362 mapsz = xsize_t(st.st_size);
1363 log_mapped = xmmap(NULL, mapsz, PROT_READ, MAP_PRIVATE, logfd, 0);
1364 logdata = log_mapped;
1365 close(logfd);
1367 lastrec = NULL;
1368 rec = logend = logdata + st.st_size;
1369 while (logdata < rec) {
1370 reccnt++;
1371 if (logdata < rec && *(rec-1) == '\n')
1372 rec--;
1373 lastgt = NULL;
1374 while (logdata < rec && *(rec-1) != '\n') {
1375 rec--;
1376 if (*rec == '>')
1377 lastgt = rec;
1379 if (!lastgt)
1380 die("Log %s is corrupt.", logfile);
1381 date = strtoul(lastgt + 1, &tz_c, 10);
1382 if (date <= at_time || cnt == 0) {
1383 tz = strtoul(tz_c, NULL, 10);
1384 if (msg)
1385 *msg = ref_msg(rec, logend);
1386 if (cutoff_time)
1387 *cutoff_time = date;
1388 if (cutoff_tz)
1389 *cutoff_tz = tz;
1390 if (cutoff_cnt)
1391 *cutoff_cnt = reccnt - 1;
1392 if (lastrec) {
1393 if (get_sha1_hex(lastrec, logged_sha1))
1394 die("Log %s is corrupt.", logfile);
1395 if (get_sha1_hex(rec + 41, sha1))
1396 die("Log %s is corrupt.", logfile);
1397 if (hashcmp(logged_sha1, sha1)) {
1398 fprintf(stderr,
1399 "warning: Log %s has gap after %s.\n",
1400 logfile, show_date(date, tz, DATE_RFC2822));
1403 else if (date == at_time) {
1404 if (get_sha1_hex(rec + 41, sha1))
1405 die("Log %s is corrupt.", logfile);
1407 else {
1408 if (get_sha1_hex(rec + 41, logged_sha1))
1409 die("Log %s is corrupt.", logfile);
1410 if (hashcmp(logged_sha1, sha1)) {
1411 fprintf(stderr,
1412 "warning: Log %s unexpectedly ended on %s.\n",
1413 logfile, show_date(date, tz, DATE_RFC2822));
1416 munmap(log_mapped, mapsz);
1417 return 0;
1419 lastrec = rec;
1420 if (cnt > 0)
1421 cnt--;
1424 rec = logdata;
1425 while (rec < logend && *rec != '>' && *rec != '\n')
1426 rec++;
1427 if (rec == logend || *rec == '\n')
1428 die("Log %s is corrupt.", logfile);
1429 date = strtoul(rec + 1, &tz_c, 10);
1430 tz = strtoul(tz_c, NULL, 10);
1431 if (get_sha1_hex(logdata, sha1))
1432 die("Log %s is corrupt.", logfile);
1433 if (is_null_sha1(sha1)) {
1434 if (get_sha1_hex(logdata + 41, sha1))
1435 die("Log %s is corrupt.", logfile);
1437 if (msg)
1438 *msg = ref_msg(logdata, logend);
1439 munmap(log_mapped, mapsz);
1441 if (cutoff_time)
1442 *cutoff_time = date;
1443 if (cutoff_tz)
1444 *cutoff_tz = tz;
1445 if (cutoff_cnt)
1446 *cutoff_cnt = reccnt;
1447 return 1;
1450 int for_each_reflog_ent(const char *ref, each_reflog_ent_fn fn, void *cb_data)
1452 const char *logfile;
1453 FILE *logfp;
1454 char buf[1024];
1455 int ret = 0;
1457 logfile = git_path("logs/%s", ref);
1458 logfp = fopen(logfile, "r");
1459 if (!logfp)
1460 return -1;
1461 while (fgets(buf, sizeof(buf), logfp)) {
1462 unsigned char osha1[20], nsha1[20];
1463 char *email_end, *message;
1464 unsigned long timestamp;
1465 int len, tz;
1467 /* old SP new SP name <email> SP time TAB msg LF */
1468 len = strlen(buf);
1469 if (len < 83 || buf[len-1] != '\n' ||
1470 get_sha1_hex(buf, osha1) || buf[40] != ' ' ||
1471 get_sha1_hex(buf + 41, nsha1) || buf[81] != ' ' ||
1472 !(email_end = strchr(buf + 82, '>')) ||
1473 email_end[1] != ' ' ||
1474 !(timestamp = strtoul(email_end + 2, &message, 10)) ||
1475 !message || message[0] != ' ' ||
1476 (message[1] != '+' && message[1] != '-') ||
1477 !isdigit(message[2]) || !isdigit(message[3]) ||
1478 !isdigit(message[4]) || !isdigit(message[5]))
1479 continue; /* corrupt? */
1480 email_end[1] = '\0';
1481 tz = strtol(message + 1, NULL, 10);
1482 if (message[6] != '\t')
1483 message += 6;
1484 else
1485 message += 7;
1486 ret = fn(osha1, nsha1, buf+82, timestamp, tz, message, cb_data);
1487 if (ret)
1488 break;
1490 fclose(logfp);
1491 return ret;
1494 static int do_for_each_reflog(const char *base, each_ref_fn fn, void *cb_data)
1496 DIR *dir = opendir(git_path("logs/%s", base));
1497 int retval = 0;
1499 if (dir) {
1500 struct dirent *de;
1501 int baselen = strlen(base);
1502 char *log = xmalloc(baselen + 257);
1504 memcpy(log, base, baselen);
1505 if (baselen && base[baselen-1] != '/')
1506 log[baselen++] = '/';
1508 while ((de = readdir(dir)) != NULL) {
1509 struct stat st;
1510 int namelen;
1512 if (de->d_name[0] == '.')
1513 continue;
1514 namelen = strlen(de->d_name);
1515 if (namelen > 255)
1516 continue;
1517 if (has_extension(de->d_name, ".lock"))
1518 continue;
1519 memcpy(log + baselen, de->d_name, namelen+1);
1520 if (stat(git_path("logs/%s", log), &st) < 0)
1521 continue;
1522 if (S_ISDIR(st.st_mode)) {
1523 retval = do_for_each_reflog(log, fn, cb_data);
1524 } else {
1525 unsigned char sha1[20];
1526 if (!resolve_ref(log, sha1, 0, NULL))
1527 retval = error("bad ref for %s", log);
1528 else
1529 retval = fn(log, sha1, 0, cb_data);
1531 if (retval)
1532 break;
1534 free(log);
1535 closedir(dir);
1537 else if (*base)
1538 return errno;
1539 return retval;
1542 int for_each_reflog(each_ref_fn fn, void *cb_data)
1544 return do_for_each_reflog("", fn, cb_data);
1547 int update_ref(const char *action, const char *refname,
1548 const unsigned char *sha1, const unsigned char *oldval,
1549 int flags, enum action_on_err onerr)
1551 static struct ref_lock *lock;
1552 lock = lock_any_ref_for_update(refname, oldval, flags);
1553 if (!lock) {
1554 const char *str = "Cannot lock the ref '%s'.";
1555 switch (onerr) {
1556 case MSG_ON_ERR: error(str, refname); break;
1557 case DIE_ON_ERR: die(str, refname); break;
1558 case QUIET_ON_ERR: break;
1560 return 1;
1562 if (write_ref_sha1(lock, sha1, action) < 0) {
1563 const char *str = "Cannot update the ref '%s'.";
1564 switch (onerr) {
1565 case MSG_ON_ERR: error(str, refname); break;
1566 case DIE_ON_ERR: die(str, refname); break;
1567 case QUIET_ON_ERR: break;
1569 return 1;
1571 return 0;
1574 struct ref *find_ref_by_name(struct ref *list, const char *name)
1576 for ( ; list; list = list->next)
1577 if (!strcmp(list->name, name))
1578 return list;
1579 return NULL;