Imported Upstream version 2.24.1
[platform/upstream/git.git] / fsck.c
1 #include "cache.h"
2 #include "object-store.h"
3 #include "repository.h"
4 #include "object.h"
5 #include "blob.h"
6 #include "tree.h"
7 #include "tree-walk.h"
8 #include "commit.h"
9 #include "tag.h"
10 #include "fsck.h"
11 #include "refs.h"
12 #include "utf8.h"
13 #include "decorate.h"
14 #include "oidset.h"
15 #include "packfile.h"
16 #include "submodule-config.h"
17 #include "config.h"
18 #include "help.h"
19
20 static struct oidset gitmodules_found = OIDSET_INIT;
21 static struct oidset gitmodules_done = OIDSET_INIT;
22
23 #define FSCK_FATAL -1
24 #define FSCK_INFO -2
25
26 #define FOREACH_MSG_ID(FUNC) \
27         /* fatal errors */ \
28         FUNC(NUL_IN_HEADER, FATAL) \
29         FUNC(UNTERMINATED_HEADER, FATAL) \
30         /* errors */ \
31         FUNC(BAD_DATE, ERROR) \
32         FUNC(BAD_DATE_OVERFLOW, ERROR) \
33         FUNC(BAD_EMAIL, ERROR) \
34         FUNC(BAD_NAME, ERROR) \
35         FUNC(BAD_OBJECT_SHA1, ERROR) \
36         FUNC(BAD_PARENT_SHA1, ERROR) \
37         FUNC(BAD_TAG_OBJECT, ERROR) \
38         FUNC(BAD_TIMEZONE, ERROR) \
39         FUNC(BAD_TREE, ERROR) \
40         FUNC(BAD_TREE_SHA1, ERROR) \
41         FUNC(BAD_TYPE, ERROR) \
42         FUNC(DUPLICATE_ENTRIES, ERROR) \
43         FUNC(MISSING_AUTHOR, ERROR) \
44         FUNC(MISSING_COMMITTER, ERROR) \
45         FUNC(MISSING_EMAIL, ERROR) \
46         FUNC(MISSING_GRAFT, ERROR) \
47         FUNC(MISSING_NAME_BEFORE_EMAIL, ERROR) \
48         FUNC(MISSING_OBJECT, ERROR) \
49         FUNC(MISSING_PARENT, ERROR) \
50         FUNC(MISSING_SPACE_BEFORE_DATE, ERROR) \
51         FUNC(MISSING_SPACE_BEFORE_EMAIL, ERROR) \
52         FUNC(MISSING_TAG, ERROR) \
53         FUNC(MISSING_TAG_ENTRY, ERROR) \
54         FUNC(MISSING_TAG_OBJECT, ERROR) \
55         FUNC(MISSING_TREE, ERROR) \
56         FUNC(MISSING_TREE_OBJECT, ERROR) \
57         FUNC(MISSING_TYPE, ERROR) \
58         FUNC(MISSING_TYPE_ENTRY, ERROR) \
59         FUNC(MULTIPLE_AUTHORS, ERROR) \
60         FUNC(TAG_OBJECT_NOT_TAG, ERROR) \
61         FUNC(TREE_NOT_SORTED, ERROR) \
62         FUNC(UNKNOWN_TYPE, ERROR) \
63         FUNC(ZERO_PADDED_DATE, ERROR) \
64         FUNC(GITMODULES_MISSING, ERROR) \
65         FUNC(GITMODULES_BLOB, ERROR) \
66         FUNC(GITMODULES_LARGE, ERROR) \
67         FUNC(GITMODULES_NAME, ERROR) \
68         FUNC(GITMODULES_SYMLINK, ERROR) \
69         FUNC(GITMODULES_URL, ERROR) \
70         FUNC(GITMODULES_PATH, ERROR) \
71         FUNC(GITMODULES_UPDATE, ERROR) \
72         /* warnings */ \
73         FUNC(BAD_FILEMODE, WARN) \
74         FUNC(EMPTY_NAME, WARN) \
75         FUNC(FULL_PATHNAME, WARN) \
76         FUNC(HAS_DOT, WARN) \
77         FUNC(HAS_DOTDOT, WARN) \
78         FUNC(HAS_DOTGIT, WARN) \
79         FUNC(NULL_SHA1, WARN) \
80         FUNC(ZERO_PADDED_FILEMODE, WARN) \
81         FUNC(NUL_IN_COMMIT, WARN) \
82         /* infos (reported as warnings, but ignored by default) */ \
83         FUNC(GITMODULES_PARSE, INFO) \
84         FUNC(BAD_TAG_NAME, INFO) \
85         FUNC(MISSING_TAGGER_ENTRY, INFO)
86
87 #define MSG_ID(id, msg_type) FSCK_MSG_##id,
88 enum fsck_msg_id {
89         FOREACH_MSG_ID(MSG_ID)
90         FSCK_MSG_MAX
91 };
92 #undef MSG_ID
93
94 #define STR(x) #x
95 #define MSG_ID(id, msg_type) { STR(id), NULL, NULL, FSCK_##msg_type },
96 static struct {
97         const char *id_string;
98         const char *downcased;
99         const char *camelcased;
100         int msg_type;
101 } msg_id_info[FSCK_MSG_MAX + 1] = {
102         FOREACH_MSG_ID(MSG_ID)
103         { NULL, NULL, NULL, -1 }
104 };
105 #undef MSG_ID
106
107 static void prepare_msg_ids(void)
108 {
109         int i;
110
111         if (msg_id_info[0].downcased)
112                 return;
113
114         /* convert id_string to lower case, without underscores. */
115         for (i = 0; i < FSCK_MSG_MAX; i++) {
116                 const char *p = msg_id_info[i].id_string;
117                 int len = strlen(p);
118                 char *q = xmalloc(len);
119
120                 msg_id_info[i].downcased = q;
121                 while (*p)
122                         if (*p == '_')
123                                 p++;
124                         else
125                                 *(q)++ = tolower(*(p)++);
126                 *q = '\0';
127
128                 p = msg_id_info[i].id_string;
129                 q = xmalloc(len);
130                 msg_id_info[i].camelcased = q;
131                 while (*p) {
132                         if (*p == '_') {
133                                 p++;
134                                 if (*p)
135                                         *q++ = *p++;
136                         } else {
137                                 *q++ = tolower(*p++);
138                         }
139                 }
140                 *q = '\0';
141         }
142 }
143
144 static int parse_msg_id(const char *text)
145 {
146         int i;
147
148         prepare_msg_ids();
149
150         for (i = 0; i < FSCK_MSG_MAX; i++)
151                 if (!strcmp(text, msg_id_info[i].downcased))
152                         return i;
153
154         return -1;
155 }
156
157 void list_config_fsck_msg_ids(struct string_list *list, const char *prefix)
158 {
159         int i;
160
161         prepare_msg_ids();
162
163         for (i = 0; i < FSCK_MSG_MAX; i++)
164                 list_config_item(list, prefix, msg_id_info[i].camelcased);
165 }
166
167 static int fsck_msg_type(enum fsck_msg_id msg_id,
168         struct fsck_options *options)
169 {
170         int msg_type;
171
172         assert(msg_id >= 0 && msg_id < FSCK_MSG_MAX);
173
174         if (options->msg_type)
175                 msg_type = options->msg_type[msg_id];
176         else {
177                 msg_type = msg_id_info[msg_id].msg_type;
178                 if (options->strict && msg_type == FSCK_WARN)
179                         msg_type = FSCK_ERROR;
180         }
181
182         return msg_type;
183 }
184
185 static int parse_msg_type(const char *str)
186 {
187         if (!strcmp(str, "error"))
188                 return FSCK_ERROR;
189         else if (!strcmp(str, "warn"))
190                 return FSCK_WARN;
191         else if (!strcmp(str, "ignore"))
192                 return FSCK_IGNORE;
193         else
194                 die("Unknown fsck message type: '%s'", str);
195 }
196
197 int is_valid_msg_type(const char *msg_id, const char *msg_type)
198 {
199         if (parse_msg_id(msg_id) < 0)
200                 return 0;
201         parse_msg_type(msg_type);
202         return 1;
203 }
204
205 void fsck_set_msg_type(struct fsck_options *options,
206                 const char *msg_id, const char *msg_type)
207 {
208         int id = parse_msg_id(msg_id), type;
209
210         if (id < 0)
211                 die("Unhandled message id: %s", msg_id);
212         type = parse_msg_type(msg_type);
213
214         if (type != FSCK_ERROR && msg_id_info[id].msg_type == FSCK_FATAL)
215                 die("Cannot demote %s to %s", msg_id, msg_type);
216
217         if (!options->msg_type) {
218                 int i;
219                 int *msg_type;
220                 ALLOC_ARRAY(msg_type, FSCK_MSG_MAX);
221                 for (i = 0; i < FSCK_MSG_MAX; i++)
222                         msg_type[i] = fsck_msg_type(i, options);
223                 options->msg_type = msg_type;
224         }
225
226         options->msg_type[id] = type;
227 }
228
229 void fsck_set_msg_types(struct fsck_options *options, const char *values)
230 {
231         char *buf = xstrdup(values), *to_free = buf;
232         int done = 0;
233
234         while (!done) {
235                 int len = strcspn(buf, " ,|"), equal;
236
237                 done = !buf[len];
238                 if (!len) {
239                         buf++;
240                         continue;
241                 }
242                 buf[len] = '\0';
243
244                 for (equal = 0;
245                      equal < len && buf[equal] != '=' && buf[equal] != ':';
246                      equal++)
247                         buf[equal] = tolower(buf[equal]);
248                 buf[equal] = '\0';
249
250                 if (!strcmp(buf, "skiplist")) {
251                         if (equal == len)
252                                 die("skiplist requires a path");
253                         oidset_parse_file(&options->skiplist, buf + equal + 1);
254                         buf += len + 1;
255                         continue;
256                 }
257
258                 if (equal == len)
259                         die("Missing '=': '%s'", buf);
260
261                 fsck_set_msg_type(options, buf, buf + equal + 1);
262                 buf += len + 1;
263         }
264         free(to_free);
265 }
266
267 static void append_msg_id(struct strbuf *sb, const char *msg_id)
268 {
269         for (;;) {
270                 char c = *(msg_id)++;
271
272                 if (!c)
273                         break;
274                 if (c != '_')
275                         strbuf_addch(sb, tolower(c));
276                 else {
277                         assert(*msg_id);
278                         strbuf_addch(sb, *(msg_id)++);
279                 }
280         }
281
282         strbuf_addstr(sb, ": ");
283 }
284
285 static int object_on_skiplist(struct fsck_options *opts, struct object *obj)
286 {
287         return opts && obj && oidset_contains(&opts->skiplist, &obj->oid);
288 }
289
290 __attribute__((format (printf, 4, 5)))
291 static int report(struct fsck_options *options, struct object *object,
292         enum fsck_msg_id id, const char *fmt, ...)
293 {
294         va_list ap;
295         struct strbuf sb = STRBUF_INIT;
296         int msg_type = fsck_msg_type(id, options), result;
297
298         if (msg_type == FSCK_IGNORE)
299                 return 0;
300
301         if (object_on_skiplist(options, object))
302                 return 0;
303
304         if (msg_type == FSCK_FATAL)
305                 msg_type = FSCK_ERROR;
306         else if (msg_type == FSCK_INFO)
307                 msg_type = FSCK_WARN;
308
309         append_msg_id(&sb, msg_id_info[id].id_string);
310
311         va_start(ap, fmt);
312         strbuf_vaddf(&sb, fmt, ap);
313         result = options->error_func(options, object, msg_type, sb.buf);
314         strbuf_release(&sb);
315         va_end(ap);
316
317         return result;
318 }
319
320 static char *get_object_name(struct fsck_options *options, struct object *obj)
321 {
322         if (!options->object_names)
323                 return NULL;
324         return lookup_decoration(options->object_names, obj);
325 }
326
327 static void put_object_name(struct fsck_options *options, struct object *obj,
328         const char *fmt, ...)
329 {
330         va_list ap;
331         struct strbuf buf = STRBUF_INIT;
332         char *existing;
333
334         if (!options->object_names)
335                 return;
336         existing = lookup_decoration(options->object_names, obj);
337         if (existing)
338                 return;
339         va_start(ap, fmt);
340         strbuf_vaddf(&buf, fmt, ap);
341         add_decoration(options->object_names, obj, strbuf_detach(&buf, NULL));
342         va_end(ap);
343 }
344
345 static const char *describe_object(struct fsck_options *o, struct object *obj)
346 {
347         static struct strbuf buf = STRBUF_INIT;
348         char *name;
349
350         strbuf_reset(&buf);
351         strbuf_addstr(&buf, oid_to_hex(&obj->oid));
352         if (o->object_names && (name = lookup_decoration(o->object_names, obj)))
353                 strbuf_addf(&buf, " (%s)", name);
354
355         return buf.buf;
356 }
357
358 static int fsck_walk_tree(struct tree *tree, void *data, struct fsck_options *options)
359 {
360         struct tree_desc desc;
361         struct name_entry entry;
362         int res = 0;
363         const char *name;
364
365         if (parse_tree(tree))
366                 return -1;
367
368         name = get_object_name(options, &tree->object);
369         if (init_tree_desc_gently(&desc, tree->buffer, tree->size))
370                 return -1;
371         while (tree_entry_gently(&desc, &entry)) {
372                 struct object *obj;
373                 int result;
374
375                 if (S_ISGITLINK(entry.mode))
376                         continue;
377
378                 if (S_ISDIR(entry.mode)) {
379                         obj = (struct object *)lookup_tree(the_repository, &entry.oid);
380                         if (name && obj)
381                                 put_object_name(options, obj, "%s%s/", name,
382                                         entry.path);
383                         result = options->walk(obj, OBJ_TREE, data, options);
384                 }
385                 else if (S_ISREG(entry.mode) || S_ISLNK(entry.mode)) {
386                         obj = (struct object *)lookup_blob(the_repository, &entry.oid);
387                         if (name && obj)
388                                 put_object_name(options, obj, "%s%s", name,
389                                         entry.path);
390                         result = options->walk(obj, OBJ_BLOB, data, options);
391                 }
392                 else {
393                         result = error("in tree %s: entry %s has bad mode %.6o",
394                                         describe_object(options, &tree->object), entry.path, entry.mode);
395                 }
396                 if (result < 0)
397                         return result;
398                 if (!res)
399                         res = result;
400         }
401         return res;
402 }
403
404 static int fsck_walk_commit(struct commit *commit, void *data, struct fsck_options *options)
405 {
406         int counter = 0, generation = 0, name_prefix_len = 0;
407         struct commit_list *parents;
408         int res;
409         int result;
410         const char *name;
411
412         if (parse_commit(commit))
413                 return -1;
414
415         name = get_object_name(options, &commit->object);
416         if (name)
417                 put_object_name(options, &get_commit_tree(commit)->object,
418                                 "%s:", name);
419
420         result = options->walk((struct object *)get_commit_tree(commit),
421                                OBJ_TREE, data, options);
422         if (result < 0)
423                 return result;
424         res = result;
425
426         parents = commit->parents;
427         if (name && parents) {
428                 int len = strlen(name), power;
429
430                 if (len && name[len - 1] == '^') {
431                         generation = 1;
432                         name_prefix_len = len - 1;
433                 }
434                 else { /* parse ~<generation> suffix */
435                         for (generation = 0, power = 1;
436                              len && isdigit(name[len - 1]);
437                              power *= 10)
438                                 generation += power * (name[--len] - '0');
439                         if (power > 1 && len && name[len - 1] == '~')
440                                 name_prefix_len = len - 1;
441                 }
442         }
443
444         while (parents) {
445                 if (name) {
446                         struct object *obj = &parents->item->object;
447
448                         if (counter++)
449                                 put_object_name(options, obj, "%s^%d",
450                                         name, counter);
451                         else if (generation > 0)
452                                 put_object_name(options, obj, "%.*s~%d",
453                                         name_prefix_len, name, generation + 1);
454                         else
455                                 put_object_name(options, obj, "%s^", name);
456                 }
457                 result = options->walk((struct object *)parents->item, OBJ_COMMIT, data, options);
458                 if (result < 0)
459                         return result;
460                 if (!res)
461                         res = result;
462                 parents = parents->next;
463         }
464         return res;
465 }
466
467 static int fsck_walk_tag(struct tag *tag, void *data, struct fsck_options *options)
468 {
469         char *name = get_object_name(options, &tag->object);
470
471         if (parse_tag(tag))
472                 return -1;
473         if (name)
474                 put_object_name(options, tag->tagged, "%s", name);
475         return options->walk(tag->tagged, OBJ_ANY, data, options);
476 }
477
478 int fsck_walk(struct object *obj, void *data, struct fsck_options *options)
479 {
480         if (!obj)
481                 return -1;
482
483         if (obj->type == OBJ_NONE)
484                 parse_object(the_repository, &obj->oid);
485
486         switch (obj->type) {
487         case OBJ_BLOB:
488                 return 0;
489         case OBJ_TREE:
490                 return fsck_walk_tree((struct tree *)obj, data, options);
491         case OBJ_COMMIT:
492                 return fsck_walk_commit((struct commit *)obj, data, options);
493         case OBJ_TAG:
494                 return fsck_walk_tag((struct tag *)obj, data, options);
495         default:
496                 error("Unknown object type for %s", describe_object(options, obj));
497                 return -1;
498         }
499 }
500
501 /*
502  * The entries in a tree are ordered in the _path_ order,
503  * which means that a directory entry is ordered by adding
504  * a slash to the end of it.
505  *
506  * So a directory called "a" is ordered _after_ a file
507  * called "a.c", because "a/" sorts after "a.c".
508  */
509 #define TREE_UNORDERED (-1)
510 #define TREE_HAS_DUPS  (-2)
511
512 static int verify_ordered(unsigned mode1, const char *name1, unsigned mode2, const char *name2)
513 {
514         int len1 = strlen(name1);
515         int len2 = strlen(name2);
516         int len = len1 < len2 ? len1 : len2;
517         unsigned char c1, c2;
518         int cmp;
519
520         cmp = memcmp(name1, name2, len);
521         if (cmp < 0)
522                 return 0;
523         if (cmp > 0)
524                 return TREE_UNORDERED;
525
526         /*
527          * Ok, the first <len> characters are the same.
528          * Now we need to order the next one, but turn
529          * a '\0' into a '/' for a directory entry.
530          */
531         c1 = name1[len];
532         c2 = name2[len];
533         if (!c1 && !c2)
534                 /*
535                  * git-write-tree used to write out a nonsense tree that has
536                  * entries with the same name, one blob and one tree.  Make
537                  * sure we do not have duplicate entries.
538                  */
539                 return TREE_HAS_DUPS;
540         if (!c1 && S_ISDIR(mode1))
541                 c1 = '/';
542         if (!c2 && S_ISDIR(mode2))
543                 c2 = '/';
544         return c1 < c2 ? 0 : TREE_UNORDERED;
545 }
546
547 static int fsck_tree(struct tree *item, struct fsck_options *options)
548 {
549         int retval = 0;
550         int has_null_sha1 = 0;
551         int has_full_path = 0;
552         int has_empty_name = 0;
553         int has_dot = 0;
554         int has_dotdot = 0;
555         int has_dotgit = 0;
556         int has_zero_pad = 0;
557         int has_bad_modes = 0;
558         int has_dup_entries = 0;
559         int not_properly_sorted = 0;
560         struct tree_desc desc;
561         unsigned o_mode;
562         const char *o_name;
563
564         if (init_tree_desc_gently(&desc, item->buffer, item->size)) {
565                 retval += report(options, &item->object, FSCK_MSG_BAD_TREE, "cannot be parsed as a tree");
566                 return retval;
567         }
568
569         o_mode = 0;
570         o_name = NULL;
571
572         while (desc.size) {
573                 unsigned short mode;
574                 const char *name, *backslash;
575                 const struct object_id *oid;
576
577                 oid = tree_entry_extract(&desc, &name, &mode);
578
579                 has_null_sha1 |= is_null_oid(oid);
580                 has_full_path |= !!strchr(name, '/');
581                 has_empty_name |= !*name;
582                 has_dot |= !strcmp(name, ".");
583                 has_dotdot |= !strcmp(name, "..");
584                 has_dotgit |= is_hfs_dotgit(name) || is_ntfs_dotgit(name);
585                 has_zero_pad |= *(char *)desc.buffer == '0';
586
587                 if (is_hfs_dotgitmodules(name) || is_ntfs_dotgitmodules(name)) {
588                         if (!S_ISLNK(mode))
589                                 oidset_insert(&gitmodules_found, oid);
590                         else
591                                 retval += report(options, &item->object,
592                                                  FSCK_MSG_GITMODULES_SYMLINK,
593                                                  ".gitmodules is a symbolic link");
594                 }
595
596                 if ((backslash = strchr(name, '\\'))) {
597                         while (backslash) {
598                                 backslash++;
599                                 has_dotgit |= is_ntfs_dotgit(backslash);
600                                 if (is_ntfs_dotgitmodules(backslash)) {
601                                         if (!S_ISLNK(mode))
602                                                 oidset_insert(&gitmodules_found, oid);
603                                         else
604                                                 retval += report(options, &item->object,
605                                                                  FSCK_MSG_GITMODULES_SYMLINK,
606                                                                  ".gitmodules is a symbolic link");
607                                 }
608                                 backslash = strchr(backslash, '\\');
609                         }
610                 }
611
612                 if (update_tree_entry_gently(&desc)) {
613                         retval += report(options, &item->object, FSCK_MSG_BAD_TREE, "cannot be parsed as a tree");
614                         break;
615                 }
616
617                 switch (mode) {
618                 /*
619                  * Standard modes..
620                  */
621                 case S_IFREG | 0755:
622                 case S_IFREG | 0644:
623                 case S_IFLNK:
624                 case S_IFDIR:
625                 case S_IFGITLINK:
626                         break;
627                 /*
628                  * This is nonstandard, but we had a few of these
629                  * early on when we honored the full set of mode
630                  * bits..
631                  */
632                 case S_IFREG | 0664:
633                         if (!options->strict)
634                                 break;
635                         /* fallthrough */
636                 default:
637                         has_bad_modes = 1;
638                 }
639
640                 if (o_name) {
641                         switch (verify_ordered(o_mode, o_name, mode, name)) {
642                         case TREE_UNORDERED:
643                                 not_properly_sorted = 1;
644                                 break;
645                         case TREE_HAS_DUPS:
646                                 has_dup_entries = 1;
647                                 break;
648                         default:
649                                 break;
650                         }
651                 }
652
653                 o_mode = mode;
654                 o_name = name;
655         }
656
657         if (has_null_sha1)
658                 retval += report(options, &item->object, FSCK_MSG_NULL_SHA1, "contains entries pointing to null sha1");
659         if (has_full_path)
660                 retval += report(options, &item->object, FSCK_MSG_FULL_PATHNAME, "contains full pathnames");
661         if (has_empty_name)
662                 retval += report(options, &item->object, FSCK_MSG_EMPTY_NAME, "contains empty pathname");
663         if (has_dot)
664                 retval += report(options, &item->object, FSCK_MSG_HAS_DOT, "contains '.'");
665         if (has_dotdot)
666                 retval += report(options, &item->object, FSCK_MSG_HAS_DOTDOT, "contains '..'");
667         if (has_dotgit)
668                 retval += report(options, &item->object, FSCK_MSG_HAS_DOTGIT, "contains '.git'");
669         if (has_zero_pad)
670                 retval += report(options, &item->object, FSCK_MSG_ZERO_PADDED_FILEMODE, "contains zero-padded file modes");
671         if (has_bad_modes)
672                 retval += report(options, &item->object, FSCK_MSG_BAD_FILEMODE, "contains bad file modes");
673         if (has_dup_entries)
674                 retval += report(options, &item->object, FSCK_MSG_DUPLICATE_ENTRIES, "contains duplicate file entries");
675         if (not_properly_sorted)
676                 retval += report(options, &item->object, FSCK_MSG_TREE_NOT_SORTED, "not properly sorted");
677         return retval;
678 }
679
680 static int verify_headers(const void *data, unsigned long size,
681                           struct object *obj, struct fsck_options *options)
682 {
683         const char *buffer = (const char *)data;
684         unsigned long i;
685
686         for (i = 0; i < size; i++) {
687                 switch (buffer[i]) {
688                 case '\0':
689                         return report(options, obj,
690                                 FSCK_MSG_NUL_IN_HEADER,
691                                 "unterminated header: NUL at offset %ld", i);
692                 case '\n':
693                         if (i + 1 < size && buffer[i + 1] == '\n')
694                                 return 0;
695                 }
696         }
697
698         /*
699          * We did not find double-LF that separates the header
700          * and the body.  Not having a body is not a crime but
701          * we do want to see the terminating LF for the last header
702          * line.
703          */
704         if (size && buffer[size - 1] == '\n')
705                 return 0;
706
707         return report(options, obj,
708                 FSCK_MSG_UNTERMINATED_HEADER, "unterminated header");
709 }
710
711 static int fsck_ident(const char **ident, struct object *obj, struct fsck_options *options)
712 {
713         const char *p = *ident;
714         char *end;
715
716         *ident = strchrnul(*ident, '\n');
717         if (**ident == '\n')
718                 (*ident)++;
719
720         if (*p == '<')
721                 return report(options, obj, FSCK_MSG_MISSING_NAME_BEFORE_EMAIL, "invalid author/committer line - missing space before email");
722         p += strcspn(p, "<>\n");
723         if (*p == '>')
724                 return report(options, obj, FSCK_MSG_BAD_NAME, "invalid author/committer line - bad name");
725         if (*p != '<')
726                 return report(options, obj, FSCK_MSG_MISSING_EMAIL, "invalid author/committer line - missing email");
727         if (p[-1] != ' ')
728                 return report(options, obj, FSCK_MSG_MISSING_SPACE_BEFORE_EMAIL, "invalid author/committer line - missing space before email");
729         p++;
730         p += strcspn(p, "<>\n");
731         if (*p != '>')
732                 return report(options, obj, FSCK_MSG_BAD_EMAIL, "invalid author/committer line - bad email");
733         p++;
734         if (*p != ' ')
735                 return report(options, obj, FSCK_MSG_MISSING_SPACE_BEFORE_DATE, "invalid author/committer line - missing space before date");
736         p++;
737         if (*p == '0' && p[1] != ' ')
738                 return report(options, obj, FSCK_MSG_ZERO_PADDED_DATE, "invalid author/committer line - zero-padded date");
739         if (date_overflows(parse_timestamp(p, &end, 10)))
740                 return report(options, obj, FSCK_MSG_BAD_DATE_OVERFLOW, "invalid author/committer line - date causes integer overflow");
741         if ((end == p || *end != ' '))
742                 return report(options, obj, FSCK_MSG_BAD_DATE, "invalid author/committer line - bad date");
743         p = end + 1;
744         if ((*p != '+' && *p != '-') ||
745             !isdigit(p[1]) ||
746             !isdigit(p[2]) ||
747             !isdigit(p[3]) ||
748             !isdigit(p[4]) ||
749             (p[5] != '\n'))
750                 return report(options, obj, FSCK_MSG_BAD_TIMEZONE, "invalid author/committer line - bad time zone");
751         p += 6;
752         return 0;
753 }
754
755 static int fsck_commit_buffer(struct commit *commit, const char *buffer,
756         unsigned long size, struct fsck_options *options)
757 {
758         struct object_id tree_oid, oid;
759         struct commit_graft *graft;
760         unsigned parent_count, parent_line_count = 0, author_count;
761         int err;
762         const char *buffer_begin = buffer;
763         const char *p;
764
765         if (verify_headers(buffer, size, &commit->object, options))
766                 return -1;
767
768         if (!skip_prefix(buffer, "tree ", &buffer))
769                 return report(options, &commit->object, FSCK_MSG_MISSING_TREE, "invalid format - expected 'tree' line");
770         if (parse_oid_hex(buffer, &tree_oid, &p) || *p != '\n') {
771                 err = report(options, &commit->object, FSCK_MSG_BAD_TREE_SHA1, "invalid 'tree' line format - bad sha1");
772                 if (err)
773                         return err;
774         }
775         buffer = p + 1;
776         while (skip_prefix(buffer, "parent ", &buffer)) {
777                 if (parse_oid_hex(buffer, &oid, &p) || *p != '\n') {
778                         err = report(options, &commit->object, FSCK_MSG_BAD_PARENT_SHA1, "invalid 'parent' line format - bad sha1");
779                         if (err)
780                                 return err;
781                 }
782                 buffer = p + 1;
783                 parent_line_count++;
784         }
785         graft = lookup_commit_graft(the_repository, &commit->object.oid);
786         parent_count = commit_list_count(commit->parents);
787         if (graft) {
788                 if (graft->nr_parent == -1 && !parent_count)
789                         ; /* shallow commit */
790                 else if (graft->nr_parent != parent_count) {
791                         err = report(options, &commit->object, FSCK_MSG_MISSING_GRAFT, "graft objects missing");
792                         if (err)
793                                 return err;
794                 }
795         } else {
796                 if (parent_count != parent_line_count) {
797                         err = report(options, &commit->object, FSCK_MSG_MISSING_PARENT, "parent objects missing");
798                         if (err)
799                                 return err;
800                 }
801         }
802         author_count = 0;
803         while (skip_prefix(buffer, "author ", &buffer)) {
804                 author_count++;
805                 err = fsck_ident(&buffer, &commit->object, options);
806                 if (err)
807                         return err;
808         }
809         if (author_count < 1)
810                 err = report(options, &commit->object, FSCK_MSG_MISSING_AUTHOR, "invalid format - expected 'author' line");
811         else if (author_count > 1)
812                 err = report(options, &commit->object, FSCK_MSG_MULTIPLE_AUTHORS, "invalid format - multiple 'author' lines");
813         if (err)
814                 return err;
815         if (!skip_prefix(buffer, "committer ", &buffer))
816                 return report(options, &commit->object, FSCK_MSG_MISSING_COMMITTER, "invalid format - expected 'committer' line");
817         err = fsck_ident(&buffer, &commit->object, options);
818         if (err)
819                 return err;
820         if (!get_commit_tree(commit)) {
821                 err = report(options, &commit->object, FSCK_MSG_BAD_TREE, "could not load commit's tree %s", oid_to_hex(&tree_oid));
822                 if (err)
823                         return err;
824         }
825         if (memchr(buffer_begin, '\0', size)) {
826                 err = report(options, &commit->object, FSCK_MSG_NUL_IN_COMMIT,
827                              "NUL byte in the commit object body");
828                 if (err)
829                         return err;
830         }
831         return 0;
832 }
833
834 static int fsck_commit(struct commit *commit, const char *data,
835         unsigned long size, struct fsck_options *options)
836 {
837         const char *buffer = data ?  data : get_commit_buffer(commit, &size);
838         int ret = fsck_commit_buffer(commit, buffer, size, options);
839         if (!data)
840                 unuse_commit_buffer(commit, buffer);
841         return ret;
842 }
843
844 static int fsck_tag_buffer(struct tag *tag, const char *data,
845         unsigned long size, struct fsck_options *options)
846 {
847         struct object_id oid;
848         int ret = 0;
849         const char *buffer;
850         char *to_free = NULL, *eol;
851         struct strbuf sb = STRBUF_INIT;
852         const char *p;
853
854         if (data)
855                 buffer = data;
856         else {
857                 enum object_type type;
858
859                 buffer = to_free =
860                         read_object_file(&tag->object.oid, &type, &size);
861                 if (!buffer)
862                         return report(options, &tag->object,
863                                 FSCK_MSG_MISSING_TAG_OBJECT,
864                                 "cannot read tag object");
865
866                 if (type != OBJ_TAG) {
867                         ret = report(options, &tag->object,
868                                 FSCK_MSG_TAG_OBJECT_NOT_TAG,
869                                 "expected tag got %s",
870                             type_name(type));
871                         goto done;
872                 }
873         }
874
875         ret = verify_headers(buffer, size, &tag->object, options);
876         if (ret)
877                 goto done;
878
879         if (!skip_prefix(buffer, "object ", &buffer)) {
880                 ret = report(options, &tag->object, FSCK_MSG_MISSING_OBJECT, "invalid format - expected 'object' line");
881                 goto done;
882         }
883         if (parse_oid_hex(buffer, &oid, &p) || *p != '\n') {
884                 ret = report(options, &tag->object, FSCK_MSG_BAD_OBJECT_SHA1, "invalid 'object' line format - bad sha1");
885                 if (ret)
886                         goto done;
887         }
888         buffer = p + 1;
889
890         if (!skip_prefix(buffer, "type ", &buffer)) {
891                 ret = report(options, &tag->object, FSCK_MSG_MISSING_TYPE_ENTRY, "invalid format - expected 'type' line");
892                 goto done;
893         }
894         eol = strchr(buffer, '\n');
895         if (!eol) {
896                 ret = report(options, &tag->object, FSCK_MSG_MISSING_TYPE, "invalid format - unexpected end after 'type' line");
897                 goto done;
898         }
899         if (type_from_string_gently(buffer, eol - buffer, 1) < 0)
900                 ret = report(options, &tag->object, FSCK_MSG_BAD_TYPE, "invalid 'type' value");
901         if (ret)
902                 goto done;
903         buffer = eol + 1;
904
905         if (!skip_prefix(buffer, "tag ", &buffer)) {
906                 ret = report(options, &tag->object, FSCK_MSG_MISSING_TAG_ENTRY, "invalid format - expected 'tag' line");
907                 goto done;
908         }
909         eol = strchr(buffer, '\n');
910         if (!eol) {
911                 ret = report(options, &tag->object, FSCK_MSG_MISSING_TAG, "invalid format - unexpected end after 'type' line");
912                 goto done;
913         }
914         strbuf_addf(&sb, "refs/tags/%.*s", (int)(eol - buffer), buffer);
915         if (check_refname_format(sb.buf, 0)) {
916                 ret = report(options, &tag->object, FSCK_MSG_BAD_TAG_NAME,
917                            "invalid 'tag' name: %.*s",
918                            (int)(eol - buffer), buffer);
919                 if (ret)
920                         goto done;
921         }
922         buffer = eol + 1;
923
924         if (!skip_prefix(buffer, "tagger ", &buffer)) {
925                 /* early tags do not contain 'tagger' lines; warn only */
926                 ret = report(options, &tag->object, FSCK_MSG_MISSING_TAGGER_ENTRY, "invalid format - expected 'tagger' line");
927                 if (ret)
928                         goto done;
929         }
930         else
931                 ret = fsck_ident(&buffer, &tag->object, options);
932
933 done:
934         strbuf_release(&sb);
935         free(to_free);
936         return ret;
937 }
938
939 static int fsck_tag(struct tag *tag, const char *data,
940         unsigned long size, struct fsck_options *options)
941 {
942         struct object *tagged = tag->tagged;
943
944         if (!tagged)
945                 return report(options, &tag->object, FSCK_MSG_BAD_TAG_OBJECT, "could not load tagged object");
946
947         return fsck_tag_buffer(tag, data, size, options);
948 }
949
950 struct fsck_gitmodules_data {
951         struct object *obj;
952         struct fsck_options *options;
953         int ret;
954 };
955
956 static int fsck_gitmodules_fn(const char *var, const char *value, void *vdata)
957 {
958         struct fsck_gitmodules_data *data = vdata;
959         const char *subsection, *key;
960         int subsection_len;
961         char *name;
962
963         if (parse_config_key(var, "submodule", &subsection, &subsection_len, &key) < 0 ||
964             !subsection)
965                 return 0;
966
967         name = xmemdupz(subsection, subsection_len);
968         if (check_submodule_name(name) < 0)
969                 data->ret |= report(data->options, data->obj,
970                                     FSCK_MSG_GITMODULES_NAME,
971                                     "disallowed submodule name: %s",
972                                     name);
973         if (!strcmp(key, "url") && value &&
974             looks_like_command_line_option(value))
975                 data->ret |= report(data->options, data->obj,
976                                     FSCK_MSG_GITMODULES_URL,
977                                     "disallowed submodule url: %s",
978                                     value);
979         if (!strcmp(key, "path") && value &&
980             looks_like_command_line_option(value))
981                 data->ret |= report(data->options, data->obj,
982                                     FSCK_MSG_GITMODULES_PATH,
983                                     "disallowed submodule path: %s",
984                                     value);
985         if (!strcmp(key, "update") && value &&
986             parse_submodule_update_type(value) == SM_UPDATE_COMMAND)
987                 data->ret |= report(data->options, data->obj,
988                                     FSCK_MSG_GITMODULES_UPDATE,
989                                     "disallowed submodule update setting: %s",
990                                     value);
991         free(name);
992
993         return 0;
994 }
995
996 static int fsck_blob(struct blob *blob, const char *buf,
997                      unsigned long size, struct fsck_options *options)
998 {
999         struct fsck_gitmodules_data data;
1000         struct config_options config_opts = { 0 };
1001
1002         if (!oidset_contains(&gitmodules_found, &blob->object.oid))
1003                 return 0;
1004         oidset_insert(&gitmodules_done, &blob->object.oid);
1005
1006         if (object_on_skiplist(options, &blob->object))
1007                 return 0;
1008
1009         if (!buf) {
1010                 /*
1011                  * A missing buffer here is a sign that the caller found the
1012                  * blob too gigantic to load into memory. Let's just consider
1013                  * that an error.
1014                  */
1015                 return report(options, &blob->object,
1016                               FSCK_MSG_GITMODULES_LARGE,
1017                               ".gitmodules too large to parse");
1018         }
1019
1020         data.obj = &blob->object;
1021         data.options = options;
1022         data.ret = 0;
1023         config_opts.error_action = CONFIG_ERROR_SILENT;
1024         if (git_config_from_mem(fsck_gitmodules_fn, CONFIG_ORIGIN_BLOB,
1025                                 ".gitmodules", buf, size, &data, &config_opts))
1026                 data.ret |= report(options, &blob->object,
1027                                    FSCK_MSG_GITMODULES_PARSE,
1028                                    "could not parse gitmodules blob");
1029
1030         return data.ret;
1031 }
1032
1033 int fsck_object(struct object *obj, void *data, unsigned long size,
1034         struct fsck_options *options)
1035 {
1036         if (!obj)
1037                 return report(options, obj, FSCK_MSG_BAD_OBJECT_SHA1, "no valid object to fsck");
1038
1039         if (obj->type == OBJ_BLOB)
1040                 return fsck_blob((struct blob *)obj, data, size, options);
1041         if (obj->type == OBJ_TREE)
1042                 return fsck_tree((struct tree *) obj, options);
1043         if (obj->type == OBJ_COMMIT)
1044                 return fsck_commit((struct commit *) obj, (const char *) data,
1045                         size, options);
1046         if (obj->type == OBJ_TAG)
1047                 return fsck_tag((struct tag *) obj, (const char *) data,
1048                         size, options);
1049
1050         return report(options, obj, FSCK_MSG_UNKNOWN_TYPE, "unknown type '%d' (internal fsck error)",
1051                           obj->type);
1052 }
1053
1054 int fsck_error_function(struct fsck_options *o,
1055         struct object *obj, int msg_type, const char *message)
1056 {
1057         if (msg_type == FSCK_WARN) {
1058                 warning("object %s: %s", describe_object(o, obj), message);
1059                 return 0;
1060         }
1061         error("object %s: %s", describe_object(o, obj), message);
1062         return 1;
1063 }
1064
1065 int fsck_finish(struct fsck_options *options)
1066 {
1067         int ret = 0;
1068         struct oidset_iter iter;
1069         const struct object_id *oid;
1070
1071         oidset_iter_init(&gitmodules_found, &iter);
1072         while ((oid = oidset_iter_next(&iter))) {
1073                 struct blob *blob;
1074                 enum object_type type;
1075                 unsigned long size;
1076                 char *buf;
1077
1078                 if (oidset_contains(&gitmodules_done, oid))
1079                         continue;
1080
1081                 blob = lookup_blob(the_repository, oid);
1082                 if (!blob) {
1083                         struct object *obj = lookup_unknown_object(oid);
1084                         ret |= report(options, obj,
1085                                       FSCK_MSG_GITMODULES_BLOB,
1086                                       "non-blob found at .gitmodules");
1087                         continue;
1088                 }
1089
1090                 buf = read_object_file(oid, &type, &size);
1091                 if (!buf) {
1092                         if (is_promisor_object(&blob->object.oid))
1093                                 continue;
1094                         ret |= report(options, &blob->object,
1095                                       FSCK_MSG_GITMODULES_MISSING,
1096                                       "unable to read .gitmodules blob");
1097                         continue;
1098                 }
1099
1100                 if (type == OBJ_BLOB)
1101                         ret |= fsck_blob(blob, buf, size, options);
1102                 else
1103                         ret |= report(options, &blob->object,
1104                                       FSCK_MSG_GITMODULES_BLOB,
1105                                       "non-blob found at .gitmodules");
1106                 free(buf);
1107         }
1108
1109
1110         oidset_clear(&gitmodules_found);
1111         oidset_clear(&gitmodules_done);
1112         return ret;
1113 }