Merge branch 'maint'
[git] / refs.c
1 #include "refs.h"
2 #include "cache.h"
3
4 #include <errno.h>
5
6 struct ref_list {
7         struct ref_list *next;
8         unsigned char flag; /* ISSYMREF? ISPACKED? */
9         unsigned char sha1[20];
10         char name[FLEX_ARRAY];
11 };
12
13 static const char *parse_ref_line(char *line, unsigned char *sha1)
14 {
15         /*
16          * 42: the answer to everything.
17          *
18          * In this case, it happens to be the answer to
19          *  40 (length of sha1 hex representation)
20          *  +1 (space in between hex and name)
21          *  +1 (newline at the end of the line)
22          */
23         int len = strlen(line) - 42;
24
25         if (len <= 0)
26                 return NULL;
27         if (get_sha1_hex(line, sha1) < 0)
28                 return NULL;
29         if (!isspace(line[40]))
30                 return NULL;
31         line += 41;
32         if (isspace(*line))
33                 return NULL;
34         if (line[len] != '\n')
35                 return NULL;
36         line[len] = 0;
37         return line;
38 }
39
40 static struct ref_list *add_ref(const char *name, const unsigned char *sha1,
41                                 int flag, struct ref_list *list)
42 {
43         int len;
44         struct ref_list **p = &list, *entry;
45
46         /* Find the place to insert the ref into.. */
47         while ((entry = *p) != NULL) {
48                 int cmp = strcmp(entry->name, name);
49                 if (cmp > 0)
50                         break;
51
52                 /* Same as existing entry? */
53                 if (!cmp)
54                         return list;
55                 p = &entry->next;
56         }
57
58         /* Allocate it and add it in.. */
59         len = strlen(name) + 1;
60         entry = xmalloc(sizeof(struct ref_list) + len);
61         hashcpy(entry->sha1, sha1);
62         memcpy(entry->name, name, len);
63         entry->flag = flag;
64         entry->next = *p;
65         *p = entry;
66         return list;
67 }
68
69 /*
70  * Future: need to be in "struct repository"
71  * when doing a full libification.
72  */
73 struct cached_refs {
74         char did_loose;
75         char did_packed;
76         struct ref_list *loose;
77         struct ref_list *packed;
78 } cached_refs;
79
80 static void free_ref_list(struct ref_list *list)
81 {
82         struct ref_list *next;
83         for ( ; list; list = next) {
84                 next = list->next;
85                 free(list);
86         }
87 }
88
89 static void invalidate_cached_refs(void)
90 {
91         struct cached_refs *ca = &cached_refs;
92
93         if (ca->did_loose && ca->loose)
94                 free_ref_list(ca->loose);
95         if (ca->did_packed && ca->packed)
96                 free_ref_list(ca->packed);
97         ca->loose = ca->packed = NULL;
98         ca->did_loose = ca->did_packed = 0;
99 }
100
101 static struct ref_list *get_packed_refs(void)
102 {
103         if (!cached_refs.did_packed) {
104                 struct ref_list *refs = NULL;
105                 FILE *f = fopen(git_path("packed-refs"), "r");
106                 if (f) {
107                         struct ref_list *list = NULL;
108                         char refline[PATH_MAX];
109                         while (fgets(refline, sizeof(refline), f)) {
110                                 unsigned char sha1[20];
111                                 const char *name = parse_ref_line(refline, sha1);
112                                 if (!name)
113                                         continue;
114                                 list = add_ref(name, sha1, REF_ISPACKED, list);
115                         }
116                         fclose(f);
117                         refs = list;
118                 }
119                 cached_refs.packed = refs;
120                 cached_refs.did_packed = 1;
121         }
122         return cached_refs.packed;
123 }
124
125 static struct ref_list *get_ref_dir(const char *base, struct ref_list *list)
126 {
127         DIR *dir = opendir(git_path("%s", base));
128
129         if (dir) {
130                 struct dirent *de;
131                 int baselen = strlen(base);
132                 char *ref = xmalloc(baselen + 257);
133
134                 memcpy(ref, base, baselen);
135                 if (baselen && base[baselen-1] != '/')
136                         ref[baselen++] = '/';
137
138                 while ((de = readdir(dir)) != NULL) {
139                         unsigned char sha1[20];
140                         struct stat st;
141                         int flag;
142                         int namelen;
143
144                         if (de->d_name[0] == '.')
145                                 continue;
146                         namelen = strlen(de->d_name);
147                         if (namelen > 255)
148                                 continue;
149                         if (has_extension(de->d_name, ".lock"))
150                                 continue;
151                         memcpy(ref + baselen, de->d_name, namelen+1);
152                         if (stat(git_path("%s", ref), &st) < 0)
153                                 continue;
154                         if (S_ISDIR(st.st_mode)) {
155                                 list = get_ref_dir(ref, list);
156                                 continue;
157                         }
158                         if (!resolve_ref(ref, sha1, 1, &flag)) {
159                                 error("%s points nowhere!", ref);
160                                 continue;
161                         }
162                         list = add_ref(ref, sha1, flag, list);
163                 }
164                 free(ref);
165                 closedir(dir);
166         }
167         return list;
168 }
169
170 static struct ref_list *get_loose_refs(void)
171 {
172         if (!cached_refs.did_loose) {
173                 cached_refs.loose = get_ref_dir("refs", NULL);
174                 cached_refs.did_loose = 1;
175         }
176         return cached_refs.loose;
177 }
178
179 /* We allow "recursive" symbolic refs. Only within reason, though */
180 #define MAXDEPTH 5
181
182 const char *resolve_ref(const char *ref, unsigned char *sha1, int reading, int *flag)
183 {
184         int depth = MAXDEPTH, len;
185         char buffer[256];
186         static char ref_buffer[256];
187
188         if (flag)
189                 *flag = 0;
190
191         for (;;) {
192                 const char *path = git_path("%s", ref);
193                 struct stat st;
194                 char *buf;
195                 int fd;
196
197                 if (--depth < 0)
198                         return NULL;
199
200                 /* Special case: non-existing file.
201                  * Not having the refs/heads/new-branch is OK
202                  * if we are writing into it, so is .git/HEAD
203                  * that points at refs/heads/master still to be
204                  * born.  It is NOT OK if we are resolving for
205                  * reading.
206                  */
207                 if (lstat(path, &st) < 0) {
208                         struct ref_list *list = get_packed_refs();
209                         while (list) {
210                                 if (!strcmp(ref, list->name)) {
211                                         hashcpy(sha1, list->sha1);
212                                         if (flag)
213                                                 *flag |= REF_ISPACKED;
214                                         return ref;
215                                 }
216                                 list = list->next;
217                         }
218                         if (reading || errno != ENOENT)
219                                 return NULL;
220                         hashclr(sha1);
221                         return ref;
222                 }
223
224                 /* Follow "normalized" - ie "refs/.." symlinks by hand */
225                 if (S_ISLNK(st.st_mode)) {
226                         len = readlink(path, buffer, sizeof(buffer)-1);
227                         if (len >= 5 && !memcmp("refs/", buffer, 5)) {
228                                 buffer[len] = 0;
229                                 strcpy(ref_buffer, buffer);
230                                 ref = ref_buffer;
231                                 if (flag)
232                                         *flag |= REF_ISSYMREF;
233                                 continue;
234                         }
235                 }
236
237                 /* Is it a directory? */
238                 if (S_ISDIR(st.st_mode)) {
239                         errno = EISDIR;
240                         return NULL;
241                 }
242
243                 /*
244                  * Anything else, just open it and try to use it as
245                  * a ref
246                  */
247                 fd = open(path, O_RDONLY);
248                 if (fd < 0)
249                         return NULL;
250                 len = read(fd, buffer, sizeof(buffer)-1);
251                 close(fd);
252
253                 /*
254                  * Is it a symbolic ref?
255                  */
256                 if (len < 4 || memcmp("ref:", buffer, 4))
257                         break;
258                 buf = buffer + 4;
259                 len -= 4;
260                 while (len && isspace(*buf))
261                         buf++, len--;
262                 while (len && isspace(buf[len-1]))
263                         len--;
264                 buf[len] = 0;
265                 memcpy(ref_buffer, buf, len + 1);
266                 ref = ref_buffer;
267                 if (flag)
268                         *flag |= REF_ISSYMREF;
269         }
270         if (len < 40 || get_sha1_hex(buffer, sha1))
271                 return NULL;
272         return ref;
273 }
274
275 int create_symref(const char *ref_target, const char *refs_heads_master)
276 {
277         const char *lockpath;
278         char ref[1000];
279         int fd, len, written;
280         const char *git_HEAD = git_path("%s", ref_target);
281
282 #ifndef NO_SYMLINK_HEAD
283         if (prefer_symlink_refs) {
284                 unlink(git_HEAD);
285                 if (!symlink(refs_heads_master, git_HEAD))
286                         return 0;
287                 fprintf(stderr, "no symlink - falling back to symbolic ref\n");
288         }
289 #endif
290
291         len = snprintf(ref, sizeof(ref), "ref: %s\n", refs_heads_master);
292         if (sizeof(ref) <= len) {
293                 error("refname too long: %s", refs_heads_master);
294                 return -1;
295         }
296         lockpath = mkpath("%s.lock", git_HEAD);
297         fd = open(lockpath, O_CREAT | O_EXCL | O_WRONLY, 0666); 
298         written = write(fd, ref, len);
299         close(fd);
300         if (written != len) {
301                 unlink(lockpath);
302                 error("Unable to write to %s", lockpath);
303                 return -2;
304         }
305         if (rename(lockpath, git_HEAD) < 0) {
306                 unlink(lockpath);
307                 error("Unable to create %s", git_HEAD);
308                 return -3;
309         }
310         if (adjust_shared_perm(git_HEAD)) {
311                 unlink(lockpath);
312                 error("Unable to fix permissions on %s", lockpath);
313                 return -4;
314         }
315         return 0;
316 }
317
318 int read_ref(const char *ref, unsigned char *sha1)
319 {
320         if (resolve_ref(ref, sha1, 1, NULL))
321                 return 0;
322         return -1;
323 }
324
325 static int do_for_each_ref(const char *base, each_ref_fn fn, int trim,
326                            void *cb_data)
327 {
328         int retval;
329         struct ref_list *packed = get_packed_refs();
330         struct ref_list *loose = get_loose_refs();
331
332         while (packed && loose) {
333                 struct ref_list *entry;
334                 int cmp = strcmp(packed->name, loose->name);
335                 if (!cmp) {
336                         packed = packed->next;
337                         continue;
338                 }
339                 if (cmp > 0) {
340                         entry = loose;
341                         loose = loose->next;
342                 } else {
343                         entry = packed;
344                         packed = packed->next;
345                 }
346                 if (strncmp(base, entry->name, trim))
347                         continue;
348                 if (is_null_sha1(entry->sha1))
349                         continue;
350                 if (!has_sha1_file(entry->sha1)) {
351                         error("%s does not point to a valid object!", entry->name);
352                         continue;
353                 }
354                 retval = fn(entry->name + trim, entry->sha1,
355                             entry->flag, cb_data);
356                 if (retval)
357                         return retval;
358         }
359
360         packed = packed ? packed : loose;
361         while (packed) {
362                 if (!strncmp(base, packed->name, trim)) {
363                         retval = fn(packed->name + trim, packed->sha1,
364                                     packed->flag, cb_data);
365                         if (retval)
366                                 return retval;
367                 }
368                 packed = packed->next;
369         }
370         return 0;
371 }
372
373 int head_ref(each_ref_fn fn, void *cb_data)
374 {
375         unsigned char sha1[20];
376         int flag;
377
378         if (resolve_ref("HEAD", sha1, 1, &flag))
379                 return fn("HEAD", sha1, flag, cb_data);
380         return 0;
381 }
382
383 int for_each_ref(each_ref_fn fn, void *cb_data)
384 {
385         return do_for_each_ref("refs/", fn, 0, cb_data);
386 }
387
388 int for_each_tag_ref(each_ref_fn fn, void *cb_data)
389 {
390         return do_for_each_ref("refs/tags/", fn, 10, cb_data);
391 }
392
393 int for_each_branch_ref(each_ref_fn fn, void *cb_data)
394 {
395         return do_for_each_ref("refs/heads/", fn, 11, cb_data);
396 }
397
398 int for_each_remote_ref(each_ref_fn fn, void *cb_data)
399 {
400         return do_for_each_ref("refs/remotes/", fn, 13, cb_data);
401 }
402
403 /* NEEDSWORK: This is only used by ssh-upload and it should go; the
404  * caller should do resolve_ref or read_ref like everybody else.  Or
405  * maybe everybody else should use get_ref_sha1() instead of doing
406  * read_ref().
407  */
408 int get_ref_sha1(const char *ref, unsigned char *sha1)
409 {
410         if (check_ref_format(ref))
411                 return -1;
412         return read_ref(mkpath("refs/%s", ref), sha1);
413 }
414
415 /*
416  * Make sure "ref" is something reasonable to have under ".git/refs/";
417  * We do not like it if:
418  *
419  * - any path component of it begins with ".", or
420  * - it has double dots "..", or
421  * - it has ASCII control character, "~", "^", ":" or SP, anywhere, or
422  * - it ends with a "/".
423  */
424
425 static inline int bad_ref_char(int ch)
426 {
427         return (((unsigned) ch) <= ' ' ||
428                 ch == '~' || ch == '^' || ch == ':' ||
429                 /* 2.13 Pattern Matching Notation */
430                 ch == '?' || ch == '*' || ch == '[');
431 }
432
433 int check_ref_format(const char *ref)
434 {
435         int ch, level;
436         const char *cp = ref;
437
438         level = 0;
439         while (1) {
440                 while ((ch = *cp++) == '/')
441                         ; /* tolerate duplicated slashes */
442                 if (!ch)
443                         return -1; /* should not end with slashes */
444
445                 /* we are at the beginning of the path component */
446                 if (ch == '.' || bad_ref_char(ch))
447                         return -1;
448
449                 /* scan the rest of the path component */
450                 while ((ch = *cp++) != 0) {
451                         if (bad_ref_char(ch))
452                                 return -1;
453                         if (ch == '/')
454                                 break;
455                         if (ch == '.' && *cp == '.')
456                                 return -1;
457                 }
458                 level++;
459                 if (!ch) {
460                         if (level < 2)
461                                 return -1; /* at least of form "heads/blah" */
462                         return 0;
463                 }
464         }
465 }
466
467 static struct ref_lock *verify_lock(struct ref_lock *lock,
468         const unsigned char *old_sha1, int mustexist)
469 {
470         if (!resolve_ref(lock->ref_name, lock->old_sha1, mustexist, NULL)) {
471                 error("Can't verify ref %s", lock->ref_name);
472                 unlock_ref(lock);
473                 return NULL;
474         }
475         if (hashcmp(lock->old_sha1, old_sha1)) {
476                 error("Ref %s is at %s but expected %s", lock->ref_name,
477                         sha1_to_hex(lock->old_sha1), sha1_to_hex(old_sha1));
478                 unlock_ref(lock);
479                 return NULL;
480         }
481         return lock;
482 }
483
484 static int remove_empty_dir_recursive(char *path, int len)
485 {
486         DIR *dir = opendir(path);
487         struct dirent *e;
488         int ret = 0;
489
490         if (!dir)
491                 return -1;
492         if (path[len-1] != '/')
493                 path[len++] = '/';
494         while ((e = readdir(dir)) != NULL) {
495                 struct stat st;
496                 int namlen;
497                 if ((e->d_name[0] == '.') &&
498                     ((e->d_name[1] == 0) ||
499                      ((e->d_name[1] == '.') && e->d_name[2] == 0)))
500                         continue; /* "." and ".." */
501
502                 namlen = strlen(e->d_name);
503                 if ((len + namlen < PATH_MAX) &&
504                     strcpy(path + len, e->d_name) &&
505                     !lstat(path, &st) &&
506                     S_ISDIR(st.st_mode) &&
507                     !remove_empty_dir_recursive(path, len + namlen))
508                         continue; /* happy */
509
510                 /* path too long, stat fails, or non-directory still exists */
511                 ret = -1;
512                 break;
513         }
514         closedir(dir);
515         if (!ret) {
516                 path[len] = 0;
517                 ret = rmdir(path);
518         }
519         return ret;
520 }
521
522 static int remove_empty_directories(char *file)
523 {
524         /* we want to create a file but there is a directory there;
525          * if that is an empty directory (or a directory that contains
526          * only empty directories), remove them.
527          */
528         char path[PATH_MAX];
529         int len = strlen(file);
530
531         if (len >= PATH_MAX) /* path too long ;-) */
532                 return -1;
533         strcpy(path, file);
534         return remove_empty_dir_recursive(path, len);
535 }
536
537 static struct ref_lock *lock_ref_sha1_basic(const char *ref, const unsigned char *old_sha1, int *flag)
538 {
539         char *ref_file;
540         const char *orig_ref = ref;
541         struct ref_lock *lock;
542         struct stat st;
543         int last_errno = 0;
544         int mustexist = (old_sha1 && !is_null_sha1(old_sha1));
545
546         lock = xcalloc(1, sizeof(struct ref_lock));
547         lock->lock_fd = -1;
548
549         ref = resolve_ref(ref, lock->old_sha1, mustexist, flag);
550         if (!ref && errno == EISDIR) {
551                 /* we are trying to lock foo but we used to
552                  * have foo/bar which now does not exist;
553                  * it is normal for the empty directory 'foo'
554                  * to remain.
555                  */
556                 ref_file = git_path("%s", orig_ref);
557                 if (remove_empty_directories(ref_file)) {
558                         last_errno = errno;
559                         error("there are still refs under '%s'", orig_ref);
560                         goto error_return;
561                 }
562                 ref = resolve_ref(orig_ref, lock->old_sha1, mustexist, flag);
563         }
564         if (!ref) {
565                 last_errno = errno;
566                 error("unable to resolve reference %s: %s",
567                         orig_ref, strerror(errno));
568                 goto error_return;
569         }
570         if (is_null_sha1(lock->old_sha1)) {
571                 /* The ref did not exist and we are creating it.
572                  * Make sure there is no existing ref that is packed
573                  * whose name begins with our refname, nor a ref whose
574                  * name is a proper prefix of our refname.
575                  */
576                 int namlen = strlen(ref); /* e.g. 'foo/bar' */
577                 struct ref_list *list = get_packed_refs();
578                 while (list) {
579                         /* list->name could be 'foo' or 'foo/bar/baz' */
580                         int len = strlen(list->name);
581                         int cmplen = (namlen < len) ? namlen : len;
582                         const char *lead = (namlen < len) ? list->name : ref;
583
584                         if (!strncmp(ref, list->name, cmplen) &&
585                             lead[cmplen] == '/') {
586                                 error("'%s' exists; cannot create '%s'",
587                                       list->name, ref);
588                                 goto error_return;
589                         }
590                         list = list->next;
591                 }
592         }
593
594         lock->lk = xcalloc(1, sizeof(struct lock_file));
595
596         lock->ref_name = xstrdup(ref);
597         lock->log_file = xstrdup(git_path("logs/%s", ref));
598         ref_file = git_path("%s", ref);
599         lock->force_write = lstat(ref_file, &st) && errno == ENOENT;
600
601         if (safe_create_leading_directories(ref_file)) {
602                 last_errno = errno;
603                 error("unable to create directory for %s", ref_file);
604                 goto error_return;
605         }
606         lock->lock_fd = hold_lock_file_for_update(lock->lk, ref_file, 1);
607
608         return old_sha1 ? verify_lock(lock, old_sha1, mustexist) : lock;
609
610  error_return:
611         unlock_ref(lock);
612         errno = last_errno;
613         return NULL;
614 }
615
616 struct ref_lock *lock_ref_sha1(const char *ref, const unsigned char *old_sha1)
617 {
618         char refpath[PATH_MAX];
619         if (check_ref_format(ref))
620                 return NULL;
621         strcpy(refpath, mkpath("refs/%s", ref));
622         return lock_ref_sha1_basic(refpath, old_sha1, NULL);
623 }
624
625 struct ref_lock *lock_any_ref_for_update(const char *ref, const unsigned char *old_sha1)
626 {
627         return lock_ref_sha1_basic(ref, old_sha1, NULL);
628 }
629
630 static struct lock_file packlock;
631
632 static int repack_without_ref(const char *refname)
633 {
634         struct ref_list *list, *packed_ref_list;
635         int fd;
636         int found = 0;
637
638         packed_ref_list = get_packed_refs();
639         for (list = packed_ref_list; list; list = list->next) {
640                 if (!strcmp(refname, list->name)) {
641                         found = 1;
642                         break;
643                 }
644         }
645         if (!found)
646                 return 0;
647         memset(&packlock, 0, sizeof(packlock));
648         fd = hold_lock_file_for_update(&packlock, git_path("packed-refs"), 0);
649         if (fd < 0)
650                 return error("cannot delete '%s' from packed refs", refname);
651
652         for (list = packed_ref_list; list; list = list->next) {
653                 char line[PATH_MAX + 100];
654                 int len;
655
656                 if (!strcmp(refname, list->name))
657                         continue;
658                 len = snprintf(line, sizeof(line), "%s %s\n",
659                                sha1_to_hex(list->sha1), list->name);
660                 /* this should not happen but just being defensive */
661                 if (len > sizeof(line))
662                         die("too long a refname '%s'", list->name);
663                 write_or_die(fd, line, len);
664         }
665         return commit_lock_file(&packlock);
666 }
667
668 int delete_ref(const char *refname, unsigned char *sha1)
669 {
670         struct ref_lock *lock;
671         int err, i, ret = 0, flag = 0;
672
673         lock = lock_ref_sha1_basic(refname, sha1, &flag);
674         if (!lock)
675                 return 1;
676         if (!(flag & REF_ISPACKED)) {
677                 /* loose */
678                 i = strlen(lock->lk->filename) - 5; /* .lock */
679                 lock->lk->filename[i] = 0;
680                 err = unlink(lock->lk->filename);
681                 if (err) {
682                         ret = 1;
683                         error("unlink(%s) failed: %s",
684                               lock->lk->filename, strerror(errno));
685                 }
686                 lock->lk->filename[i] = '.';
687         }
688         /* removing the loose one could have resurrected an earlier
689          * packed one.  Also, if it was not loose we need to repack
690          * without it.
691          */
692         ret |= repack_without_ref(refname);
693
694         err = unlink(lock->log_file);
695         if (err && errno != ENOENT)
696                 fprintf(stderr, "warning: unlink(%s) failed: %s",
697                         lock->log_file, strerror(errno));
698         invalidate_cached_refs();
699         unlock_ref(lock);
700         return ret;
701 }
702
703 void unlock_ref(struct ref_lock *lock)
704 {
705         if (lock->lock_fd >= 0) {
706                 close(lock->lock_fd);
707                 /* Do not free lock->lk -- atexit() still looks at them */
708                 if (lock->lk)
709                         rollback_lock_file(lock->lk);
710         }
711         free(lock->ref_name);
712         free(lock->log_file);
713         free(lock);
714 }
715
716 static int log_ref_write(struct ref_lock *lock,
717         const unsigned char *sha1, const char *msg)
718 {
719         int logfd, written, oflags = O_APPEND | O_WRONLY;
720         unsigned maxlen, len;
721         char *logrec;
722         const char *committer;
723
724         if (log_all_ref_updates &&
725             !strncmp(lock->ref_name, "refs/heads/", 11)) {
726                 if (safe_create_leading_directories(lock->log_file) < 0)
727                         return error("unable to create directory for %s",
728                                 lock->log_file);
729                 oflags |= O_CREAT;
730         }
731
732         logfd = open(lock->log_file, oflags, 0666);
733         if (logfd < 0) {
734                 if (!(oflags & O_CREAT) && errno == ENOENT)
735                         return 0;
736
737                 if ((oflags & O_CREAT) && errno == EISDIR) {
738                         if (remove_empty_directories(lock->log_file)) {
739                                 return error("There are still logs under '%s'",
740                                              lock->log_file);
741                         }
742                         logfd = open(lock->log_file, oflags, 0666);
743                 }
744
745                 if (logfd < 0)
746                         return error("Unable to append to %s: %s",
747                                      lock->log_file, strerror(errno));
748         }
749
750         committer = git_committer_info(1);
751         if (msg) {
752                 maxlen = strlen(committer) + strlen(msg) + 2*40 + 5;
753                 logrec = xmalloc(maxlen);
754                 len = snprintf(logrec, maxlen, "%s %s %s\t%s\n",
755                         sha1_to_hex(lock->old_sha1),
756                         sha1_to_hex(sha1),
757                         committer,
758                         msg);
759         }
760         else {
761                 maxlen = strlen(committer) + 2*40 + 4;
762                 logrec = xmalloc(maxlen);
763                 len = snprintf(logrec, maxlen, "%s %s %s\n",
764                         sha1_to_hex(lock->old_sha1),
765                         sha1_to_hex(sha1),
766                         committer);
767         }
768         written = len <= maxlen ? write(logfd, logrec, len) : -1;
769         free(logrec);
770         close(logfd);
771         if (written != len)
772                 return error("Unable to append to %s", lock->log_file);
773         return 0;
774 }
775
776 int write_ref_sha1(struct ref_lock *lock,
777         const unsigned char *sha1, const char *logmsg)
778 {
779         static char term = '\n';
780
781         if (!lock)
782                 return -1;
783         if (!lock->force_write && !hashcmp(lock->old_sha1, sha1)) {
784                 unlock_ref(lock);
785                 return 0;
786         }
787         if (write(lock->lock_fd, sha1_to_hex(sha1), 40) != 40 ||
788             write(lock->lock_fd, &term, 1) != 1
789                 || close(lock->lock_fd) < 0) {
790                 error("Couldn't write %s", lock->lk->filename);
791                 unlock_ref(lock);
792                 return -1;
793         }
794         invalidate_cached_refs();
795         if (log_ref_write(lock, sha1, logmsg) < 0) {
796                 unlock_ref(lock);
797                 return -1;
798         }
799         if (commit_lock_file(lock->lk)) {
800                 error("Couldn't set %s", lock->ref_name);
801                 unlock_ref(lock);
802                 return -1;
803         }
804         lock->lock_fd = -1;
805         unlock_ref(lock);
806         return 0;
807 }
808
809 int read_ref_at(const char *ref, unsigned long at_time, int cnt, unsigned char *sha1)
810 {
811         const char *logfile, *logdata, *logend, *rec, *lastgt, *lastrec;
812         char *tz_c;
813         int logfd, tz;
814         struct stat st;
815         unsigned long date;
816         unsigned char logged_sha1[20];
817
818         logfile = git_path("logs/%s", ref);
819         logfd = open(logfile, O_RDONLY, 0);
820         if (logfd < 0)
821                 die("Unable to read log %s: %s", logfile, strerror(errno));
822         fstat(logfd, &st);
823         if (!st.st_size)
824                 die("Log %s is empty.", logfile);
825         logdata = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, logfd, 0);
826         close(logfd);
827
828         lastrec = NULL;
829         rec = logend = logdata + st.st_size;
830         while (logdata < rec) {
831                 if (logdata < rec && *(rec-1) == '\n')
832                         rec--;
833                 lastgt = NULL;
834                 while (logdata < rec && *(rec-1) != '\n') {
835                         rec--;
836                         if (*rec == '>')
837                                 lastgt = rec;
838                 }
839                 if (!lastgt)
840                         die("Log %s is corrupt.", logfile);
841                 date = strtoul(lastgt + 1, &tz_c, 10);
842                 if (date <= at_time || cnt == 0) {
843                         if (lastrec) {
844                                 if (get_sha1_hex(lastrec, logged_sha1))
845                                         die("Log %s is corrupt.", logfile);
846                                 if (get_sha1_hex(rec + 41, sha1))
847                                         die("Log %s is corrupt.", logfile);
848                                 if (hashcmp(logged_sha1, sha1)) {
849                                         tz = strtoul(tz_c, NULL, 10);
850                                         fprintf(stderr,
851                                                 "warning: Log %s has gap after %s.\n",
852                                                 logfile, show_rfc2822_date(date, tz));
853                                 }
854                         }
855                         else if (date == at_time) {
856                                 if (get_sha1_hex(rec + 41, sha1))
857                                         die("Log %s is corrupt.", logfile);
858                         }
859                         else {
860                                 if (get_sha1_hex(rec + 41, logged_sha1))
861                                         die("Log %s is corrupt.", logfile);
862                                 if (hashcmp(logged_sha1, sha1)) {
863                                         tz = strtoul(tz_c, NULL, 10);
864                                         fprintf(stderr,
865                                                 "warning: Log %s unexpectedly ended on %s.\n",
866                                                 logfile, show_rfc2822_date(date, tz));
867                                 }
868                         }
869                         munmap((void*)logdata, st.st_size);
870                         return 0;
871                 }
872                 lastrec = rec;
873                 if (cnt > 0)
874                         cnt--;
875         }
876
877         rec = logdata;
878         while (rec < logend && *rec != '>' && *rec != '\n')
879                 rec++;
880         if (rec == logend || *rec == '\n')
881                 die("Log %s is corrupt.", logfile);
882         date = strtoul(rec + 1, &tz_c, 10);
883         tz = strtoul(tz_c, NULL, 10);
884         if (get_sha1_hex(logdata, sha1))
885                 die("Log %s is corrupt.", logfile);
886         munmap((void*)logdata, st.st_size);
887         fprintf(stderr, "warning: Log %s only goes back to %s.\n",
888                 logfile, show_rfc2822_date(date, tz));
889         return 0;
890 }