6 /* ISSYMREF=01 and ISPACKED=02 are public interfaces */
7 #define REF_KNOWS_PEELED 04
10 struct ref_list
*next
;
11 unsigned char flag
; /* ISSYMREF? ISPACKED? */
12 unsigned char sha1
[20];
13 unsigned char peeled
[20];
14 char name
[FLEX_ARRAY
];
17 static const char *parse_ref_line(char *line
, unsigned char *sha1
)
20 * 42: the answer to everything.
22 * In this case, it happens to be the answer to
23 * 40 (length of sha1 hex representation)
24 * +1 (space in between hex and name)
25 * +1 (newline at the end of the line)
27 int len
= strlen(line
) - 42;
31 if (get_sha1_hex(line
, sha1
) < 0)
33 if (!isspace(line
[40]))
38 if (line
[len
] != '\n')
45 static struct ref_list
*add_ref(const char *name
, const unsigned char *sha1
,
46 int flag
, struct ref_list
*list
,
47 struct ref_list
**new_entry
)
50 struct ref_list
**p
= &list
, *entry
;
52 /* Find the place to insert the ref into.. */
53 while ((entry
= *p
) != NULL
) {
54 int cmp
= strcmp(entry
->name
, name
);
58 /* Same as existing entry? */
67 /* Allocate it and add it in.. */
68 len
= strlen(name
) + 1;
69 entry
= xmalloc(sizeof(struct ref_list
) + len
);
70 hashcpy(entry
->sha1
, sha1
);
71 hashclr(entry
->peeled
);
72 memcpy(entry
->name
, name
, len
);
82 * Future: need to be in "struct repository"
83 * when doing a full libification.
88 struct ref_list
*loose
;
89 struct ref_list
*packed
;
92 static void free_ref_list(struct ref_list
*list
)
94 struct ref_list
*next
;
95 for ( ; list
; list
= next
) {
101 static void invalidate_cached_refs(void)
103 struct cached_refs
*ca
= &cached_refs
;
105 if (ca
->did_loose
&& ca
->loose
)
106 free_ref_list(ca
->loose
);
107 if (ca
->did_packed
&& ca
->packed
)
108 free_ref_list(ca
->packed
);
109 ca
->loose
= ca
->packed
= NULL
;
110 ca
->did_loose
= ca
->did_packed
= 0;
113 static void read_packed_refs(FILE *f
, struct cached_refs
*cached_refs
)
115 struct ref_list
*list
= NULL
;
116 struct ref_list
*last
= NULL
;
117 char refline
[PATH_MAX
];
118 int flag
= REF_ISPACKED
;
120 while (fgets(refline
, sizeof(refline
), f
)) {
121 unsigned char sha1
[20];
123 static const char header
[] = "# pack-refs with:";
125 if (!strncmp(refline
, header
, sizeof(header
)-1)) {
126 const char *traits
= refline
+ sizeof(header
) - 1;
127 if (strstr(traits
, " peeled "))
128 flag
|= REF_KNOWS_PEELED
;
129 /* perhaps other traits later as well */
133 name
= parse_ref_line(refline
, sha1
);
135 list
= add_ref(name
, sha1
, flag
, list
, &last
);
140 strlen(refline
) == 42 &&
141 refline
[41] == '\n' &&
142 !get_sha1_hex(refline
+ 1, sha1
))
143 hashcpy(last
->peeled
, sha1
);
145 cached_refs
->packed
= list
;
148 static struct ref_list
*get_packed_refs(void)
150 if (!cached_refs
.did_packed
) {
151 FILE *f
= fopen(git_path("packed-refs"), "r");
152 cached_refs
.packed
= NULL
;
154 read_packed_refs(f
, &cached_refs
);
157 cached_refs
.did_packed
= 1;
159 return cached_refs
.packed
;
162 static struct ref_list
*get_ref_dir(const char *base
, struct ref_list
*list
)
164 DIR *dir
= opendir(git_path("%s", base
));
168 int baselen
= strlen(base
);
169 char *ref
= xmalloc(baselen
+ 257);
171 memcpy(ref
, base
, baselen
);
172 if (baselen
&& base
[baselen
-1] != '/')
173 ref
[baselen
++] = '/';
175 while ((de
= readdir(dir
)) != NULL
) {
176 unsigned char sha1
[20];
181 if (de
->d_name
[0] == '.')
183 namelen
= strlen(de
->d_name
);
186 if (has_extension(de
->d_name
, ".lock"))
188 memcpy(ref
+ baselen
, de
->d_name
, namelen
+1);
189 if (stat(git_path("%s", ref
), &st
) < 0)
191 if (S_ISDIR(st
.st_mode
)) {
192 list
= get_ref_dir(ref
, list
);
195 if (!resolve_ref(ref
, sha1
, 1, &flag
)) {
196 error("%s points nowhere!", ref
);
199 list
= add_ref(ref
, sha1
, flag
, list
, NULL
);
207 static struct ref_list
*get_loose_refs(void)
209 if (!cached_refs
.did_loose
) {
210 cached_refs
.loose
= get_ref_dir("refs", NULL
);
211 cached_refs
.did_loose
= 1;
213 return cached_refs
.loose
;
216 /* We allow "recursive" symbolic refs. Only within reason, though */
219 const char *resolve_ref(const char *ref
, unsigned char *sha1
, int reading
, int *flag
)
221 int depth
= MAXDEPTH
, len
;
223 static char ref_buffer
[256];
229 const char *path
= git_path("%s", ref
);
237 /* Special case: non-existing file.
238 * Not having the refs/heads/new-branch is OK
239 * if we are writing into it, so is .git/HEAD
240 * that points at refs/heads/master still to be
241 * born. It is NOT OK if we are resolving for
244 if (lstat(path
, &st
) < 0) {
245 struct ref_list
*list
= get_packed_refs();
247 if (!strcmp(ref
, list
->name
)) {
248 hashcpy(sha1
, list
->sha1
);
250 *flag
|= REF_ISPACKED
;
255 if (reading
|| errno
!= ENOENT
)
261 /* Follow "normalized" - ie "refs/.." symlinks by hand */
262 if (S_ISLNK(st
.st_mode
)) {
263 len
= readlink(path
, buffer
, sizeof(buffer
)-1);
264 if (len
>= 5 && !memcmp("refs/", buffer
, 5)) {
266 strcpy(ref_buffer
, buffer
);
269 *flag
|= REF_ISSYMREF
;
274 /* Is it a directory? */
275 if (S_ISDIR(st
.st_mode
)) {
281 * Anything else, just open it and try to use it as
284 fd
= open(path
, O_RDONLY
);
287 len
= read_in_full(fd
, buffer
, sizeof(buffer
)-1);
291 * Is it a symbolic ref?
293 if (len
< 4 || memcmp("ref:", buffer
, 4))
297 while (len
&& isspace(*buf
))
299 while (len
&& isspace(buf
[len
-1]))
302 memcpy(ref_buffer
, buf
, len
+ 1);
305 *flag
|= REF_ISSYMREF
;
307 if (len
< 40 || get_sha1_hex(buffer
, sha1
))
312 int create_symref(const char *ref_target
, const char *refs_heads_master
)
314 const char *lockpath
;
316 int fd
, len
, written
;
317 const char *git_HEAD
= git_path("%s", ref_target
);
319 #ifndef NO_SYMLINK_HEAD
320 if (prefer_symlink_refs
) {
322 if (!symlink(refs_heads_master
, git_HEAD
))
324 fprintf(stderr
, "no symlink - falling back to symbolic ref\n");
328 len
= snprintf(ref
, sizeof(ref
), "ref: %s\n", refs_heads_master
);
329 if (sizeof(ref
) <= len
) {
330 error("refname too long: %s", refs_heads_master
);
333 lockpath
= mkpath("%s.lock", git_HEAD
);
334 fd
= open(lockpath
, O_CREAT
| O_EXCL
| O_WRONLY
, 0666);
336 error("Unable to open %s for writing", lockpath
);
339 written
= write_in_full(fd
, ref
, len
);
341 if (written
!= len
) {
343 error("Unable to write to %s", lockpath
);
346 if (rename(lockpath
, git_HEAD
) < 0) {
348 error("Unable to create %s", git_HEAD
);
351 if (adjust_shared_perm(git_HEAD
)) {
353 error("Unable to fix permissions on %s", lockpath
);
359 int read_ref(const char *ref
, unsigned char *sha1
)
361 if (resolve_ref(ref
, sha1
, 1, NULL
))
366 static int do_one_ref(const char *base
, each_ref_fn fn
, int trim
,
367 void *cb_data
, struct ref_list
*entry
)
369 if (strncmp(base
, entry
->name
, trim
))
371 if (is_null_sha1(entry
->sha1
))
373 if (!has_sha1_file(entry
->sha1
)) {
374 error("%s does not point to a valid object!", entry
->name
);
377 return fn(entry
->name
+ trim
, entry
->sha1
, entry
->flag
, cb_data
);
380 int peel_ref(const char *ref
, unsigned char *sha1
)
383 unsigned char base
[20];
386 if (!resolve_ref(ref
, base
, 1, &flag
))
389 if ((flag
& REF_ISPACKED
)) {
390 struct ref_list
*list
= get_packed_refs();
393 if (!strcmp(list
->name
, ref
)) {
394 if (list
->flag
& REF_KNOWS_PEELED
) {
395 hashcpy(sha1
, list
->peeled
);
398 /* older pack-refs did not leave peeled ones */
405 /* fallback - callers should not call this for unpacked refs */
406 o
= parse_object(base
);
407 if (o
->type
== OBJ_TAG
) {
408 o
= deref_tag(o
, ref
, 0);
410 hashcpy(sha1
, o
->sha1
);
417 static int do_for_each_ref(const char *base
, each_ref_fn fn
, int trim
,
421 struct ref_list
*packed
= get_packed_refs();
422 struct ref_list
*loose
= get_loose_refs();
424 while (packed
&& loose
) {
425 struct ref_list
*entry
;
426 int cmp
= strcmp(packed
->name
, loose
->name
);
428 packed
= packed
->next
;
436 packed
= packed
->next
;
438 retval
= do_one_ref(base
, fn
, trim
, cb_data
, entry
);
443 for (packed
= packed
? packed
: loose
; packed
; packed
= packed
->next
) {
444 retval
= do_one_ref(base
, fn
, trim
, cb_data
, packed
);
451 int head_ref(each_ref_fn fn
, void *cb_data
)
453 unsigned char sha1
[20];
456 if (resolve_ref("HEAD", sha1
, 1, &flag
))
457 return fn("HEAD", sha1
, flag
, cb_data
);
461 int for_each_ref(each_ref_fn fn
, void *cb_data
)
463 return do_for_each_ref("refs/", fn
, 0, cb_data
);
466 int for_each_tag_ref(each_ref_fn fn
, void *cb_data
)
468 return do_for_each_ref("refs/tags/", fn
, 10, cb_data
);
471 int for_each_branch_ref(each_ref_fn fn
, void *cb_data
)
473 return do_for_each_ref("refs/heads/", fn
, 11, cb_data
);
476 int for_each_remote_ref(each_ref_fn fn
, void *cb_data
)
478 return do_for_each_ref("refs/remotes/", fn
, 13, cb_data
);
481 /* NEEDSWORK: This is only used by ssh-upload and it should go; the
482 * caller should do resolve_ref or read_ref like everybody else. Or
483 * maybe everybody else should use get_ref_sha1() instead of doing
486 int get_ref_sha1(const char *ref
, unsigned char *sha1
)
488 if (check_ref_format(ref
))
490 return read_ref(mkpath("refs/%s", ref
), sha1
);
494 * Make sure "ref" is something reasonable to have under ".git/refs/";
495 * We do not like it if:
497 * - any path component of it begins with ".", or
498 * - it has double dots "..", or
499 * - it has ASCII control character, "~", "^", ":" or SP, anywhere, or
500 * - it ends with a "/".
503 static inline int bad_ref_char(int ch
)
505 return (((unsigned) ch
) <= ' ' ||
506 ch
== '~' || ch
== '^' || ch
== ':' ||
507 /* 2.13 Pattern Matching Notation */
508 ch
== '?' || ch
== '*' || ch
== '[');
511 int check_ref_format(const char *ref
)
514 const char *cp
= ref
;
518 while ((ch
= *cp
++) == '/')
519 ; /* tolerate duplicated slashes */
521 return -1; /* should not end with slashes */
523 /* we are at the beginning of the path component */
524 if (ch
== '.' || bad_ref_char(ch
))
527 /* scan the rest of the path component */
528 while ((ch
= *cp
++) != 0) {
529 if (bad_ref_char(ch
))
533 if (ch
== '.' && *cp
== '.')
539 return -2; /* at least of form "heads/blah" */
545 static struct ref_lock
*verify_lock(struct ref_lock
*lock
,
546 const unsigned char *old_sha1
, int mustexist
)
548 if (!resolve_ref(lock
->ref_name
, lock
->old_sha1
, mustexist
, NULL
)) {
549 error("Can't verify ref %s", lock
->ref_name
);
553 if (hashcmp(lock
->old_sha1
, old_sha1
)) {
554 error("Ref %s is at %s but expected %s", lock
->ref_name
,
555 sha1_to_hex(lock
->old_sha1
), sha1_to_hex(old_sha1
));
562 static int remove_empty_dir_recursive(char *path
, int len
)
564 DIR *dir
= opendir(path
);
570 if (path
[len
-1] != '/')
572 while ((e
= readdir(dir
)) != NULL
) {
575 if ((e
->d_name
[0] == '.') &&
576 ((e
->d_name
[1] == 0) ||
577 ((e
->d_name
[1] == '.') && e
->d_name
[2] == 0)))
578 continue; /* "." and ".." */
580 namlen
= strlen(e
->d_name
);
581 if ((len
+ namlen
< PATH_MAX
) &&
582 strcpy(path
+ len
, e
->d_name
) &&
584 S_ISDIR(st
.st_mode
) &&
585 !remove_empty_dir_recursive(path
, len
+ namlen
))
586 continue; /* happy */
588 /* path too long, stat fails, or non-directory still exists */
600 static int remove_empty_directories(char *file
)
602 /* we want to create a file but there is a directory there;
603 * if that is an empty directory (or a directory that contains
604 * only empty directories), remove them.
607 int len
= strlen(file
);
609 if (len
>= PATH_MAX
) /* path too long ;-) */
612 return remove_empty_dir_recursive(path
, len
);
615 static int is_refname_available(const char *ref
, const char *oldref
,
616 struct ref_list
*list
, int quiet
)
618 int namlen
= strlen(ref
); /* e.g. 'foo/bar' */
620 /* list->name could be 'foo' or 'foo/bar/baz' */
621 if (!oldref
|| strcmp(oldref
, list
->name
)) {
622 int len
= strlen(list
->name
);
623 int cmplen
= (namlen
< len
) ? namlen
: len
;
624 const char *lead
= (namlen
< len
) ? list
->name
: ref
;
625 if (!strncmp(ref
, list
->name
, cmplen
) &&
626 lead
[cmplen
] == '/') {
628 error("'%s' exists; cannot create '%s'",
638 static struct ref_lock
*lock_ref_sha1_basic(const char *ref
, const unsigned char *old_sha1
, int *flag
)
641 const char *orig_ref
= ref
;
642 struct ref_lock
*lock
;
645 int mustexist
= (old_sha1
&& !is_null_sha1(old_sha1
));
647 lock
= xcalloc(1, sizeof(struct ref_lock
));
650 ref
= resolve_ref(ref
, lock
->old_sha1
, mustexist
, flag
);
651 if (!ref
&& errno
== EISDIR
) {
652 /* we are trying to lock foo but we used to
653 * have foo/bar which now does not exist;
654 * it is normal for the empty directory 'foo'
657 ref_file
= git_path("%s", orig_ref
);
658 if (remove_empty_directories(ref_file
)) {
660 error("there are still refs under '%s'", orig_ref
);
663 ref
= resolve_ref(orig_ref
, lock
->old_sha1
, mustexist
, flag
);
667 error("unable to resolve reference %s: %s",
668 orig_ref
, strerror(errno
));
671 /* When the ref did not exist and we are creating it,
672 * make sure there is no existing ref that is packed
673 * whose name begins with our refname, nor a ref whose
674 * name is a proper prefix of our refname.
676 if (is_null_sha1(lock
->old_sha1
) &&
677 !is_refname_available(ref
, NULL
, get_packed_refs(), 0))
680 lock
->lk
= xcalloc(1, sizeof(struct lock_file
));
682 lock
->ref_name
= xstrdup(ref
);
683 lock
->orig_ref_name
= xstrdup(orig_ref
);
684 ref_file
= git_path("%s", ref
);
685 lock
->force_write
= lstat(ref_file
, &st
) && errno
== ENOENT
;
687 if (safe_create_leading_directories(ref_file
)) {
689 error("unable to create directory for %s", ref_file
);
692 lock
->lock_fd
= hold_lock_file_for_update(lock
->lk
, ref_file
, 1);
694 return old_sha1
? verify_lock(lock
, old_sha1
, mustexist
) : lock
;
702 struct ref_lock
*lock_ref_sha1(const char *ref
, const unsigned char *old_sha1
)
704 char refpath
[PATH_MAX
];
705 if (check_ref_format(ref
))
707 strcpy(refpath
, mkpath("refs/%s", ref
));
708 return lock_ref_sha1_basic(refpath
, old_sha1
, NULL
);
711 struct ref_lock
*lock_any_ref_for_update(const char *ref
, const unsigned char *old_sha1
)
713 return lock_ref_sha1_basic(ref
, old_sha1
, NULL
);
716 static struct lock_file packlock
;
718 static int repack_without_ref(const char *refname
)
720 struct ref_list
*list
, *packed_ref_list
;
724 packed_ref_list
= get_packed_refs();
725 for (list
= packed_ref_list
; list
; list
= list
->next
) {
726 if (!strcmp(refname
, list
->name
)) {
733 fd
= hold_lock_file_for_update(&packlock
, git_path("packed-refs"), 0);
735 return error("cannot delete '%s' from packed refs", refname
);
737 for (list
= packed_ref_list
; list
; list
= list
->next
) {
738 char line
[PATH_MAX
+ 100];
741 if (!strcmp(refname
, list
->name
))
743 len
= snprintf(line
, sizeof(line
), "%s %s\n",
744 sha1_to_hex(list
->sha1
), list
->name
);
745 /* this should not happen but just being defensive */
746 if (len
> sizeof(line
))
747 die("too long a refname '%s'", list
->name
);
748 write_or_die(fd
, line
, len
);
750 return commit_lock_file(&packlock
);
753 int delete_ref(const char *refname
, unsigned char *sha1
)
755 struct ref_lock
*lock
;
756 int err
, i
, ret
= 0, flag
= 0;
758 lock
= lock_ref_sha1_basic(refname
, sha1
, &flag
);
761 if (!(flag
& REF_ISPACKED
)) {
763 i
= strlen(lock
->lk
->filename
) - 5; /* .lock */
764 lock
->lk
->filename
[i
] = 0;
765 err
= unlink(lock
->lk
->filename
);
768 error("unlink(%s) failed: %s",
769 lock
->lk
->filename
, strerror(errno
));
771 lock
->lk
->filename
[i
] = '.';
773 /* removing the loose one could have resurrected an earlier
774 * packed one. Also, if it was not loose we need to repack
777 ret
|= repack_without_ref(refname
);
779 err
= unlink(git_path("logs/%s", lock
->ref_name
));
780 if (err
&& errno
!= ENOENT
)
781 fprintf(stderr
, "warning: unlink(%s) failed: %s",
782 git_path("logs/%s", lock
->ref_name
), strerror(errno
));
783 invalidate_cached_refs();
788 int rename_ref(const char *oldref
, const char *newref
, const char *logmsg
)
790 static const char renamed_ref
[] = "RENAMED-REF";
791 unsigned char sha1
[20], orig_sha1
[20];
792 int flag
= 0, logmoved
= 0;
793 struct ref_lock
*lock
;
795 int log
= !lstat(git_path("logs/%s", oldref
), &loginfo
);
797 if (S_ISLNK(loginfo
.st_mode
))
798 return error("reflog for %s is a symlink", oldref
);
800 if (!resolve_ref(oldref
, orig_sha1
, 1, &flag
))
801 return error("refname %s not found", oldref
);
803 if (!is_refname_available(newref
, oldref
, get_packed_refs(), 0))
806 if (!is_refname_available(newref
, oldref
, get_loose_refs(), 0))
809 lock
= lock_ref_sha1_basic(renamed_ref
, NULL
, NULL
);
811 return error("unable to lock %s", renamed_ref
);
812 lock
->force_write
= 1;
813 if (write_ref_sha1(lock
, orig_sha1
, logmsg
))
814 return error("unable to save current sha1 in %s", renamed_ref
);
816 if (log
&& rename(git_path("logs/%s", oldref
), git_path("tmp-renamed-log")))
817 return error("unable to move logfile logs/%s to tmp-renamed-log: %s",
818 oldref
, strerror(errno
));
820 if (delete_ref(oldref
, orig_sha1
)) {
821 error("unable to delete old %s", oldref
);
825 if (resolve_ref(newref
, sha1
, 1, &flag
) && delete_ref(newref
, sha1
)) {
827 if (remove_empty_directories(git_path("%s", newref
))) {
828 error("Directory not empty: %s", newref
);
832 error("unable to delete existing %s", newref
);
837 if (log
&& safe_create_leading_directories(git_path("logs/%s", newref
))) {
838 error("unable to create directory for %s", newref
);
843 if (log
&& rename(git_path("tmp-renamed-log"), git_path("logs/%s", newref
))) {
844 if (errno
==EISDIR
|| errno
==ENOTDIR
) {
846 * rename(a, b) when b is an existing
847 * directory ought to result in ISDIR, but
848 * Solaris 5.8 gives ENOTDIR. Sheesh.
850 if (remove_empty_directories(git_path("logs/%s", newref
))) {
851 error("Directory not empty: logs/%s", newref
);
856 error("unable to move logfile tmp-renamed-log to logs/%s: %s",
857 newref
, strerror(errno
));
863 lock
= lock_ref_sha1_basic(newref
, NULL
, NULL
);
865 error("unable to lock %s for update", newref
);
869 lock
->force_write
= 1;
870 hashcpy(lock
->old_sha1
, orig_sha1
);
871 if (write_ref_sha1(lock
, orig_sha1
, logmsg
)) {
872 error("unable to write current sha1 into %s", newref
);
876 if (!strncmp(oldref
, "refs/heads/", 11) &&
877 !strncmp(newref
, "refs/heads/", 11)) {
878 char oldsection
[1024], newsection
[1024];
880 snprintf(oldsection
, 1024, "branch.%s", oldref
+ 11);
881 snprintf(newsection
, 1024, "branch.%s", newref
+ 11);
882 if (git_config_rename_section(oldsection
, newsection
) < 0)
889 lock
= lock_ref_sha1_basic(oldref
, NULL
, NULL
);
891 error("unable to lock %s for rollback", oldref
);
895 lock
->force_write
= 1;
896 flag
= log_all_ref_updates
;
897 log_all_ref_updates
= 0;
898 if (write_ref_sha1(lock
, orig_sha1
, NULL
))
899 error("unable to write current sha1 into %s", oldref
);
900 log_all_ref_updates
= flag
;
903 if (logmoved
&& rename(git_path("logs/%s", newref
), git_path("logs/%s", oldref
)))
904 error("unable to restore logfile %s from %s: %s",
905 oldref
, newref
, strerror(errno
));
906 if (!logmoved
&& log
&&
907 rename(git_path("tmp-renamed-log"), git_path("logs/%s", oldref
)))
908 error("unable to restore logfile %s from tmp-renamed-log: %s",
909 oldref
, strerror(errno
));
914 void unlock_ref(struct ref_lock
*lock
)
916 if (lock
->lock_fd
>= 0) {
917 close(lock
->lock_fd
);
918 /* Do not free lock->lk -- atexit() still looks at them */
920 rollback_lock_file(lock
->lk
);
922 free(lock
->ref_name
);
923 free(lock
->orig_ref_name
);
927 static int log_ref_write(const char *ref_name
, const unsigned char *old_sha1
,
928 const unsigned char *new_sha1
, const char *msg
)
930 int logfd
, written
, oflags
= O_APPEND
| O_WRONLY
;
931 unsigned maxlen
, len
;
933 char *log_file
, *logrec
;
934 const char *committer
;
936 if (log_all_ref_updates
< 0)
937 log_all_ref_updates
= !is_bare_repository();
939 log_file
= git_path("logs/%s", ref_name
);
941 if (log_all_ref_updates
&&
942 (!strncmp(ref_name
, "refs/heads/", 11) ||
943 !strncmp(ref_name
, "refs/remotes/", 13))) {
944 if (safe_create_leading_directories(log_file
) < 0)
945 return error("unable to create directory for %s",
950 logfd
= open(log_file
, oflags
, 0666);
952 if (!(oflags
& O_CREAT
) && errno
== ENOENT
)
955 if ((oflags
& O_CREAT
) && errno
== EISDIR
) {
956 if (remove_empty_directories(log_file
)) {
957 return error("There are still logs under '%s'",
960 logfd
= open(log_file
, oflags
, 0666);
964 return error("Unable to append to %s: %s",
965 log_file
, strerror(errno
));
970 /* clean up the message and make sure it is a single line */
975 const char *ep
= strchr(msg
, '\n');
979 msglen
= strlen(msg
);
983 committer
= git_committer_info(-1);
984 maxlen
= strlen(committer
) + msglen
+ 100;
985 logrec
= xmalloc(maxlen
);
986 len
= sprintf(logrec
, "%s %s %s\n",
987 sha1_to_hex(old_sha1
),
988 sha1_to_hex(new_sha1
),
991 len
+= sprintf(logrec
+ len
- 1, "\t%.*s\n", msglen
, msg
) - 1;
992 written
= len
<= maxlen
? write_in_full(logfd
, logrec
, len
) : -1;
996 return error("Unable to append to %s", log_file
);
1000 int write_ref_sha1(struct ref_lock
*lock
,
1001 const unsigned char *sha1
, const char *logmsg
)
1003 static char term
= '\n';
1007 if (!lock
->force_write
&& !hashcmp(lock
->old_sha1
, sha1
)) {
1011 if (write_in_full(lock
->lock_fd
, sha1_to_hex(sha1
), 40) != 40 ||
1012 write_in_full(lock
->lock_fd
, &term
, 1) != 1
1013 || close(lock
->lock_fd
) < 0) {
1014 error("Couldn't write %s", lock
->lk
->filename
);
1018 invalidate_cached_refs();
1019 if (log_ref_write(lock
->ref_name
, lock
->old_sha1
, sha1
, logmsg
) < 0) {
1023 if (commit_lock_file(lock
->lk
)) {
1024 error("Couldn't set %s", lock
->ref_name
);
1033 static char *ref_msg(const char *line
, const char *endp
)
1039 for (ep
= line
; ep
< endp
&& *ep
!= '\n'; ep
++)
1041 msg
= xmalloc(ep
- line
+ 1);
1042 memcpy(msg
, line
, ep
- line
);
1047 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
)
1049 const char *logfile
, *logdata
, *logend
, *rec
, *lastgt
, *lastrec
;
1051 int logfd
, tz
, reccnt
= 0;
1054 unsigned char logged_sha1
[20];
1057 logfile
= git_path("logs/%s", ref
);
1058 logfd
= open(logfile
, O_RDONLY
, 0);
1060 die("Unable to read log %s: %s", logfile
, strerror(errno
));
1063 die("Log %s is empty.", logfile
);
1064 log_mapped
= xmmap(NULL
, st
.st_size
, PROT_READ
, MAP_PRIVATE
, logfd
, 0);
1065 logdata
= log_mapped
;
1069 rec
= logend
= logdata
+ st
.st_size
;
1070 while (logdata
< rec
) {
1072 if (logdata
< rec
&& *(rec
-1) == '\n')
1075 while (logdata
< rec
&& *(rec
-1) != '\n') {
1081 die("Log %s is corrupt.", logfile
);
1082 date
= strtoul(lastgt
+ 1, &tz_c
, 10);
1083 if (date
<= at_time
|| cnt
== 0) {
1084 tz
= strtoul(tz_c
, NULL
, 10);
1086 *msg
= ref_msg(rec
, logend
);
1088 *cutoff_time
= date
;
1092 *cutoff_cnt
= reccnt
- 1;
1094 if (get_sha1_hex(lastrec
, logged_sha1
))
1095 die("Log %s is corrupt.", logfile
);
1096 if (get_sha1_hex(rec
+ 41, sha1
))
1097 die("Log %s is corrupt.", logfile
);
1098 if (hashcmp(logged_sha1
, sha1
)) {
1100 "warning: Log %s has gap after %s.\n",
1101 logfile
, show_rfc2822_date(date
, tz
));
1104 else if (date
== at_time
) {
1105 if (get_sha1_hex(rec
+ 41, sha1
))
1106 die("Log %s is corrupt.", logfile
);
1109 if (get_sha1_hex(rec
+ 41, logged_sha1
))
1110 die("Log %s is corrupt.", logfile
);
1111 if (hashcmp(logged_sha1
, sha1
)) {
1113 "warning: Log %s unexpectedly ended on %s.\n",
1114 logfile
, show_rfc2822_date(date
, tz
));
1117 munmap(log_mapped
, st
.st_size
);
1126 while (rec
< logend
&& *rec
!= '>' && *rec
!= '\n')
1128 if (rec
== logend
|| *rec
== '\n')
1129 die("Log %s is corrupt.", logfile
);
1130 date
= strtoul(rec
+ 1, &tz_c
, 10);
1131 tz
= strtoul(tz_c
, NULL
, 10);
1132 if (get_sha1_hex(logdata
, sha1
))
1133 die("Log %s is corrupt.", logfile
);
1135 *msg
= ref_msg(logdata
, logend
);
1136 munmap(log_mapped
, st
.st_size
);
1139 *cutoff_time
= date
;
1143 *cutoff_cnt
= reccnt
;
1147 int for_each_reflog_ent(const char *ref
, each_reflog_ent_fn fn
, void *cb_data
)
1149 const char *logfile
;
1154 logfile
= git_path("logs/%s", ref
);
1155 logfp
= fopen(logfile
, "r");
1158 while (fgets(buf
, sizeof(buf
), logfp
)) {
1159 unsigned char osha1
[20], nsha1
[20];
1160 char *email_end
, *message
;
1161 unsigned long timestamp
;
1164 /* old SP new SP name <email> SP time TAB msg LF */
1166 if (len
< 83 || buf
[len
-1] != '\n' ||
1167 get_sha1_hex(buf
, osha1
) || buf
[40] != ' ' ||
1168 get_sha1_hex(buf
+ 41, nsha1
) || buf
[81] != ' ' ||
1169 !(email_end
= strchr(buf
+ 82, '>')) ||
1170 email_end
[1] != ' ' ||
1171 !(timestamp
= strtoul(email_end
+ 2, &message
, 10)) ||
1172 !message
|| message
[0] != ' ' ||
1173 (message
[1] != '+' && message
[1] != '-') ||
1174 !isdigit(message
[2]) || !isdigit(message
[3]) ||
1175 !isdigit(message
[4]) || !isdigit(message
[5]) ||
1177 continue; /* corrupt? */
1178 email_end
[1] = '\0';
1179 tz
= strtol(message
+ 1, NULL
, 10);
1181 ret
= fn(osha1
, nsha1
, buf
+82, timestamp
, tz
, message
, cb_data
);