Uncomment test case: git branch c/d should barf if branch c exists.
[git/git.git] / refs.c
CommitLineData
95fc7512
DB
1#include "refs.h"
2#include "cache.h"
3
4#include <errno.h>
5
e1e22e37
LT
6struct ref_list {
7 struct ref_list *next;
8da19775 8 unsigned char flag; /* ISSYMREF? ISPACKED? */
e1e22e37
LT
9 unsigned char sha1[20];
10 char name[FLEX_ARRAY];
11};
12
13static 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;
434cd0cd
LT
32 if (isspace(*line))
33 return NULL;
e1e22e37
LT
34 if (line[len] != '\n')
35 return NULL;
36 line[len] = 0;
37 return line;
38}
39
8da19775
JH
40static struct ref_list *add_ref(const char *name, const unsigned char *sha1,
41 int flag, struct ref_list *list)
e1e22e37
LT
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);
8da19775 63 entry->flag = flag;
e1e22e37
LT
64 entry->next = *p;
65 *p = entry;
66 return list;
67}
68
69static struct ref_list *get_packed_refs(void)
70{
71 static int did_refs = 0;
72 static struct ref_list *refs = NULL;
73
74 if (!did_refs) {
75 FILE *f = fopen(git_path("packed-refs"), "r");
76 if (f) {
77 struct ref_list *list = NULL;
78 char refline[PATH_MAX];
79 while (fgets(refline, sizeof(refline), f)) {
80 unsigned char sha1[20];
81 const char *name = parse_ref_line(refline, sha1);
82 if (!name)
83 continue;
8da19775 84 list = add_ref(name, sha1, REF_ISPACKED, list);
e1e22e37
LT
85 }
86 fclose(f);
87 refs = list;
88 }
89 did_refs = 1;
90 }
91 return refs;
92}
93
94static struct ref_list *get_ref_dir(const char *base, struct ref_list *list)
95{
96 DIR *dir = opendir(git_path("%s", base));
97
98 if (dir) {
99 struct dirent *de;
100 int baselen = strlen(base);
ed378ec7 101 char *ref = xmalloc(baselen + 257);
e1e22e37 102
ed378ec7 103 memcpy(ref, base, baselen);
e1e22e37 104 if (baselen && base[baselen-1] != '/')
ed378ec7 105 ref[baselen++] = '/';
e1e22e37
LT
106
107 while ((de = readdir(dir)) != NULL) {
108 unsigned char sha1[20];
109 struct stat st;
8da19775 110 int flag;
e1e22e37
LT
111 int namelen;
112
113 if (de->d_name[0] == '.')
114 continue;
115 namelen = strlen(de->d_name);
116 if (namelen > 255)
117 continue;
118 if (has_extension(de->d_name, ".lock"))
119 continue;
ed378ec7
LT
120 memcpy(ref + baselen, de->d_name, namelen+1);
121 if (stat(git_path("%s", ref), &st) < 0)
e1e22e37
LT
122 continue;
123 if (S_ISDIR(st.st_mode)) {
ed378ec7 124 list = get_ref_dir(ref, list);
e1e22e37
LT
125 continue;
126 }
8da19775 127 if (!resolve_ref(ref, sha1, 1, &flag)) {
ed378ec7 128 error("%s points nowhere!", ref);
e1e22e37
LT
129 continue;
130 }
8da19775 131 list = add_ref(ref, sha1, flag, list);
e1e22e37 132 }
ed378ec7 133 free(ref);
e1e22e37
LT
134 closedir(dir);
135 }
136 return list;
137}
138
139static struct ref_list *get_loose_refs(void)
140{
141 static int did_refs = 0;
142 static struct ref_list *refs = NULL;
143
144 if (!did_refs) {
145 refs = get_ref_dir("refs", NULL);
146 did_refs = 1;
147 }
148 return refs;
149}
150
ca8db142
LT
151/* We allow "recursive" symbolic refs. Only within reason, though */
152#define MAXDEPTH 5
153
8da19775 154const char *resolve_ref(const char *ref, unsigned char *sha1, int reading, int *flag)
8a65ff76 155{
a876ed83
JH
156 int depth = MAXDEPTH, len;
157 char buffer[256];
ed378ec7 158 static char ref_buffer[256];
ca8db142 159
8da19775
JH
160 if (flag)
161 *flag = 0;
162
a876ed83 163 for (;;) {
ed378ec7 164 const char *path = git_path("%s", ref);
a876ed83
JH
165 struct stat st;
166 char *buf;
167 int fd;
8a65ff76 168
a876ed83
JH
169 if (--depth < 0)
170 return NULL;
ca8db142 171
a876ed83
JH
172 /* Special case: non-existing file.
173 * Not having the refs/heads/new-branch is OK
174 * if we are writing into it, so is .git/HEAD
175 * that points at refs/heads/master still to be
176 * born. It is NOT OK if we are resolving for
177 * reading.
178 */
179 if (lstat(path, &st) < 0) {
434cd0cd
LT
180 struct ref_list *list = get_packed_refs();
181 while (list) {
182 if (!strcmp(ref, list->name)) {
183 hashcpy(sha1, list->sha1);
8da19775
JH
184 if (flag)
185 *flag |= REF_ISPACKED;
434cd0cd
LT
186 return ref;
187 }
188 list = list->next;
189 }
a876ed83
JH
190 if (reading || errno != ENOENT)
191 return NULL;
e702496e 192 hashclr(sha1);
ed378ec7 193 return ref;
a876ed83 194 }
ca8db142 195
a876ed83
JH
196 /* Follow "normalized" - ie "refs/.." symlinks by hand */
197 if (S_ISLNK(st.st_mode)) {
198 len = readlink(path, buffer, sizeof(buffer)-1);
199 if (len >= 5 && !memcmp("refs/", buffer, 5)) {
ed378ec7
LT
200 buffer[len] = 0;
201 strcpy(ref_buffer, buffer);
202 ref = ref_buffer;
8da19775
JH
203 if (flag)
204 *flag |= REF_ISSYMREF;
a876ed83
JH
205 continue;
206 }
ca8db142 207 }
a876ed83
JH
208
209 /*
210 * Anything else, just open it and try to use it as
211 * a ref
212 */
213 fd = open(path, O_RDONLY);
214 if (fd < 0)
215 return NULL;
216 len = read(fd, buffer, sizeof(buffer)-1);
217 close(fd);
218
219 /*
220 * Is it a symbolic ref?
221 */
222 if (len < 4 || memcmp("ref:", buffer, 4))
223 break;
224 buf = buffer + 4;
225 len -= 4;
226 while (len && isspace(*buf))
227 buf++, len--;
228 while (len && isspace(buf[len-1]))
ed378ec7
LT
229 len--;
230 buf[len] = 0;
231 memcpy(ref_buffer, buf, len + 1);
232 ref = ref_buffer;
8da19775
JH
233 if (flag)
234 *flag |= REF_ISSYMREF;
8a65ff76 235 }
a876ed83
JH
236 if (len < 40 || get_sha1_hex(buffer, sha1))
237 return NULL;
ed378ec7 238 return ref;
a876ed83
JH
239}
240
ed378ec7 241int create_symref(const char *ref_target, const char *refs_heads_master)
8098a178 242{
8098a178
JH
243 const char *lockpath;
244 char ref[1000];
245 int fd, len, written;
ed378ec7 246 const char *git_HEAD = git_path("%s", ref_target);
8098a178 247
9f0bb90d
JH
248#ifndef NO_SYMLINK_HEAD
249 if (prefer_symlink_refs) {
f8348be3
JS
250 unlink(git_HEAD);
251 if (!symlink(refs_heads_master, git_HEAD))
252 return 0;
253 fprintf(stderr, "no symlink - falling back to symbolic ref\n");
254 }
303958dc
JS
255#endif
256
8098a178
JH
257 len = snprintf(ref, sizeof(ref), "ref: %s\n", refs_heads_master);
258 if (sizeof(ref) <= len) {
259 error("refname too long: %s", refs_heads_master);
260 return -1;
261 }
262 lockpath = mkpath("%s.lock", git_HEAD);
263 fd = open(lockpath, O_CREAT | O_EXCL | O_WRONLY, 0666);
264 written = write(fd, ref, len);
265 close(fd);
266 if (written != len) {
267 unlink(lockpath);
268 error("Unable to write to %s", lockpath);
269 return -2;
270 }
271 if (rename(lockpath, git_HEAD) < 0) {
272 unlink(lockpath);
273 error("Unable to create %s", git_HEAD);
274 return -3;
275 }
138086a7
JH
276 if (adjust_shared_perm(git_HEAD)) {
277 unlink(lockpath);
278 error("Unable to fix permissions on %s", lockpath);
279 return -4;
280 }
8098a178 281 return 0;
8098a178
JH
282}
283
ed378ec7 284int read_ref(const char *ref, unsigned char *sha1)
a876ed83 285{
8da19775 286 if (resolve_ref(ref, sha1, 1, NULL))
a876ed83
JH
287 return 0;
288 return -1;
8a65ff76
LT
289}
290
8da19775
JH
291static int do_for_each_ref(const char *base, each_ref_fn fn, int trim,
292 void *cb_data)
8a65ff76 293{
e1e22e37
LT
294 int retval;
295 struct ref_list *packed = get_packed_refs();
296 struct ref_list *loose = get_loose_refs();
8a65ff76 297
e1e22e37
LT
298 while (packed && loose) {
299 struct ref_list *entry;
300 int cmp = strcmp(packed->name, loose->name);
301 if (!cmp) {
302 packed = packed->next;
303 continue;
6cada6a9 304 }
e1e22e37
LT
305 if (cmp > 0) {
306 entry = loose;
307 loose = loose->next;
308 } else {
309 entry = packed;
310 packed = packed->next;
311 }
312 if (strncmp(base, entry->name, trim))
313 continue;
b37a562a
LT
314 if (is_null_sha1(entry->sha1))
315 continue;
316 if (!has_sha1_file(entry->sha1)) {
317 error("%s does not point to a valid object!", entry->name);
318 continue;
319 }
8da19775
JH
320 retval = fn(entry->name + trim, entry->sha1,
321 entry->flag, cb_data);
e1e22e37
LT
322 if (retval)
323 return retval;
324 }
8a65ff76 325
e1e22e37
LT
326 packed = packed ? packed : loose;
327 while (packed) {
328 if (!strncmp(base, packed->name, trim)) {
8da19775
JH
329 retval = fn(packed->name + trim, packed->sha1,
330 packed->flag, cb_data);
8a65ff76 331 if (retval)
e1e22e37 332 return retval;
8a65ff76 333 }
e1e22e37 334 packed = packed->next;
8a65ff76 335 }
e1e22e37 336 return 0;
8a65ff76
LT
337}
338
cb5d709f 339int head_ref(each_ref_fn fn, void *cb_data)
723c31fe
LT
340{
341 unsigned char sha1[20];
8da19775
JH
342 int flag;
343
344 if (resolve_ref("HEAD", sha1, 1, &flag))
345 return fn("HEAD", sha1, flag, cb_data);
2f34ba32 346 return 0;
723c31fe
LT
347}
348
cb5d709f 349int for_each_ref(each_ref_fn fn, void *cb_data)
8a65ff76 350{
cb5d709f 351 return do_for_each_ref("refs/", fn, 0, cb_data);
a62be77f
SE
352}
353
cb5d709f 354int for_each_tag_ref(each_ref_fn fn, void *cb_data)
a62be77f 355{
cb5d709f 356 return do_for_each_ref("refs/tags/", fn, 10, cb_data);
a62be77f
SE
357}
358
cb5d709f 359int for_each_branch_ref(each_ref_fn fn, void *cb_data)
a62be77f 360{
cb5d709f 361 return do_for_each_ref("refs/heads/", fn, 11, cb_data);
a62be77f
SE
362}
363
cb5d709f 364int for_each_remote_ref(each_ref_fn fn, void *cb_data)
a62be77f 365{
cb5d709f 366 return do_for_each_ref("refs/remotes/", fn, 13, cb_data);
8a65ff76
LT
367}
368
cb5d709f
JH
369/* NEEDSWORK: This is only used by ssh-upload and it should go; the
370 * caller should do resolve_ref or read_ref like everybody else. Or
371 * maybe everybody else should use get_ref_sha1() instead of doing
372 * read_ref().
373 */
95fc7512
DB
374int get_ref_sha1(const char *ref, unsigned char *sha1)
375{
95fc7512
DB
376 if (check_ref_format(ref))
377 return -1;
ed378ec7 378 return read_ref(mkpath("refs/%s", ref), sha1);
95fc7512
DB
379}
380
ac5409e4
JH
381int delete_ref(const char *refname, unsigned char *sha1)
382{
383 struct ref_lock *lock;
384 int err, i, ret = 0;
385
386 lock = lock_any_ref_for_update(refname, sha1);
387 if (!lock)
388 return 1;
389 i = strlen(lock->lk->filename) - 5; /* .lock */
390 lock->lk->filename[i] = 0;
391 err = unlink(lock->lk->filename);
392 if (err) {
393 ret = 1;
394 error("unlink(%s) failed: %s",
395 lock->lk->filename, strerror(errno));
396 }
397 lock->lk->filename[i] = '.';
398
399 err = unlink(lock->log_file);
400 if (err && errno != ENOENT)
401 fprintf(stderr, "warning: unlink(%s) failed: %s",
402 lock->log_file, strerror(errno));
403
404 return ret;
405}
406
03feddd6
JH
407/*
408 * Make sure "ref" is something reasonable to have under ".git/refs/";
409 * We do not like it if:
410 *
411 * - any path component of it begins with ".", or
412 * - it has double dots "..", or
413 * - it has ASCII control character, "~", "^", ":" or SP, anywhere, or
414 * - it ends with a "/".
415 */
416
417static inline int bad_ref_char(int ch)
418{
419 return (((unsigned) ch) <= ' ' ||
68283999
JH
420 ch == '~' || ch == '^' || ch == ':' ||
421 /* 2.13 Pattern Matching Notation */
422 ch == '?' || ch == '*' || ch == '[');
03feddd6
JH
423}
424
95fc7512
DB
425int check_ref_format(const char *ref)
426{
03feddd6
JH
427 int ch, level;
428 const char *cp = ref;
429
430 level = 0;
431 while (1) {
432 while ((ch = *cp++) == '/')
433 ; /* tolerate duplicated slashes */
434 if (!ch)
435 return -1; /* should not end with slashes */
436
437 /* we are at the beginning of the path component */
438 if (ch == '.' || bad_ref_char(ch))
439 return -1;
440
441 /* scan the rest of the path component */
442 while ((ch = *cp++) != 0) {
443 if (bad_ref_char(ch))
444 return -1;
445 if (ch == '/')
446 break;
447 if (ch == '.' && *cp == '.')
448 return -1;
449 }
450 level++;
451 if (!ch) {
452 if (level < 2)
453 return -1; /* at least of form "heads/blah" */
454 return 0;
455 }
456 }
95fc7512
DB
457}
458
e5f38ec3 459static struct ref_lock *verify_lock(struct ref_lock *lock,
4bd18c43
SP
460 const unsigned char *old_sha1, int mustexist)
461{
8da19775 462 if (!resolve_ref(lock->ref_name, lock->old_sha1, mustexist, NULL)) {
434cd0cd 463 error("Can't verify ref %s", lock->ref_name);
4bd18c43
SP
464 unlock_ref(lock);
465 return NULL;
466 }
a89fccd2 467 if (hashcmp(lock->old_sha1, old_sha1)) {
434cd0cd 468 error("Ref %s is at %s but expected %s", lock->ref_name,
4bd18c43
SP
469 sha1_to_hex(lock->old_sha1), sha1_to_hex(old_sha1));
470 unlock_ref(lock);
471 return NULL;
472 }
473 return lock;
474}
475
4431fcc4 476static struct ref_lock *lock_ref_sha1_basic(const char *ref, const unsigned char *old_sha1)
4bd18c43 477{
434cd0cd 478 char *ref_file;
ed378ec7 479 const char *orig_ref = ref;
4bd18c43 480 struct ref_lock *lock;
732232a1 481 struct stat st;
4431fcc4 482 int mustexist = (old_sha1 && !is_null_sha1(old_sha1));
4bd18c43
SP
483
484 lock = xcalloc(1, sizeof(struct ref_lock));
485 lock->lock_fd = -1;
486
8da19775 487 ref = resolve_ref(ref, lock->old_sha1, mustexist, NULL);
ed378ec7 488 if (!ref) {
818f477c
SP
489 int last_errno = errno;
490 error("unable to resolve reference %s: %s",
ed378ec7 491 orig_ref, strerror(errno));
4bd18c43 492 unlock_ref(lock);
818f477c 493 errno = last_errno;
4bd18c43
SP
494 return NULL;
495 }
c33d5174 496 lock->lk = xcalloc(1, sizeof(struct lock_file));
4bd18c43 497
434cd0cd 498 lock->ref_name = xstrdup(ref);
ed378ec7 499 lock->log_file = xstrdup(git_path("logs/%s", ref));
7c1a278d 500 ref_file = git_path("%s", ref);
434cd0cd 501 lock->force_write = lstat(ref_file, &st) && errno == ENOENT;
4bd18c43 502
434cd0cd
LT
503 if (safe_create_leading_directories(ref_file))
504 die("unable to create directory for %s", ref_file);
505 lock->lock_fd = hold_lock_file_for_update(lock->lk, ref_file, 1);
4bd18c43
SP
506
507 return old_sha1 ? verify_lock(lock, old_sha1, mustexist) : lock;
508}
509
4431fcc4 510struct ref_lock *lock_ref_sha1(const char *ref, const unsigned char *old_sha1)
95fc7512 511{
53cce84c 512 char refpath[PATH_MAX];
95fc7512 513 if (check_ref_format(ref))
4bd18c43 514 return NULL;
53cce84c 515 strcpy(refpath, mkpath("refs/%s", ref));
4431fcc4 516 return lock_ref_sha1_basic(refpath, old_sha1);
4bd18c43
SP
517}
518
4431fcc4 519struct ref_lock *lock_any_ref_for_update(const char *ref, const unsigned char *old_sha1)
4bd18c43 520{
4431fcc4 521 return lock_ref_sha1_basic(ref, old_sha1);
4bd18c43
SP
522}
523
e5f38ec3 524void unlock_ref(struct ref_lock *lock)
4bd18c43
SP
525{
526 if (lock->lock_fd >= 0) {
527 close(lock->lock_fd);
c33d5174
JH
528 /* Do not free lock->lk -- atexit() still looks at them */
529 if (lock->lk)
530 rollback_lock_file(lock->lk);
4bd18c43 531 }
434cd0cd 532 free(lock->ref_name);
4cac42b1 533 free(lock->log_file);
4bd18c43
SP
534 free(lock);
535}
536
6de08ae6
SP
537static int log_ref_write(struct ref_lock *lock,
538 const unsigned char *sha1, const char *msg)
539{
540 int logfd, written, oflags = O_APPEND | O_WRONLY;
541 unsigned maxlen, len;
542 char *logrec;
ff4c8485 543 const char *committer;
6de08ae6
SP
544
545 if (log_all_ref_updates) {
546 if (safe_create_leading_directories(lock->log_file) < 0)
547 return error("unable to create directory for %s",
548 lock->log_file);
549 oflags |= O_CREAT;
550 }
551
552 logfd = open(lock->log_file, oflags, 0666);
553 if (logfd < 0) {
554 if (!log_all_ref_updates && errno == ENOENT)
555 return 0;
556 return error("Unable to append to %s: %s",
557 lock->log_file, strerror(errno));
558 }
559
ff4c8485 560 committer = git_committer_info(1);
6de08ae6 561 if (msg) {
ff4c8485 562 maxlen = strlen(committer) + strlen(msg) + 2*40 + 5;
6de08ae6
SP
563 logrec = xmalloc(maxlen);
564 len = snprintf(logrec, maxlen, "%s %s %s\t%s\n",
565 sha1_to_hex(lock->old_sha1),
566 sha1_to_hex(sha1),
ff4c8485 567 committer,
6de08ae6 568 msg);
e5f38ec3
JH
569 }
570 else {
ff4c8485 571 maxlen = strlen(committer) + 2*40 + 4;
6de08ae6
SP
572 logrec = xmalloc(maxlen);
573 len = snprintf(logrec, maxlen, "%s %s %s\n",
574 sha1_to_hex(lock->old_sha1),
575 sha1_to_hex(sha1),
ff4c8485 576 committer);
6de08ae6
SP
577 }
578 written = len <= maxlen ? write(logfd, logrec, len) : -1;
579 free(logrec);
580 close(logfd);
581 if (written != len)
582 return error("Unable to append to %s", lock->log_file);
583 return 0;
584}
585
4bd18c43
SP
586int write_ref_sha1(struct ref_lock *lock,
587 const unsigned char *sha1, const char *logmsg)
588{
589 static char term = '\n';
590
591 if (!lock)
95fc7512 592 return -1;
a89fccd2 593 if (!lock->force_write && !hashcmp(lock->old_sha1, sha1)) {
4bd18c43
SP
594 unlock_ref(lock);
595 return 0;
95fc7512 596 }
4bd18c43
SP
597 if (write(lock->lock_fd, sha1_to_hex(sha1), 40) != 40 ||
598 write(lock->lock_fd, &term, 1) != 1
599 || close(lock->lock_fd) < 0) {
c33d5174 600 error("Couldn't write %s", lock->lk->filename);
4bd18c43
SP
601 unlock_ref(lock);
602 return -1;
603 }
6de08ae6
SP
604 if (log_ref_write(lock, sha1, logmsg) < 0) {
605 unlock_ref(lock);
606 return -1;
607 }
c33d5174 608 if (commit_lock_file(lock->lk)) {
434cd0cd 609 error("Couldn't set %s", lock->ref_name);
4bd18c43
SP
610 unlock_ref(lock);
611 return -1;
612 }
613 lock->lock_fd = -1;
614 unlock_ref(lock);
615 return 0;
95fc7512 616}
d556fae2
SP
617
618int read_ref_at(const char *ref, unsigned long at_time, unsigned char *sha1)
619{
e5229042 620 const char *logfile, *logdata, *logend, *rec, *lastgt, *lastrec;
d556fae2
SP
621 char *tz_c;
622 int logfd, tz;
623 struct stat st;
624 unsigned long date;
e5229042 625 unsigned char logged_sha1[20];
d556fae2
SP
626
627 logfile = git_path("logs/%s", ref);
628 logfd = open(logfile, O_RDONLY, 0);
629 if (logfd < 0)
630 die("Unable to read log %s: %s", logfile, strerror(errno));
631 fstat(logfd, &st);
632 if (!st.st_size)
633 die("Log %s is empty.", logfile);
634 logdata = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, logfd, 0);
635 close(logfd);
636
e5229042 637 lastrec = NULL;
d556fae2
SP
638 rec = logend = logdata + st.st_size;
639 while (logdata < rec) {
640 if (logdata < rec && *(rec-1) == '\n')
641 rec--;
e5229042
SP
642 lastgt = NULL;
643 while (logdata < rec && *(rec-1) != '\n') {
d556fae2 644 rec--;
e5229042
SP
645 if (*rec == '>')
646 lastgt = rec;
647 }
648 if (!lastgt)
d556fae2 649 die("Log %s is corrupt.", logfile);
e5229042 650 date = strtoul(lastgt + 1, &tz_c, 10);
d556fae2 651 if (date <= at_time) {
e5229042
SP
652 if (lastrec) {
653 if (get_sha1_hex(lastrec, logged_sha1))
654 die("Log %s is corrupt.", logfile);
655 if (get_sha1_hex(rec + 41, sha1))
656 die("Log %s is corrupt.", logfile);
a89fccd2 657 if (hashcmp(logged_sha1, sha1)) {
e5229042
SP
658 tz = strtoul(tz_c, NULL, 10);
659 fprintf(stderr,
660 "warning: Log %s has gap after %s.\n",
661 logfile, show_rfc2822_date(date, tz));
662 }
e5f38ec3
JH
663 }
664 else if (date == at_time) {
e5229042
SP
665 if (get_sha1_hex(rec + 41, sha1))
666 die("Log %s is corrupt.", logfile);
e5f38ec3
JH
667 }
668 else {
e5229042
SP
669 if (get_sha1_hex(rec + 41, logged_sha1))
670 die("Log %s is corrupt.", logfile);
a89fccd2 671 if (hashcmp(logged_sha1, sha1)) {
e5229042
SP
672 tz = strtoul(tz_c, NULL, 10);
673 fprintf(stderr,
674 "warning: Log %s unexpectedly ended on %s.\n",
675 logfile, show_rfc2822_date(date, tz));
676 }
677 }
d556fae2
SP
678 munmap((void*)logdata, st.st_size);
679 return 0;
680 }
e5229042 681 lastrec = rec;
d556fae2
SP
682 }
683
e5229042
SP
684 rec = logdata;
685 while (rec < logend && *rec != '>' && *rec != '\n')
686 rec++;
687 if (rec == logend || *rec == '\n')
d556fae2 688 die("Log %s is corrupt.", logfile);
e5229042 689 date = strtoul(rec + 1, &tz_c, 10);
d556fae2
SP
690 tz = strtoul(tz_c, NULL, 10);
691 if (get_sha1_hex(logdata, sha1))
692 die("Log %s is corrupt.", logfile);
693 munmap((void*)logdata, st.st_size);
694 fprintf(stderr, "warning: Log %s only goes back to %s.\n",
695 logfile, show_rfc2822_date(date, tz));
696 return 0;
697}