Merge branch 'jc/doc-gc-prune-now'
[git] / fsck.c
1 #include "cache.h"
2 #include "object.h"
3 #include "blob.h"
4 #include "tree.h"
5 #include "tree-walk.h"
6 #include "commit.h"
7 #include "tag.h"
8 #include "fsck.h"
9 #include "refs.h"
10 #include "utf8.h"
11 #include "sha1-array.h"
12
13 #define FSCK_FATAL -1
14 #define FSCK_INFO -2
15
16 #define FOREACH_MSG_ID(FUNC) \
17         /* fatal errors */ \
18         FUNC(NUL_IN_HEADER, FATAL) \
19         FUNC(UNTERMINATED_HEADER, FATAL) \
20         /* errors */ \
21         FUNC(BAD_DATE, ERROR) \
22         FUNC(BAD_DATE_OVERFLOW, ERROR) \
23         FUNC(BAD_EMAIL, ERROR) \
24         FUNC(BAD_NAME, ERROR) \
25         FUNC(BAD_OBJECT_SHA1, ERROR) \
26         FUNC(BAD_PARENT_SHA1, ERROR) \
27         FUNC(BAD_TAG_OBJECT, ERROR) \
28         FUNC(BAD_TIMEZONE, ERROR) \
29         FUNC(BAD_TREE, ERROR) \
30         FUNC(BAD_TREE_SHA1, ERROR) \
31         FUNC(BAD_TYPE, ERROR) \
32         FUNC(DUPLICATE_ENTRIES, ERROR) \
33         FUNC(MISSING_AUTHOR, ERROR) \
34         FUNC(MISSING_COMMITTER, ERROR) \
35         FUNC(MISSING_EMAIL, ERROR) \
36         FUNC(MISSING_GRAFT, ERROR) \
37         FUNC(MISSING_NAME_BEFORE_EMAIL, ERROR) \
38         FUNC(MISSING_OBJECT, ERROR) \
39         FUNC(MISSING_PARENT, ERROR) \
40         FUNC(MISSING_SPACE_BEFORE_DATE, ERROR) \
41         FUNC(MISSING_SPACE_BEFORE_EMAIL, ERROR) \
42         FUNC(MISSING_TAG, ERROR) \
43         FUNC(MISSING_TAG_ENTRY, ERROR) \
44         FUNC(MISSING_TAG_OBJECT, ERROR) \
45         FUNC(MISSING_TREE, ERROR) \
46         FUNC(MISSING_TYPE, ERROR) \
47         FUNC(MISSING_TYPE_ENTRY, ERROR) \
48         FUNC(MULTIPLE_AUTHORS, ERROR) \
49         FUNC(TAG_OBJECT_NOT_TAG, ERROR) \
50         FUNC(TREE_NOT_SORTED, ERROR) \
51         FUNC(UNKNOWN_TYPE, ERROR) \
52         FUNC(ZERO_PADDED_DATE, ERROR) \
53         /* warnings */ \
54         FUNC(BAD_FILEMODE, WARN) \
55         FUNC(EMPTY_NAME, WARN) \
56         FUNC(FULL_PATHNAME, WARN) \
57         FUNC(HAS_DOT, WARN) \
58         FUNC(HAS_DOTDOT, WARN) \
59         FUNC(HAS_DOTGIT, WARN) \
60         FUNC(NULL_SHA1, WARN) \
61         FUNC(ZERO_PADDED_FILEMODE, WARN) \
62         /* infos (reported as warnings, but ignored by default) */ \
63         FUNC(BAD_TAG_NAME, INFO) \
64         FUNC(MISSING_TAGGER_ENTRY, INFO)
65
66 #define MSG_ID(id, msg_type) FSCK_MSG_##id,
67 enum fsck_msg_id {
68         FOREACH_MSG_ID(MSG_ID)
69         FSCK_MSG_MAX
70 };
71 #undef MSG_ID
72
73 #define STR(x) #x
74 #define MSG_ID(id, msg_type) { STR(id), NULL, FSCK_##msg_type },
75 static struct {
76         const char *id_string;
77         const char *downcased;
78         int msg_type;
79 } msg_id_info[FSCK_MSG_MAX + 1] = {
80         FOREACH_MSG_ID(MSG_ID)
81         { NULL, NULL, -1 }
82 };
83 #undef MSG_ID
84
85 static int parse_msg_id(const char *text)
86 {
87         int i;
88
89         if (!msg_id_info[0].downcased) {
90                 /* convert id_string to lower case, without underscores. */
91                 for (i = 0; i < FSCK_MSG_MAX; i++) {
92                         const char *p = msg_id_info[i].id_string;
93                         int len = strlen(p);
94                         char *q = xmalloc(len);
95
96                         msg_id_info[i].downcased = q;
97                         while (*p)
98                                 if (*p == '_')
99                                         p++;
100                                 else
101                                         *(q)++ = tolower(*(p)++);
102                         *q = '\0';
103                 }
104         }
105
106         for (i = 0; i < FSCK_MSG_MAX; i++)
107                 if (!strcmp(text, msg_id_info[i].downcased))
108                         return i;
109
110         return -1;
111 }
112
113 static int fsck_msg_type(enum fsck_msg_id msg_id,
114         struct fsck_options *options)
115 {
116         int msg_type;
117
118         assert(msg_id >= 0 && msg_id < FSCK_MSG_MAX);
119
120         if (options->msg_type)
121                 msg_type = options->msg_type[msg_id];
122         else {
123                 msg_type = msg_id_info[msg_id].msg_type;
124                 if (options->strict && msg_type == FSCK_WARN)
125                         msg_type = FSCK_ERROR;
126         }
127
128         return msg_type;
129 }
130
131 static void init_skiplist(struct fsck_options *options, const char *path)
132 {
133         static struct sha1_array skiplist = SHA1_ARRAY_INIT;
134         int sorted, fd;
135         char buffer[41];
136         unsigned char sha1[20];
137
138         if (options->skiplist)
139                 sorted = options->skiplist->sorted;
140         else {
141                 sorted = 1;
142                 options->skiplist = &skiplist;
143         }
144
145         fd = open(path, O_RDONLY);
146         if (fd < 0)
147                 die("Could not open skip list: %s", path);
148         for (;;) {
149                 int result = read_in_full(fd, buffer, sizeof(buffer));
150                 if (result < 0)
151                         die_errno("Could not read '%s'", path);
152                 if (!result)
153                         break;
154                 if (get_sha1_hex(buffer, sha1) || buffer[40] != '\n')
155                         die("Invalid SHA-1: %s", buffer);
156                 sha1_array_append(&skiplist, sha1);
157                 if (sorted && skiplist.nr > 1 &&
158                                 hashcmp(skiplist.sha1[skiplist.nr - 2],
159                                         sha1) > 0)
160                         sorted = 0;
161         }
162         close(fd);
163
164         if (sorted)
165                 skiplist.sorted = 1;
166 }
167
168 static int parse_msg_type(const char *str)
169 {
170         if (!strcmp(str, "error"))
171                 return FSCK_ERROR;
172         else if (!strcmp(str, "warn"))
173                 return FSCK_WARN;
174         else if (!strcmp(str, "ignore"))
175                 return FSCK_IGNORE;
176         else
177                 die("Unknown fsck message type: '%s'", str);
178 }
179
180 int is_valid_msg_type(const char *msg_id, const char *msg_type)
181 {
182         if (parse_msg_id(msg_id) < 0)
183                 return 0;
184         parse_msg_type(msg_type);
185         return 1;
186 }
187
188 void fsck_set_msg_type(struct fsck_options *options,
189                 const char *msg_id, const char *msg_type)
190 {
191         int id = parse_msg_id(msg_id), type;
192
193         if (id < 0)
194                 die("Unhandled message id: %s", msg_id);
195         type = parse_msg_type(msg_type);
196
197         if (type != FSCK_ERROR && msg_id_info[id].msg_type == FSCK_FATAL)
198                 die("Cannot demote %s to %s", msg_id, msg_type);
199
200         if (!options->msg_type) {
201                 int i;
202                 int *msg_type = xmalloc(sizeof(int) * FSCK_MSG_MAX);
203                 for (i = 0; i < FSCK_MSG_MAX; i++)
204                         msg_type[i] = fsck_msg_type(i, options);
205                 options->msg_type = msg_type;
206         }
207
208         options->msg_type[id] = type;
209 }
210
211 void fsck_set_msg_types(struct fsck_options *options, const char *values)
212 {
213         char *buf = xstrdup(values), *to_free = buf;
214         int done = 0;
215
216         while (!done) {
217                 int len = strcspn(buf, " ,|"), equal;
218
219                 done = !buf[len];
220                 if (!len) {
221                         buf++;
222                         continue;
223                 }
224                 buf[len] = '\0';
225
226                 for (equal = 0;
227                      equal < len && buf[equal] != '=' && buf[equal] != ':';
228                      equal++)
229                         buf[equal] = tolower(buf[equal]);
230                 buf[equal] = '\0';
231
232                 if (!strcmp(buf, "skiplist")) {
233                         if (equal == len)
234                                 die("skiplist requires a path");
235                         init_skiplist(options, buf + equal + 1);
236                         buf += len + 1;
237                         continue;
238                 }
239
240                 if (equal == len)
241                         die("Missing '=': '%s'", buf);
242
243                 fsck_set_msg_type(options, buf, buf + equal + 1);
244                 buf += len + 1;
245         }
246         free(to_free);
247 }
248
249 static void append_msg_id(struct strbuf *sb, const char *msg_id)
250 {
251         for (;;) {
252                 char c = *(msg_id)++;
253
254                 if (!c)
255                         break;
256                 if (c != '_')
257                         strbuf_addch(sb, tolower(c));
258                 else {
259                         assert(*msg_id);
260                         strbuf_addch(sb, *(msg_id)++);
261                 }
262         }
263
264         strbuf_addstr(sb, ": ");
265 }
266
267 __attribute__((format (printf, 4, 5)))
268 static int report(struct fsck_options *options, struct object *object,
269         enum fsck_msg_id id, const char *fmt, ...)
270 {
271         va_list ap;
272         struct strbuf sb = STRBUF_INIT;
273         int msg_type = fsck_msg_type(id, options), result;
274
275         if (msg_type == FSCK_IGNORE)
276                 return 0;
277
278         if (options->skiplist && object &&
279                         sha1_array_lookup(options->skiplist, object->sha1) >= 0)
280                 return 0;
281
282         if (msg_type == FSCK_FATAL)
283                 msg_type = FSCK_ERROR;
284         else if (msg_type == FSCK_INFO)
285                 msg_type = FSCK_WARN;
286
287         append_msg_id(&sb, msg_id_info[id].id_string);
288
289         va_start(ap, fmt);
290         strbuf_vaddf(&sb, fmt, ap);
291         result = options->error_func(object, msg_type, sb.buf);
292         strbuf_release(&sb);
293         va_end(ap);
294
295         return result;
296 }
297
298 static int fsck_walk_tree(struct tree *tree, void *data, struct fsck_options *options)
299 {
300         struct tree_desc desc;
301         struct name_entry entry;
302         int res = 0;
303
304         if (parse_tree(tree))
305                 return -1;
306
307         init_tree_desc(&desc, tree->buffer, tree->size);
308         while (tree_entry(&desc, &entry)) {
309                 int result;
310
311                 if (S_ISGITLINK(entry.mode))
312                         continue;
313                 if (S_ISDIR(entry.mode))
314                         result = options->walk(&lookup_tree(entry.sha1)->object, OBJ_TREE, data, options);
315                 else if (S_ISREG(entry.mode) || S_ISLNK(entry.mode))
316                         result = options->walk(&lookup_blob(entry.sha1)->object, OBJ_BLOB, data, options);
317                 else {
318                         result = error("in tree %s: entry %s has bad mode %.6o",
319                                         sha1_to_hex(tree->object.sha1), entry.path, entry.mode);
320                 }
321                 if (result < 0)
322                         return result;
323                 if (!res)
324                         res = result;
325         }
326         return res;
327 }
328
329 static int fsck_walk_commit(struct commit *commit, void *data, struct fsck_options *options)
330 {
331         struct commit_list *parents;
332         int res;
333         int result;
334
335         if (parse_commit(commit))
336                 return -1;
337
338         result = options->walk((struct object *)commit->tree, OBJ_TREE, data, options);
339         if (result < 0)
340                 return result;
341         res = result;
342
343         parents = commit->parents;
344         while (parents) {
345                 result = options->walk((struct object *)parents->item, OBJ_COMMIT, data, options);
346                 if (result < 0)
347                         return result;
348                 if (!res)
349                         res = result;
350                 parents = parents->next;
351         }
352         return res;
353 }
354
355 static int fsck_walk_tag(struct tag *tag, void *data, struct fsck_options *options)
356 {
357         if (parse_tag(tag))
358                 return -1;
359         return options->walk(tag->tagged, OBJ_ANY, data, options);
360 }
361
362 int fsck_walk(struct object *obj, void *data, struct fsck_options *options)
363 {
364         if (!obj)
365                 return -1;
366         switch (obj->type) {
367         case OBJ_BLOB:
368                 return 0;
369         case OBJ_TREE:
370                 return fsck_walk_tree((struct tree *)obj, data, options);
371         case OBJ_COMMIT:
372                 return fsck_walk_commit((struct commit *)obj, data, options);
373         case OBJ_TAG:
374                 return fsck_walk_tag((struct tag *)obj, data, options);
375         default:
376                 error("Unknown object type for %s", sha1_to_hex(obj->sha1));
377                 return -1;
378         }
379 }
380
381 /*
382  * The entries in a tree are ordered in the _path_ order,
383  * which means that a directory entry is ordered by adding
384  * a slash to the end of it.
385  *
386  * So a directory called "a" is ordered _after_ a file
387  * called "a.c", because "a/" sorts after "a.c".
388  */
389 #define TREE_UNORDERED (-1)
390 #define TREE_HAS_DUPS  (-2)
391
392 static int verify_ordered(unsigned mode1, const char *name1, unsigned mode2, const char *name2)
393 {
394         int len1 = strlen(name1);
395         int len2 = strlen(name2);
396         int len = len1 < len2 ? len1 : len2;
397         unsigned char c1, c2;
398         int cmp;
399
400         cmp = memcmp(name1, name2, len);
401         if (cmp < 0)
402                 return 0;
403         if (cmp > 0)
404                 return TREE_UNORDERED;
405
406         /*
407          * Ok, the first <len> characters are the same.
408          * Now we need to order the next one, but turn
409          * a '\0' into a '/' for a directory entry.
410          */
411         c1 = name1[len];
412         c2 = name2[len];
413         if (!c1 && !c2)
414                 /*
415                  * git-write-tree used to write out a nonsense tree that has
416                  * entries with the same name, one blob and one tree.  Make
417                  * sure we do not have duplicate entries.
418                  */
419                 return TREE_HAS_DUPS;
420         if (!c1 && S_ISDIR(mode1))
421                 c1 = '/';
422         if (!c2 && S_ISDIR(mode2))
423                 c2 = '/';
424         return c1 < c2 ? 0 : TREE_UNORDERED;
425 }
426
427 static int fsck_tree(struct tree *item, struct fsck_options *options)
428 {
429         int retval;
430         int has_null_sha1 = 0;
431         int has_full_path = 0;
432         int has_empty_name = 0;
433         int has_dot = 0;
434         int has_dotdot = 0;
435         int has_dotgit = 0;
436         int has_zero_pad = 0;
437         int has_bad_modes = 0;
438         int has_dup_entries = 0;
439         int not_properly_sorted = 0;
440         struct tree_desc desc;
441         unsigned o_mode;
442         const char *o_name;
443
444         init_tree_desc(&desc, item->buffer, item->size);
445
446         o_mode = 0;
447         o_name = NULL;
448
449         while (desc.size) {
450                 unsigned mode;
451                 const char *name;
452                 const unsigned char *sha1;
453
454                 sha1 = tree_entry_extract(&desc, &name, &mode);
455
456                 has_null_sha1 |= is_null_sha1(sha1);
457                 has_full_path |= !!strchr(name, '/');
458                 has_empty_name |= !*name;
459                 has_dot |= !strcmp(name, ".");
460                 has_dotdot |= !strcmp(name, "..");
461                 has_dotgit |= (!strcmp(name, ".git") ||
462                                is_hfs_dotgit(name) ||
463                                is_ntfs_dotgit(name));
464                 has_zero_pad |= *(char *)desc.buffer == '0';
465                 update_tree_entry(&desc);
466
467                 switch (mode) {
468                 /*
469                  * Standard modes..
470                  */
471                 case S_IFREG | 0755:
472                 case S_IFREG | 0644:
473                 case S_IFLNK:
474                 case S_IFDIR:
475                 case S_IFGITLINK:
476                         break;
477                 /*
478                  * This is nonstandard, but we had a few of these
479                  * early on when we honored the full set of mode
480                  * bits..
481                  */
482                 case S_IFREG | 0664:
483                         if (!options->strict)
484                                 break;
485                 default:
486                         has_bad_modes = 1;
487                 }
488
489                 if (o_name) {
490                         switch (verify_ordered(o_mode, o_name, mode, name)) {
491                         case TREE_UNORDERED:
492                                 not_properly_sorted = 1;
493                                 break;
494                         case TREE_HAS_DUPS:
495                                 has_dup_entries = 1;
496                                 break;
497                         default:
498                                 break;
499                         }
500                 }
501
502                 o_mode = mode;
503                 o_name = name;
504         }
505
506         retval = 0;
507         if (has_null_sha1)
508                 retval += report(options, &item->object, FSCK_MSG_NULL_SHA1, "contains entries pointing to null sha1");
509         if (has_full_path)
510                 retval += report(options, &item->object, FSCK_MSG_FULL_PATHNAME, "contains full pathnames");
511         if (has_empty_name)
512                 retval += report(options, &item->object, FSCK_MSG_EMPTY_NAME, "contains empty pathname");
513         if (has_dot)
514                 retval += report(options, &item->object, FSCK_MSG_HAS_DOT, "contains '.'");
515         if (has_dotdot)
516                 retval += report(options, &item->object, FSCK_MSG_HAS_DOTDOT, "contains '..'");
517         if (has_dotgit)
518                 retval += report(options, &item->object, FSCK_MSG_HAS_DOTGIT, "contains '.git'");
519         if (has_zero_pad)
520                 retval += report(options, &item->object, FSCK_MSG_ZERO_PADDED_FILEMODE, "contains zero-padded file modes");
521         if (has_bad_modes)
522                 retval += report(options, &item->object, FSCK_MSG_BAD_FILEMODE, "contains bad file modes");
523         if (has_dup_entries)
524                 retval += report(options, &item->object, FSCK_MSG_DUPLICATE_ENTRIES, "contains duplicate file entries");
525         if (not_properly_sorted)
526                 retval += report(options, &item->object, FSCK_MSG_TREE_NOT_SORTED, "not properly sorted");
527         return retval;
528 }
529
530 static int verify_headers(const void *data, unsigned long size,
531                           struct object *obj, struct fsck_options *options)
532 {
533         const char *buffer = (const char *)data;
534         unsigned long i;
535
536         for (i = 0; i < size; i++) {
537                 switch (buffer[i]) {
538                 case '\0':
539                         return report(options, obj,
540                                 FSCK_MSG_NUL_IN_HEADER,
541                                 "unterminated header: NUL at offset %ld", i);
542                 case '\n':
543                         if (i + 1 < size && buffer[i + 1] == '\n')
544                                 return 0;
545                 }
546         }
547
548         /*
549          * We did not find double-LF that separates the header
550          * and the body.  Not having a body is not a crime but
551          * we do want to see the terminating LF for the last header
552          * line.
553          */
554         if (size && buffer[size - 1] == '\n')
555                 return 0;
556
557         return report(options, obj,
558                 FSCK_MSG_UNTERMINATED_HEADER, "unterminated header");
559 }
560
561 static int fsck_ident(const char **ident, struct object *obj, struct fsck_options *options)
562 {
563         const char *p = *ident;
564         char *end;
565
566         *ident = strchrnul(*ident, '\n');
567         if (**ident == '\n')
568                 (*ident)++;
569
570         if (*p == '<')
571                 return report(options, obj, FSCK_MSG_MISSING_NAME_BEFORE_EMAIL, "invalid author/committer line - missing space before email");
572         p += strcspn(p, "<>\n");
573         if (*p == '>')
574                 return report(options, obj, FSCK_MSG_BAD_NAME, "invalid author/committer line - bad name");
575         if (*p != '<')
576                 return report(options, obj, FSCK_MSG_MISSING_EMAIL, "invalid author/committer line - missing email");
577         if (p[-1] != ' ')
578                 return report(options, obj, FSCK_MSG_MISSING_SPACE_BEFORE_EMAIL, "invalid author/committer line - missing space before email");
579         p++;
580         p += strcspn(p, "<>\n");
581         if (*p != '>')
582                 return report(options, obj, FSCK_MSG_BAD_EMAIL, "invalid author/committer line - bad email");
583         p++;
584         if (*p != ' ')
585                 return report(options, obj, FSCK_MSG_MISSING_SPACE_BEFORE_DATE, "invalid author/committer line - missing space before date");
586         p++;
587         if (*p == '0' && p[1] != ' ')
588                 return report(options, obj, FSCK_MSG_ZERO_PADDED_DATE, "invalid author/committer line - zero-padded date");
589         if (date_overflows(strtoul(p, &end, 10)))
590                 return report(options, obj, FSCK_MSG_BAD_DATE_OVERFLOW, "invalid author/committer line - date causes integer overflow");
591         if ((end == p || *end != ' '))
592                 return report(options, obj, FSCK_MSG_BAD_DATE, "invalid author/committer line - bad date");
593         p = end + 1;
594         if ((*p != '+' && *p != '-') ||
595             !isdigit(p[1]) ||
596             !isdigit(p[2]) ||
597             !isdigit(p[3]) ||
598             !isdigit(p[4]) ||
599             (p[5] != '\n'))
600                 return report(options, obj, FSCK_MSG_BAD_TIMEZONE, "invalid author/committer line - bad time zone");
601         p += 6;
602         return 0;
603 }
604
605 static int fsck_commit_buffer(struct commit *commit, const char *buffer,
606         unsigned long size, struct fsck_options *options)
607 {
608         unsigned char tree_sha1[20], sha1[20];
609         struct commit_graft *graft;
610         unsigned parent_count, parent_line_count = 0, author_count;
611         int err;
612
613         if (verify_headers(buffer, size, &commit->object, options))
614                 return -1;
615
616         if (!skip_prefix(buffer, "tree ", &buffer))
617                 return report(options, &commit->object, FSCK_MSG_MISSING_TREE, "invalid format - expected 'tree' line");
618         if (get_sha1_hex(buffer, tree_sha1) || buffer[40] != '\n') {
619                 err = report(options, &commit->object, FSCK_MSG_BAD_TREE_SHA1, "invalid 'tree' line format - bad sha1");
620                 if (err)
621                         return err;
622         }
623         buffer += 41;
624         while (skip_prefix(buffer, "parent ", &buffer)) {
625                 if (get_sha1_hex(buffer, sha1) || buffer[40] != '\n') {
626                         err = report(options, &commit->object, FSCK_MSG_BAD_PARENT_SHA1, "invalid 'parent' line format - bad sha1");
627                         if (err)
628                                 return err;
629                 }
630                 buffer += 41;
631                 parent_line_count++;
632         }
633         graft = lookup_commit_graft(commit->object.sha1);
634         parent_count = commit_list_count(commit->parents);
635         if (graft) {
636                 if (graft->nr_parent == -1 && !parent_count)
637                         ; /* shallow commit */
638                 else if (graft->nr_parent != parent_count) {
639                         err = report(options, &commit->object, FSCK_MSG_MISSING_GRAFT, "graft objects missing");
640                         if (err)
641                                 return err;
642                 }
643         } else {
644                 if (parent_count != parent_line_count) {
645                         err = report(options, &commit->object, FSCK_MSG_MISSING_PARENT, "parent objects missing");
646                         if (err)
647                                 return err;
648                 }
649         }
650         author_count = 0;
651         while (skip_prefix(buffer, "author ", &buffer)) {
652                 author_count++;
653                 err = fsck_ident(&buffer, &commit->object, options);
654                 if (err)
655                         return err;
656         }
657         if (author_count < 1)
658                 err = report(options, &commit->object, FSCK_MSG_MISSING_AUTHOR, "invalid format - expected 'author' line");
659         else if (author_count > 1)
660                 err = report(options, &commit->object, FSCK_MSG_MULTIPLE_AUTHORS, "invalid format - multiple 'author' lines");
661         if (err)
662                 return err;
663         if (!skip_prefix(buffer, "committer ", &buffer))
664                 return report(options, &commit->object, FSCK_MSG_MISSING_COMMITTER, "invalid format - expected 'committer' line");
665         err = fsck_ident(&buffer, &commit->object, options);
666         if (err)
667                 return err;
668         if (!commit->tree)
669                 return report(options, &commit->object, FSCK_MSG_BAD_TREE, "could not load commit's tree %s", sha1_to_hex(tree_sha1));
670
671         return 0;
672 }
673
674 static int fsck_commit(struct commit *commit, const char *data,
675         unsigned long size, struct fsck_options *options)
676 {
677         const char *buffer = data ?  data : get_commit_buffer(commit, &size);
678         int ret = fsck_commit_buffer(commit, buffer, size, options);
679         if (!data)
680                 unuse_commit_buffer(commit, buffer);
681         return ret;
682 }
683
684 static int fsck_tag_buffer(struct tag *tag, const char *data,
685         unsigned long size, struct fsck_options *options)
686 {
687         unsigned char sha1[20];
688         int ret = 0;
689         const char *buffer;
690         char *to_free = NULL, *eol;
691         struct strbuf sb = STRBUF_INIT;
692
693         if (data)
694                 buffer = data;
695         else {
696                 enum object_type type;
697
698                 buffer = to_free =
699                         read_sha1_file(tag->object.sha1, &type, &size);
700                 if (!buffer)
701                         return report(options, &tag->object,
702                                 FSCK_MSG_MISSING_TAG_OBJECT,
703                                 "cannot read tag object");
704
705                 if (type != OBJ_TAG) {
706                         ret = report(options, &tag->object,
707                                 FSCK_MSG_TAG_OBJECT_NOT_TAG,
708                                 "expected tag got %s",
709                             typename(type));
710                         goto done;
711                 }
712         }
713
714         if (verify_headers(buffer, size, &tag->object, options))
715                 goto done;
716
717         if (!skip_prefix(buffer, "object ", &buffer)) {
718                 ret = report(options, &tag->object, FSCK_MSG_MISSING_OBJECT, "invalid format - expected 'object' line");
719                 goto done;
720         }
721         if (get_sha1_hex(buffer, sha1) || buffer[40] != '\n') {
722                 ret = report(options, &tag->object, FSCK_MSG_BAD_OBJECT_SHA1, "invalid 'object' line format - bad sha1");
723                 if (ret)
724                         goto done;
725         }
726         buffer += 41;
727
728         if (!skip_prefix(buffer, "type ", &buffer)) {
729                 ret = report(options, &tag->object, FSCK_MSG_MISSING_TYPE_ENTRY, "invalid format - expected 'type' line");
730                 goto done;
731         }
732         eol = strchr(buffer, '\n');
733         if (!eol) {
734                 ret = report(options, &tag->object, FSCK_MSG_MISSING_TYPE, "invalid format - unexpected end after 'type' line");
735                 goto done;
736         }
737         if (type_from_string_gently(buffer, eol - buffer, 1) < 0)
738                 ret = report(options, &tag->object, FSCK_MSG_BAD_TYPE, "invalid 'type' value");
739         if (ret)
740                 goto done;
741         buffer = eol + 1;
742
743         if (!skip_prefix(buffer, "tag ", &buffer)) {
744                 ret = report(options, &tag->object, FSCK_MSG_MISSING_TAG_ENTRY, "invalid format - expected 'tag' line");
745                 goto done;
746         }
747         eol = strchr(buffer, '\n');
748         if (!eol) {
749                 ret = report(options, &tag->object, FSCK_MSG_MISSING_TAG, "invalid format - unexpected end after 'type' line");
750                 goto done;
751         }
752         strbuf_addf(&sb, "refs/tags/%.*s", (int)(eol - buffer), buffer);
753         if (check_refname_format(sb.buf, 0)) {
754                 ret = report(options, &tag->object, FSCK_MSG_BAD_TAG_NAME,
755                            "invalid 'tag' name: %.*s",
756                            (int)(eol - buffer), buffer);
757                 if (ret)
758                         goto done;
759         }
760         buffer = eol + 1;
761
762         if (!skip_prefix(buffer, "tagger ", &buffer)) {
763                 /* early tags do not contain 'tagger' lines; warn only */
764                 ret = report(options, &tag->object, FSCK_MSG_MISSING_TAGGER_ENTRY, "invalid format - expected 'tagger' line");
765                 if (ret)
766                         goto done;
767         }
768         else
769                 ret = fsck_ident(&buffer, &tag->object, options);
770
771 done:
772         strbuf_release(&sb);
773         free(to_free);
774         return ret;
775 }
776
777 static int fsck_tag(struct tag *tag, const char *data,
778         unsigned long size, struct fsck_options *options)
779 {
780         struct object *tagged = tag->tagged;
781
782         if (!tagged)
783                 return report(options, &tag->object, FSCK_MSG_BAD_TAG_OBJECT, "could not load tagged object");
784
785         return fsck_tag_buffer(tag, data, size, options);
786 }
787
788 int fsck_object(struct object *obj, void *data, unsigned long size,
789         struct fsck_options *options)
790 {
791         if (!obj)
792                 return report(options, obj, FSCK_MSG_BAD_OBJECT_SHA1, "no valid object to fsck");
793
794         if (obj->type == OBJ_BLOB)
795                 return 0;
796         if (obj->type == OBJ_TREE)
797                 return fsck_tree((struct tree *) obj, options);
798         if (obj->type == OBJ_COMMIT)
799                 return fsck_commit((struct commit *) obj, (const char *) data,
800                         size, options);
801         if (obj->type == OBJ_TAG)
802                 return fsck_tag((struct tag *) obj, (const char *) data,
803                         size, options);
804
805         return report(options, obj, FSCK_MSG_UNKNOWN_TYPE, "unknown type '%d' (internal fsck error)",
806                           obj->type);
807 }
808
809 int fsck_error_function(struct object *obj, int msg_type, const char *message)
810 {
811         if (msg_type == FSCK_WARN) {
812                 warning("object %s: %s", sha1_to_hex(obj->sha1), message);
813                 return 0;
814         }
815         error("object %s: %s", sha1_to_hex(obj->sha1), message);
816         return 1;
817 }