7 /* ISSYMREF=01 and ISPACKED=02 are public interfaces */
8 #define REF_KNOWS_PEELED 04
12 struct ref_list *next;
13 unsigned char flag; /* ISSYMREF? ISPACKED? */
14 unsigned char sha1[20];
15 unsigned char peeled[20];
16 char name[FLEX_ARRAY];
19 static const char *parse_ref_line(char *line, unsigned char *sha1)
22 * 42: the answer to everything.
24 * In this case, it happens to be the answer to
25 * 40 (length of sha1 hex representation)
26 * +1 (space in between hex and name)
27 * +1 (newline at the end of the line)
29 int len = strlen(line) - 42;
33 if (get_sha1_hex(line, sha1) < 0)
35 if (!isspace(line[40]))
40 if (line[len] != '\n')
47 static struct ref_list *add_ref(const char *name, const unsigned char *sha1,
48 int flag, struct ref_list *list,
49 struct ref_list **new_entry)
52 struct ref_list *entry;
54 /* Allocate it and add it in.. */
55 len = strlen(name) + 1;
56 entry = xmalloc(sizeof(struct ref_list) + len);
57 hashcpy(entry->sha1, sha1);
58 hashclr(entry->peeled);
59 memcpy(entry->name, name, len);
67 /* merge sort the ref list */
68 static struct ref_list *sort_ref_list(struct ref_list *list)
70 int psize, qsize, last_merge_count, cmp;
71 struct ref_list *p, *q, *l, *e;
72 struct ref_list *new_list = list;
80 last_merge_count = merge_count;
93 while (psize < k && q->next) {
99 while ((psize > 0) || (qsize > 0 && q)) {
100 if (qsize == 0 || !q) {
104 } else if (psize == 0) {
109 cmp = strcmp(q->name, p->name);
114 } else if (cmp > 0) {
119 if (hashcmp(q->sha1, p->sha1))
120 die("Duplicated ref, and SHA1s don't match: %s",
122 warning("Duplicated ref: %s", q->name);
146 } while ((last_merge_count != merge_count) || (last_merge_count != 1));
152 * Future: need to be in "struct repository"
153 * when doing a full libification.
155 static struct cached_refs {
158 struct ref_list *loose;
159 struct ref_list *packed;
161 static struct ref_list *current_ref;
163 static struct ref_list *extra_refs;
165 static void free_ref_list(struct ref_list *list)
167 struct ref_list *next;
168 for ( ; list; list = next) {
174 static void invalidate_cached_refs(void)
176 struct cached_refs *ca = &cached_refs;
178 if (ca->did_loose && ca->loose)
179 free_ref_list(ca->loose);
180 if (ca->did_packed && ca->packed)
181 free_ref_list(ca->packed);
182 ca->loose = ca->packed = NULL;
183 ca->did_loose = ca->did_packed = 0;
186 static void read_packed_refs(FILE *f, struct cached_refs *cached_refs)
188 struct ref_list *list = NULL;
189 struct ref_list *last = NULL;
190 char refline[PATH_MAX];
191 int flag = REF_ISPACKED;
193 while (fgets(refline, sizeof(refline), f)) {
194 unsigned char sha1[20];
196 static const char header[] = "# pack-refs with:";
198 if (!strncmp(refline, header, sizeof(header)-1)) {
199 const char *traits = refline + sizeof(header) - 1;
200 if (strstr(traits, " peeled "))
201 flag |= REF_KNOWS_PEELED;
202 /* perhaps other traits later as well */
206 name = parse_ref_line(refline, sha1);
208 list = add_ref(name, sha1, flag, list, &last);
213 strlen(refline) == 42 &&
214 refline[41] == '\n' &&
215 !get_sha1_hex(refline + 1, sha1))
216 hashcpy(last->peeled, sha1);
218 cached_refs->packed = sort_ref_list(list);
221 void add_extra_ref(const char *name, const unsigned char *sha1, int flag)
223 extra_refs = add_ref(name, sha1, flag, extra_refs, NULL);
226 void clear_extra_refs(void)
228 free_ref_list(extra_refs);
232 static struct ref_list *get_packed_refs(void)
234 if (!cached_refs.did_packed) {
235 FILE *f = fopen(git_path("packed-refs"), "r");
236 cached_refs.packed = NULL;
238 read_packed_refs(f, &cached_refs);
241 cached_refs.did_packed = 1;
243 return cached_refs.packed;
246 static struct ref_list *get_ref_dir(const char *base, struct ref_list *list)
248 DIR *dir = opendir(git_path("%s", base));
252 int baselen = strlen(base);
253 char *ref = xmalloc(baselen + 257);
255 memcpy(ref, base, baselen);
256 if (baselen && base[baselen-1] != '/')
257 ref[baselen++] = '/';
259 while ((de = readdir(dir)) != NULL) {
260 unsigned char sha1[20];
265 if (de->d_name[0] == '.')
267 namelen = strlen(de->d_name);
270 if (has_extension(de->d_name, ".lock"))
272 memcpy(ref + baselen, de->d_name, namelen+1);
273 if (stat(git_path("%s", ref), &st) < 0)
275 if (S_ISDIR(st.st_mode)) {
276 list = get_ref_dir(ref, list);
279 if (!resolve_ref(ref, sha1, 1, &flag)) {
283 list = add_ref(ref, sha1, flag, list, NULL);
288 return sort_ref_list(list);
291 struct warn_if_dangling_data {
296 static int warn_if_dangling_symref(const char *refname, const unsigned char *sha1,
297 int flags, void *cb_data)
299 struct warn_if_dangling_data *d = cb_data;
300 const char *resolves_to;
301 unsigned char junk[20];
303 if (!(flags & REF_ISSYMREF))
306 resolves_to = resolve_ref(refname, junk, 0, NULL);
307 if (!resolves_to || strcmp(resolves_to, d->refname))
310 printf(d->msg_fmt, refname);
314 void warn_dangling_symref(const char *msg_fmt, const char *refname)
316 struct warn_if_dangling_data data = { refname, msg_fmt };
317 for_each_rawref(warn_if_dangling_symref, &data);
320 static struct ref_list *get_loose_refs(void)
322 if (!cached_refs.did_loose) {
323 cached_refs.loose = get_ref_dir("refs", NULL);
324 cached_refs.did_loose = 1;
326 return cached_refs.loose;
329 /* We allow "recursive" symbolic refs. Only within reason, though */
331 #define MAXREFLEN (1024)
333 static int resolve_gitlink_packed_ref(char *name, int pathlen, const char *refname, unsigned char *result)
336 struct cached_refs refs;
337 struct ref_list *ref;
340 strcpy(name + pathlen, "packed-refs");
341 f = fopen(name, "r");
344 read_packed_refs(f, &refs);
349 if (!strcmp(ref->name, refname)) {
351 memcpy(result, ref->sha1, 20);
356 free_ref_list(refs.packed);
360 static int resolve_gitlink_ref_recursive(char *name, int pathlen, const char *refname, unsigned char *result, int recursion)
362 int fd, len = strlen(refname);
363 char buffer[128], *p;
365 if (recursion > MAXDEPTH || len > MAXREFLEN)
367 memcpy(name + pathlen, refname, len+1);
368 fd = open(name, O_RDONLY);
370 return resolve_gitlink_packed_ref(name, pathlen, refname, result);
372 len = read(fd, buffer, sizeof(buffer)-1);
376 while (len && isspace(buffer[len-1]))
380 /* Was it a detached head or an old-fashioned symlink? */
381 if (!get_sha1_hex(buffer, result))
385 if (strncmp(buffer, "ref:", 4))
391 return resolve_gitlink_ref_recursive(name, pathlen, p, result, recursion+1);
394 int resolve_gitlink_ref(const char *path, const char *refname, unsigned char *result)
396 int len = strlen(path), retval;
400 while (len && path[len-1] == '/')
404 gitdir = xmalloc(len + MAXREFLEN + 8);
405 memcpy(gitdir, path, len);
406 memcpy(gitdir + len, "/.git", 6);
409 tmp = read_gitfile_gently(gitdir);
413 gitdir = xmalloc(len + MAXREFLEN + 3);
414 memcpy(gitdir, tmp, len);
417 gitdir[++len] = '\0';
418 retval = resolve_gitlink_ref_recursive(gitdir, len, refname, result, 0);
424 * If the "reading" argument is set, this function finds out what _object_
425 * the ref points at by "reading" the ref. The ref, if it is not symbolic,
426 * has to exist, and if it is symbolic, it has to point at an existing ref,
427 * because the "read" goes through the symref to the ref it points at.
429 * The access that is not "reading" may often be "writing", but does not
430 * have to; it can be merely checking _where it leads to_. If it is a
431 * prelude to "writing" to the ref, a write to a symref that points at
432 * yet-to-be-born ref will create the real ref pointed by the symref.
433 * reading=0 allows the caller to check where such a symref leads to.
435 const char *resolve_ref(const char *ref, unsigned char *sha1, int reading, int *flag)
437 int depth = MAXDEPTH;
440 static char ref_buffer[256];
454 git_snpath(path, sizeof(path), "%s", ref);
455 /* Special case: non-existing file. */
456 if (lstat(path, &st) < 0) {
457 struct ref_list *list = get_packed_refs();
459 if (!strcmp(ref, list->name)) {
460 hashcpy(sha1, list->sha1);
462 *flag |= REF_ISPACKED;
467 if (reading || errno != ENOENT)
473 /* Follow "normalized" - ie "refs/.." symlinks by hand */
474 if (S_ISLNK(st.st_mode)) {
475 len = readlink(path, buffer, sizeof(buffer)-1);
476 if (len >= 5 && !memcmp("refs/", buffer, 5)) {
478 strcpy(ref_buffer, buffer);
481 *flag |= REF_ISSYMREF;
486 /* Is it a directory? */
487 if (S_ISDIR(st.st_mode)) {
493 * Anything else, just open it and try to use it as
496 fd = open(path, O_RDONLY);
499 len = read_in_full(fd, buffer, sizeof(buffer)-1);
503 * Is it a symbolic ref?
505 if (len < 4 || memcmp("ref:", buffer, 4))
509 while (len && isspace(*buf))
511 while (len && isspace(buf[len-1]))
514 memcpy(ref_buffer, buf, len + 1);
517 *flag |= REF_ISSYMREF;
519 if (len < 40 || get_sha1_hex(buffer, sha1))
524 int read_ref(const char *ref, unsigned char *sha1)
526 if (resolve_ref(ref, sha1, 1, NULL))
531 #define DO_FOR_EACH_INCLUDE_BROKEN 01
532 static int do_one_ref(const char *base, each_ref_fn fn, int trim,
533 int flags, void *cb_data, struct ref_list *entry)
535 if (strncmp(base, entry->name, trim))
538 if (!(flags & DO_FOR_EACH_INCLUDE_BROKEN)) {
539 if (entry->flag & REF_BROKEN)
540 return 0; /* ignore dangling symref */
541 if (!has_sha1_file(entry->sha1)) {
542 error("%s does not point to a valid object!", entry->name);
547 return fn(entry->name + trim, entry->sha1, entry->flag, cb_data);
550 int peel_ref(const char *ref, unsigned char *sha1)
553 unsigned char base[20];
556 if (current_ref && (current_ref->name == ref
557 || !strcmp(current_ref->name, ref))) {
558 if (current_ref->flag & REF_KNOWS_PEELED) {
559 hashcpy(sha1, current_ref->peeled);
562 hashcpy(base, current_ref->sha1);
566 if (!resolve_ref(ref, base, 1, &flag))
569 if ((flag & REF_ISPACKED)) {
570 struct ref_list *list = get_packed_refs();
573 if (!strcmp(list->name, ref)) {
574 if (list->flag & REF_KNOWS_PEELED) {
575 hashcpy(sha1, list->peeled);
578 /* older pack-refs did not leave peeled ones */
586 o = parse_object(base);
587 if (o && o->type == OBJ_TAG) {
588 o = deref_tag(o, ref, 0);
590 hashcpy(sha1, o->sha1);
597 static int do_for_each_ref(const char *base, each_ref_fn fn, int trim,
598 int flags, void *cb_data)
601 struct ref_list *packed = get_packed_refs();
602 struct ref_list *loose = get_loose_refs();
604 struct ref_list *extra;
606 for (extra = extra_refs; extra; extra = extra->next)
607 retval = do_one_ref(base, fn, trim, flags, cb_data, extra);
609 while (packed && loose) {
610 struct ref_list *entry;
611 int cmp = strcmp(packed->name, loose->name);
613 packed = packed->next;
621 packed = packed->next;
623 retval = do_one_ref(base, fn, trim, flags, cb_data, entry);
628 for (packed = packed ? packed : loose; packed; packed = packed->next) {
629 retval = do_one_ref(base, fn, trim, flags, cb_data, packed);
639 int head_ref(each_ref_fn fn, void *cb_data)
641 unsigned char sha1[20];
644 if (resolve_ref("HEAD", sha1, 1, &flag))
645 return fn("HEAD", sha1, flag, cb_data);
649 int for_each_ref(each_ref_fn fn, void *cb_data)
651 return do_for_each_ref("refs/", fn, 0, 0, cb_data);
654 int for_each_ref_in(const char *prefix, each_ref_fn fn, void *cb_data)
656 return do_for_each_ref(prefix, fn, strlen(prefix), 0, cb_data);
659 int for_each_tag_ref(each_ref_fn fn, void *cb_data)
661 return for_each_ref_in("refs/tags/", fn, cb_data);
664 int for_each_branch_ref(each_ref_fn fn, void *cb_data)
666 return for_each_ref_in("refs/heads/", fn, cb_data);
669 int for_each_remote_ref(each_ref_fn fn, void *cb_data)
671 return for_each_ref_in("refs/remotes/", fn, cb_data);
674 int for_each_rawref(each_ref_fn fn, void *cb_data)
676 return do_for_each_ref("refs/", fn, 0,
677 DO_FOR_EACH_INCLUDE_BROKEN, cb_data);
681 * Make sure "ref" is something reasonable to have under ".git/refs/";
682 * We do not like it if:
684 * - any path component of it begins with ".", or
685 * - it has double dots "..", or
686 * - it has ASCII control character, "~", "^", ":" or SP, anywhere, or
687 * - it ends with a "/".
688 * - it ends with ".lock"
691 static inline int bad_ref_char(int ch)
693 if (((unsigned) ch) <= ' ' ||
694 ch == '~' || ch == '^' || ch == ':')
696 /* 2.13 Pattern Matching Notation */
697 if (ch == '?' || ch == '[') /* Unsupported */
699 if (ch == '*') /* Supported at the end */
704 int check_ref_format(const char *ref)
706 int ch, level, bad_type, last;
707 int ret = CHECK_REF_FORMAT_OK;
708 const char *cp = ref;
712 while ((ch = *cp++) == '/')
713 ; /* tolerate duplicated slashes */
715 /* should not end with slashes */
716 return CHECK_REF_FORMAT_ERROR;
718 /* we are at the beginning of the path component */
720 return CHECK_REF_FORMAT_ERROR;
721 bad_type = bad_ref_char(ch);
723 if (bad_type == 2 && (!*cp || *cp == '/') &&
724 ret == CHECK_REF_FORMAT_OK)
725 ret = CHECK_REF_FORMAT_WILDCARD;
727 return CHECK_REF_FORMAT_ERROR;
731 /* scan the rest of the path component */
732 while ((ch = *cp++) != 0) {
733 bad_type = bad_ref_char(ch);
735 return CHECK_REF_FORMAT_ERROR;
738 if (last == '.' && ch == '.')
739 return CHECK_REF_FORMAT_ERROR;
740 if (last == '@' && ch == '{')
741 return CHECK_REF_FORMAT_ERROR;
746 if (ref <= cp - 2 && cp[-2] == '.')
747 return CHECK_REF_FORMAT_ERROR;
749 return CHECK_REF_FORMAT_ONELEVEL;
750 if (has_extension(ref, ".lock"))
751 return CHECK_REF_FORMAT_ERROR;
757 const char *prettify_ref(const struct ref *ref)
759 const char *name = ref->name;
761 !prefixcmp(name, "refs/heads/") ? 11 :
762 !prefixcmp(name, "refs/tags/") ? 10 :
763 !prefixcmp(name, "refs/remotes/") ? 13 :
767 const char *ref_rev_parse_rules[] = {
773 "refs/remotes/%.*s/HEAD",
777 const char *ref_fetch_rules[] = {
784 int refname_match(const char *abbrev_name, const char *full_name, const char **rules)
787 const int abbrev_name_len = strlen(abbrev_name);
789 for (p = rules; *p; p++) {
790 if (!strcmp(full_name, mkpath(*p, abbrev_name_len, abbrev_name))) {
798 static struct ref_lock *verify_lock(struct ref_lock *lock,
799 const unsigned char *old_sha1, int mustexist)
801 if (!resolve_ref(lock->ref_name, lock->old_sha1, mustexist, NULL)) {
802 error("Can't verify ref %s", lock->ref_name);
806 if (hashcmp(lock->old_sha1, old_sha1)) {
807 error("Ref %s is at %s but expected %s", lock->ref_name,
808 sha1_to_hex(lock->old_sha1), sha1_to_hex(old_sha1));
815 static int remove_empty_directories(const char *file)
817 /* we want to create a file but there is a directory there;
818 * if that is an empty directory (or a directory that contains
819 * only empty directories), remove them.
824 strbuf_init(&path, 20);
825 strbuf_addstr(&path, file);
827 result = remove_dir_recursively(&path, 1);
829 strbuf_release(&path);
834 static int is_refname_available(const char *ref, const char *oldref,
835 struct ref_list *list, int quiet)
837 int namlen = strlen(ref); /* e.g. 'foo/bar' */
839 /* list->name could be 'foo' or 'foo/bar/baz' */
840 if (!oldref || strcmp(oldref, list->name)) {
841 int len = strlen(list->name);
842 int cmplen = (namlen < len) ? namlen : len;
843 const char *lead = (namlen < len) ? list->name : ref;
844 if (!strncmp(ref, list->name, cmplen) &&
845 lead[cmplen] == '/') {
847 error("'%s' exists; cannot create '%s'",
857 static struct ref_lock *lock_ref_sha1_basic(const char *ref, const unsigned char *old_sha1, int flags, int *type_p)
860 const char *orig_ref = ref;
861 struct ref_lock *lock;
864 int mustexist = (old_sha1 && !is_null_sha1(old_sha1));
867 lock = xcalloc(1, sizeof(struct ref_lock));
870 ref = resolve_ref(ref, lock->old_sha1, mustexist, &type);
871 if (!ref && errno == EISDIR) {
872 /* we are trying to lock foo but we used to
873 * have foo/bar which now does not exist;
874 * it is normal for the empty directory 'foo'
877 ref_file = git_path("%s", orig_ref);
878 if (remove_empty_directories(ref_file)) {
880 error("there are still refs under '%s'", orig_ref);
883 ref = resolve_ref(orig_ref, lock->old_sha1, mustexist, &type);
889 error("unable to resolve reference %s: %s",
890 orig_ref, strerror(errno));
893 missing = is_null_sha1(lock->old_sha1);
894 /* When the ref did not exist and we are creating it,
895 * make sure there is no existing ref that is packed
896 * whose name begins with our refname, nor a ref whose
897 * name is a proper prefix of our refname.
900 !is_refname_available(ref, NULL, get_packed_refs(), 0)) {
901 last_errno = ENOTDIR;
905 lock->lk = xcalloc(1, sizeof(struct lock_file));
907 lflags = LOCK_DIE_ON_ERROR;
908 if (flags & REF_NODEREF) {
910 lflags |= LOCK_NODEREF;
912 lock->ref_name = xstrdup(ref);
913 lock->orig_ref_name = xstrdup(orig_ref);
914 ref_file = git_path("%s", ref);
916 lock->force_write = 1;
917 if ((flags & REF_NODEREF) && (type & REF_ISSYMREF))
918 lock->force_write = 1;
920 if (safe_create_leading_directories(ref_file)) {
922 error("unable to create directory for %s", ref_file);
926 lock->lock_fd = hold_lock_file_for_update(lock->lk, ref_file, lflags);
927 return old_sha1 ? verify_lock(lock, old_sha1, mustexist) : lock;
935 struct ref_lock *lock_ref_sha1(const char *ref, const unsigned char *old_sha1)
937 char refpath[PATH_MAX];
938 if (check_ref_format(ref))
940 strcpy(refpath, mkpath("refs/%s", ref));
941 return lock_ref_sha1_basic(refpath, old_sha1, 0, NULL);
944 struct ref_lock *lock_any_ref_for_update(const char *ref, const unsigned char *old_sha1, int flags)
946 switch (check_ref_format(ref)) {
950 case CHECK_REF_FORMAT_ONELEVEL:
951 return lock_ref_sha1_basic(ref, old_sha1, flags, NULL);
955 static struct lock_file packlock;
957 static int repack_without_ref(const char *refname)
959 struct ref_list *list, *packed_ref_list;
963 packed_ref_list = get_packed_refs();
964 for (list = packed_ref_list; list; list = list->next) {
965 if (!strcmp(refname, list->name)) {
972 fd = hold_lock_file_for_update(&packlock, git_path("packed-refs"), 0);
974 return error("cannot delete '%s' from packed refs", refname);
976 for (list = packed_ref_list; list; list = list->next) {
977 char line[PATH_MAX + 100];
980 if (!strcmp(refname, list->name))
982 len = snprintf(line, sizeof(line), "%s %s\n",
983 sha1_to_hex(list->sha1), list->name);
984 /* this should not happen but just being defensive */
985 if (len > sizeof(line))
986 die("too long a refname '%s'", list->name);
987 write_or_die(fd, line, len);
989 return commit_lock_file(&packlock);
992 int delete_ref(const char *refname, const unsigned char *sha1, int delopt)
994 struct ref_lock *lock;
995 int err, i = 0, ret = 0, flag = 0;
997 lock = lock_ref_sha1_basic(refname, sha1, 0, &flag);
1000 if (!(flag & REF_ISPACKED) || flag & REF_ISSYMREF) {
1004 if (!(delopt & REF_NODEREF)) {
1005 i = strlen(lock->lk->filename) - 5; /* .lock */
1006 lock->lk->filename[i] = 0;
1007 path = lock->lk->filename;
1009 path = git_path("%s", refname);
1011 err = unlink_or_warn(path);
1012 if (err && errno != ENOENT)
1015 if (!(delopt & REF_NODEREF))
1016 lock->lk->filename[i] = '.';
1018 /* removing the loose one could have resurrected an earlier
1019 * packed one. Also, if it was not loose we need to repack
1022 ret |= repack_without_ref(refname);
1024 unlink_or_warn(git_path("logs/%s", lock->ref_name));
1025 invalidate_cached_refs();
1030 int rename_ref(const char *oldref, const char *newref, const char *logmsg)
1032 static const char renamed_ref[] = "RENAMED-REF";
1033 unsigned char sha1[20], orig_sha1[20];
1034 int flag = 0, logmoved = 0;
1035 struct ref_lock *lock;
1036 struct stat loginfo;
1037 int log = !lstat(git_path("logs/%s", oldref), &loginfo);
1038 const char *symref = NULL;
1040 if (log && S_ISLNK(loginfo.st_mode))
1041 return error("reflog for %s is a symlink", oldref);
1043 symref = resolve_ref(oldref, orig_sha1, 1, &flag);
1044 if (flag & REF_ISSYMREF)
1045 return error("refname %s is a symbolic ref, renaming it is not supported",
1048 return error("refname %s not found", oldref);
1050 if (!is_refname_available(newref, oldref, get_packed_refs(), 0))
1053 if (!is_refname_available(newref, oldref, get_loose_refs(), 0))
1056 lock = lock_ref_sha1_basic(renamed_ref, NULL, 0, NULL);
1058 return error("unable to lock %s", renamed_ref);
1059 lock->force_write = 1;
1060 if (write_ref_sha1(lock, orig_sha1, logmsg))
1061 return error("unable to save current sha1 in %s", renamed_ref);
1063 if (log && rename(git_path("logs/%s", oldref), git_path("tmp-renamed-log")))
1064 return error("unable to move logfile logs/%s to tmp-renamed-log: %s",
1065 oldref, strerror(errno));
1067 if (delete_ref(oldref, orig_sha1, REF_NODEREF)) {
1068 error("unable to delete old %s", oldref);
1072 if (resolve_ref(newref, sha1, 1, &flag) && delete_ref(newref, sha1, REF_NODEREF)) {
1073 if (errno==EISDIR) {
1074 if (remove_empty_directories(git_path("%s", newref))) {
1075 error("Directory not empty: %s", newref);
1079 error("unable to delete existing %s", newref);
1084 if (log && safe_create_leading_directories(git_path("logs/%s", newref))) {
1085 error("unable to create directory for %s", newref);
1090 if (log && rename(git_path("tmp-renamed-log"), git_path("logs/%s", newref))) {
1091 if (errno==EISDIR || errno==ENOTDIR) {
1093 * rename(a, b) when b is an existing
1094 * directory ought to result in ISDIR, but
1095 * Solaris 5.8 gives ENOTDIR. Sheesh.
1097 if (remove_empty_directories(git_path("logs/%s", newref))) {
1098 error("Directory not empty: logs/%s", newref);
1103 error("unable to move logfile tmp-renamed-log to logs/%s: %s",
1104 newref, strerror(errno));
1110 lock = lock_ref_sha1_basic(newref, NULL, 0, NULL);
1112 error("unable to lock %s for update", newref);
1115 lock->force_write = 1;
1116 hashcpy(lock->old_sha1, orig_sha1);
1117 if (write_ref_sha1(lock, orig_sha1, logmsg)) {
1118 error("unable to write current sha1 into %s", newref);
1125 lock = lock_ref_sha1_basic(oldref, NULL, 0, NULL);
1127 error("unable to lock %s for rollback", oldref);
1131 lock->force_write = 1;
1132 flag = log_all_ref_updates;
1133 log_all_ref_updates = 0;
1134 if (write_ref_sha1(lock, orig_sha1, NULL))
1135 error("unable to write current sha1 into %s", oldref);
1136 log_all_ref_updates = flag;
1139 if (logmoved && rename(git_path("logs/%s", newref), git_path("logs/%s", oldref)))
1140 error("unable to restore logfile %s from %s: %s",
1141 oldref, newref, strerror(errno));
1142 if (!logmoved && log &&
1143 rename(git_path("tmp-renamed-log"), git_path("logs/%s", oldref)))
1144 error("unable to restore logfile %s from tmp-renamed-log: %s",
1145 oldref, strerror(errno));
1150 int close_ref(struct ref_lock *lock)
1152 if (close_lock_file(lock->lk))
1158 int commit_ref(struct ref_lock *lock)
1160 if (commit_lock_file(lock->lk))
1166 void unlock_ref(struct ref_lock *lock)
1168 /* Do not free lock->lk -- atexit() still looks at them */
1170 rollback_lock_file(lock->lk);
1171 free(lock->ref_name);
1172 free(lock->orig_ref_name);
1177 * copy the reflog message msg to buf, which has been allocated sufficiently
1178 * large, while cleaning up the whitespaces. Especially, convert LF to space,
1179 * because reflog file is one line per entry.
1181 static int copy_msg(char *buf, const char *msg)
1188 while ((c = *msg++)) {
1189 if (wasspace && isspace(c))
1191 wasspace = isspace(c);
1196 while (buf < cp && isspace(cp[-1]))
1202 static int log_ref_write(const char *ref_name, const unsigned char *old_sha1,
1203 const unsigned char *new_sha1, const char *msg)
1205 int logfd, written, oflags = O_APPEND | O_WRONLY;
1206 unsigned maxlen, len;
1208 char log_file[PATH_MAX];
1210 const char *committer;
1212 if (log_all_ref_updates < 0)
1213 log_all_ref_updates = !is_bare_repository();
1215 git_snpath(log_file, sizeof(log_file), "logs/%s", ref_name);
1217 if (log_all_ref_updates &&
1218 (!prefixcmp(ref_name, "refs/heads/") ||
1219 !prefixcmp(ref_name, "refs/remotes/") ||
1220 !strcmp(ref_name, "HEAD"))) {
1221 if (safe_create_leading_directories(log_file) < 0)
1222 return error("unable to create directory for %s",
1227 logfd = open(log_file, oflags, 0666);
1229 if (!(oflags & O_CREAT) && errno == ENOENT)
1232 if ((oflags & O_CREAT) && errno == EISDIR) {
1233 if (remove_empty_directories(log_file)) {
1234 return error("There are still logs under '%s'",
1237 logfd = open(log_file, oflags, 0666);
1241 return error("Unable to append to %s: %s",
1242 log_file, strerror(errno));
1245 adjust_shared_perm(log_file);
1247 msglen = msg ? strlen(msg) : 0;
1248 committer = git_committer_info(0);
1249 maxlen = strlen(committer) + msglen + 100;
1250 logrec = xmalloc(maxlen);
1251 len = sprintf(logrec, "%s %s %s\n",
1252 sha1_to_hex(old_sha1),
1253 sha1_to_hex(new_sha1),
1256 len += copy_msg(logrec + len - 1, msg) - 1;
1257 written = len <= maxlen ? write_in_full(logfd, logrec, len) : -1;
1259 if (close(logfd) != 0 || written != len)
1260 return error("Unable to append to %s", log_file);
1264 static int is_branch(const char *refname)
1266 return !strcmp(refname, "HEAD") || !prefixcmp(refname, "refs/heads/");
1269 int write_ref_sha1(struct ref_lock *lock,
1270 const unsigned char *sha1, const char *logmsg)
1272 static char term = '\n';
1277 if (!lock->force_write && !hashcmp(lock->old_sha1, sha1)) {
1281 o = parse_object(sha1);
1283 error("Trying to write ref %s with nonexistant object %s",
1284 lock->ref_name, sha1_to_hex(sha1));
1288 if (o->type != OBJ_COMMIT && is_branch(lock->ref_name)) {
1289 error("Trying to write non-commit object %s to branch %s",
1290 sha1_to_hex(sha1), lock->ref_name);
1294 if (write_in_full(lock->lock_fd, sha1_to_hex(sha1), 40) != 40 ||
1295 write_in_full(lock->lock_fd, &term, 1) != 1
1296 || close_ref(lock) < 0) {
1297 error("Couldn't write %s", lock->lk->filename);
1301 invalidate_cached_refs();
1302 if (log_ref_write(lock->ref_name, lock->old_sha1, sha1, logmsg) < 0 ||
1303 (strcmp(lock->ref_name, lock->orig_ref_name) &&
1304 log_ref_write(lock->orig_ref_name, lock->old_sha1, sha1, logmsg) < 0)) {
1308 if (strcmp(lock->orig_ref_name, "HEAD") != 0) {
1310 * Special hack: If a branch is updated directly and HEAD
1311 * points to it (may happen on the remote side of a push
1312 * for example) then logically the HEAD reflog should be
1314 * A generic solution implies reverse symref information,
1315 * but finding all symrefs pointing to the given branch
1316 * would be rather costly for this rare event (the direct
1317 * update of a branch) to be worth it. So let's cheat and
1318 * check with HEAD only which should cover 99% of all usage
1319 * scenarios (even 100% of the default ones).
1321 unsigned char head_sha1[20];
1323 const char *head_ref;
1324 head_ref = resolve_ref("HEAD", head_sha1, 1, &head_flag);
1325 if (head_ref && (head_flag & REF_ISSYMREF) &&
1326 !strcmp(head_ref, lock->ref_name))
1327 log_ref_write("HEAD", lock->old_sha1, sha1, logmsg);
1329 if (commit_ref(lock)) {
1330 error("Couldn't set %s", lock->ref_name);
1338 int create_symref(const char *ref_target, const char *refs_heads_master,
1341 const char *lockpath;
1343 int fd, len, written;
1344 char *git_HEAD = git_pathdup("%s", ref_target);
1345 unsigned char old_sha1[20], new_sha1[20];
1347 if (logmsg && read_ref(ref_target, old_sha1))
1350 if (safe_create_leading_directories(git_HEAD) < 0)
1351 return error("unable to create directory for %s", git_HEAD);
1353 #ifndef NO_SYMLINK_HEAD
1354 if (prefer_symlink_refs) {
1356 if (!symlink(refs_heads_master, git_HEAD))
1358 fprintf(stderr, "no symlink - falling back to symbolic ref\n");
1362 len = snprintf(ref, sizeof(ref), "ref: %s\n", refs_heads_master);
1363 if (sizeof(ref) <= len) {
1364 error("refname too long: %s", refs_heads_master);
1365 goto error_free_return;
1367 lockpath = mkpath("%s.lock", git_HEAD);
1368 fd = open(lockpath, O_CREAT | O_EXCL | O_WRONLY, 0666);
1370 error("Unable to open %s for writing", lockpath);
1371 goto error_free_return;
1373 written = write_in_full(fd, ref, len);
1374 if (close(fd) != 0 || written != len) {
1375 error("Unable to write to %s", lockpath);
1376 goto error_unlink_return;
1378 if (rename(lockpath, git_HEAD) < 0) {
1379 error("Unable to create %s", git_HEAD);
1380 goto error_unlink_return;
1382 if (adjust_shared_perm(git_HEAD)) {
1383 error("Unable to fix permissions on %s", lockpath);
1384 error_unlink_return:
1385 unlink_or_warn(lockpath);
1391 #ifndef NO_SYMLINK_HEAD
1394 if (logmsg && !read_ref(refs_heads_master, new_sha1))
1395 log_ref_write(ref_target, old_sha1, new_sha1, logmsg);
1401 static char *ref_msg(const char *line, const char *endp)
1405 ep = memchr(line, '\n', endp - line);
1408 return xmemdupz(line, ep - line);
1411 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)
1413 const char *logfile, *logdata, *logend, *rec, *lastgt, *lastrec;
1415 int logfd, tz, reccnt = 0;
1418 unsigned char logged_sha1[20];
1422 logfile = git_path("logs/%s", ref);
1423 logfd = open(logfile, O_RDONLY, 0);
1425 die("Unable to read log %s: %s", logfile, strerror(errno));
1428 die("Log %s is empty.", logfile);
1429 mapsz = xsize_t(st.st_size);
1430 log_mapped = xmmap(NULL, mapsz, PROT_READ, MAP_PRIVATE, logfd, 0);
1431 logdata = log_mapped;
1435 rec = logend = logdata + st.st_size;
1436 while (logdata < rec) {
1438 if (logdata < rec && *(rec-1) == '\n')
1441 while (logdata < rec && *(rec-1) != '\n') {
1447 die("Log %s is corrupt.", logfile);
1448 date = strtoul(lastgt + 1, &tz_c, 10);
1449 if (date <= at_time || cnt == 0) {
1450 tz = strtoul(tz_c, NULL, 10);
1452 *msg = ref_msg(rec, logend);
1454 *cutoff_time = date;
1458 *cutoff_cnt = reccnt - 1;
1460 if (get_sha1_hex(lastrec, logged_sha1))
1461 die("Log %s is corrupt.", logfile);
1462 if (get_sha1_hex(rec + 41, sha1))
1463 die("Log %s is corrupt.", logfile);
1464 if (hashcmp(logged_sha1, sha1)) {
1465 warning("Log %s has gap after %s.",
1466 logfile, show_date(date, tz, DATE_RFC2822));
1469 else if (date == at_time) {
1470 if (get_sha1_hex(rec + 41, sha1))
1471 die("Log %s is corrupt.", logfile);
1474 if (get_sha1_hex(rec + 41, logged_sha1))
1475 die("Log %s is corrupt.", logfile);
1476 if (hashcmp(logged_sha1, sha1)) {
1477 warning("Log %s unexpectedly ended on %s.",
1478 logfile, show_date(date, tz, DATE_RFC2822));
1481 munmap(log_mapped, mapsz);
1490 while (rec < logend && *rec != '>' && *rec != '\n')
1492 if (rec == logend || *rec == '\n')
1493 die("Log %s is corrupt.", logfile);
1494 date = strtoul(rec + 1, &tz_c, 10);
1495 tz = strtoul(tz_c, NULL, 10);
1496 if (get_sha1_hex(logdata, sha1))
1497 die("Log %s is corrupt.", logfile);
1498 if (is_null_sha1(sha1)) {
1499 if (get_sha1_hex(logdata + 41, sha1))
1500 die("Log %s is corrupt.", logfile);
1503 *msg = ref_msg(logdata, logend);
1504 munmap(log_mapped, mapsz);
1507 *cutoff_time = date;
1511 *cutoff_cnt = reccnt;
1515 int for_each_recent_reflog_ent(const char *ref, each_reflog_ent_fn fn, long ofs, void *cb_data)
1517 const char *logfile;
1522 logfile = git_path("logs/%s", ref);
1523 logfp = fopen(logfile, "r");
1528 struct stat statbuf;
1529 if (fstat(fileno(logfp), &statbuf) ||
1530 statbuf.st_size < ofs ||
1531 fseek(logfp, -ofs, SEEK_END) ||
1532 fgets(buf, sizeof(buf), logfp)) {
1538 while (fgets(buf, sizeof(buf), logfp)) {
1539 unsigned char osha1[20], nsha1[20];
1540 char *email_end, *message;
1541 unsigned long timestamp;
1544 /* old SP new SP name <email> SP time TAB msg LF */
1546 if (len < 83 || buf[len-1] != '\n' ||
1547 get_sha1_hex(buf, osha1) || buf[40] != ' ' ||
1548 get_sha1_hex(buf + 41, nsha1) || buf[81] != ' ' ||
1549 !(email_end = strchr(buf + 82, '>')) ||
1550 email_end[1] != ' ' ||
1551 !(timestamp = strtoul(email_end + 2, &message, 10)) ||
1552 !message || message[0] != ' ' ||
1553 (message[1] != '+' && message[1] != '-') ||
1554 !isdigit(message[2]) || !isdigit(message[3]) ||
1555 !isdigit(message[4]) || !isdigit(message[5]))
1556 continue; /* corrupt? */
1557 email_end[1] = '\0';
1558 tz = strtol(message + 1, NULL, 10);
1559 if (message[6] != '\t')
1563 ret = fn(osha1, nsha1, buf+82, timestamp, tz, message, cb_data);
1571 int for_each_reflog_ent(const char *ref, each_reflog_ent_fn fn, void *cb_data)
1573 return for_each_recent_reflog_ent(ref, fn, 0, cb_data);
1576 static int do_for_each_reflog(const char *base, each_ref_fn fn, void *cb_data)
1578 DIR *dir = opendir(git_path("logs/%s", base));
1583 int baselen = strlen(base);
1584 char *log = xmalloc(baselen + 257);
1586 memcpy(log, base, baselen);
1587 if (baselen && base[baselen-1] != '/')
1588 log[baselen++] = '/';
1590 while ((de = readdir(dir)) != NULL) {
1594 if (de->d_name[0] == '.')
1596 namelen = strlen(de->d_name);
1599 if (has_extension(de->d_name, ".lock"))
1601 memcpy(log + baselen, de->d_name, namelen+1);
1602 if (stat(git_path("logs/%s", log), &st) < 0)
1604 if (S_ISDIR(st.st_mode)) {
1605 retval = do_for_each_reflog(log, fn, cb_data);
1607 unsigned char sha1[20];
1608 if (!resolve_ref(log, sha1, 0, NULL))
1609 retval = error("bad ref for %s", log);
1611 retval = fn(log, sha1, 0, cb_data);
1624 int for_each_reflog(each_ref_fn fn, void *cb_data)
1626 return do_for_each_reflog("", fn, cb_data);
1629 int update_ref(const char *action, const char *refname,
1630 const unsigned char *sha1, const unsigned char *oldval,
1631 int flags, enum action_on_err onerr)
1633 static struct ref_lock *lock;
1634 lock = lock_any_ref_for_update(refname, oldval, flags);
1636 const char *str = "Cannot lock the ref '%s'.";
1638 case MSG_ON_ERR: error(str, refname); break;
1639 case DIE_ON_ERR: die(str, refname); break;
1640 case QUIET_ON_ERR: break;
1644 if (write_ref_sha1(lock, sha1, action) < 0) {
1645 const char *str = "Cannot update the ref '%s'.";
1647 case MSG_ON_ERR: error(str, refname); break;
1648 case DIE_ON_ERR: die(str, refname); break;
1649 case QUIET_ON_ERR: break;
1656 struct ref *find_ref_by_name(const struct ref *list, const char *name)
1658 for ( ; list; list = list->next)
1659 if (!strcmp(list->name, name))
1660 return (struct ref *)list;
1665 * generate a format suitable for scanf from a ref_rev_parse_rules
1666 * rule, that is replace the "%.*s" spec with a "%s" spec
1668 static void gen_scanf_fmt(char *scanf_fmt, const char *rule)
1672 spec = strstr(rule, "%.*s");
1673 if (!spec || strstr(spec + 4, "%.*s"))
1674 die("invalid rule in ref_rev_parse_rules: %s", rule);
1676 /* copy all until spec */
1677 strncpy(scanf_fmt, rule, spec - rule);
1678 scanf_fmt[spec - rule] = '\0';
1680 strcat(scanf_fmt, "%s");
1681 /* copy remaining rule */
1682 strcat(scanf_fmt, spec + 4);
1687 char *shorten_unambiguous_ref(const char *ref, int strict)
1690 static char **scanf_fmts;
1691 static int nr_rules;
1694 /* pre generate scanf formats from ref_rev_parse_rules[] */
1696 size_t total_len = 0;
1698 /* the rule list is NULL terminated, count them first */
1699 for (; ref_rev_parse_rules[nr_rules]; nr_rules++)
1700 /* no +1 because strlen("%s") < strlen("%.*s") */
1701 total_len += strlen(ref_rev_parse_rules[nr_rules]);
1703 scanf_fmts = xmalloc(nr_rules * sizeof(char *) + total_len);
1706 for (i = 0; i < nr_rules; i++) {
1707 scanf_fmts[i] = (char *)&scanf_fmts[nr_rules]
1709 gen_scanf_fmt(scanf_fmts[i], ref_rev_parse_rules[i]);
1710 total_len += strlen(ref_rev_parse_rules[i]);
1714 /* bail out if there are no rules */
1716 return xstrdup(ref);
1718 /* buffer for scanf result, at most ref must fit */
1719 short_name = xstrdup(ref);
1721 /* skip first rule, it will always match */
1722 for (i = nr_rules - 1; i > 0 ; --i) {
1724 int rules_to_fail = i;
1727 if (1 != sscanf(ref, scanf_fmts[i], short_name))
1730 short_name_len = strlen(short_name);
1733 * in strict mode, all (except the matched one) rules
1734 * must fail to resolve to a valid non-ambiguous ref
1737 rules_to_fail = nr_rules;
1740 * check if the short name resolves to a valid ref,
1741 * but use only rules prior to the matched one
1743 for (j = 0; j < rules_to_fail; j++) {
1744 const char *rule = ref_rev_parse_rules[j];
1745 unsigned char short_objectname[20];
1746 char refname[PATH_MAX];
1748 /* skip matched rule */
1753 * the short name is ambiguous, if it resolves
1754 * (with this previous rule) to a valid ref
1755 * read_ref() returns 0 on success
1757 mksnpath(refname, sizeof(refname),
1758 rule, short_name_len, short_name);
1759 if (!read_ref(refname, short_objectname))
1764 * short name is non-ambiguous if all previous rules
1765 * haven't resolved to a valid ref
1767 if (j == rules_to_fail)
1772 return xstrdup(ref);