]> git.ipfire.org Git - thirdparty/git.git/blame - fsck.c
fsck: report non-consecutive duplicate names in trees
[thirdparty/git.git] / fsck.c
CommitLineData
355885d5 1#include "cache.h"
cbd53a21 2#include "object-store.h"
109cd76d 3#include "repository.h"
355885d5
MK
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"
cec097be 11#include "refs.h"
a2b26ffb 12#include "url.h"
a18fcc9f 13#include "utf8.h"
7b35efd7 14#include "decorate.h"
159e7b08 15#include "oidset.h"
27387444 16#include "packfile.h"
ed8b10f6
JK
17#include "submodule-config.h"
18#include "config.h"
07259e74 19#include "credential.h"
3ac68a93 20#include "help.h"
159e7b08
JK
21
22static struct oidset gitmodules_found = OIDSET_INIT;
23static struct oidset gitmodules_done = OIDSET_INIT;
355885d5 24
f50c4407 25#define FSCK_FATAL -1
f27d05b1 26#define FSCK_INFO -2
f50c4407 27
c99ba492 28#define FOREACH_MSG_ID(FUNC) \
f50c4407
JS
29 /* fatal errors */ \
30 FUNC(NUL_IN_HEADER, FATAL) \
31 FUNC(UNTERMINATED_HEADER, FATAL) \
c99ba492
JS
32 /* errors */ \
33 FUNC(BAD_DATE, ERROR) \
34 FUNC(BAD_DATE_OVERFLOW, ERROR) \
35 FUNC(BAD_EMAIL, ERROR) \
36 FUNC(BAD_NAME, ERROR) \
37 FUNC(BAD_OBJECT_SHA1, ERROR) \
38 FUNC(BAD_PARENT_SHA1, ERROR) \
39 FUNC(BAD_TAG_OBJECT, ERROR) \
40 FUNC(BAD_TIMEZONE, ERROR) \
41 FUNC(BAD_TREE, ERROR) \
42 FUNC(BAD_TREE_SHA1, ERROR) \
43 FUNC(BAD_TYPE, ERROR) \
44 FUNC(DUPLICATE_ENTRIES, ERROR) \
45 FUNC(MISSING_AUTHOR, ERROR) \
46 FUNC(MISSING_COMMITTER, ERROR) \
47 FUNC(MISSING_EMAIL, ERROR) \
c99ba492
JS
48 FUNC(MISSING_NAME_BEFORE_EMAIL, ERROR) \
49 FUNC(MISSING_OBJECT, ERROR) \
c99ba492
JS
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) \
c99ba492 54 FUNC(MISSING_TREE, ERROR) \
159e7b08 55 FUNC(MISSING_TREE_OBJECT, ERROR) \
c99ba492
JS
56 FUNC(MISSING_TYPE, ERROR) \
57 FUNC(MISSING_TYPE_ENTRY, ERROR) \
c9ad147f 58 FUNC(MULTIPLE_AUTHORS, ERROR) \
c99ba492
JS
59 FUNC(TREE_NOT_SORTED, ERROR) \
60 FUNC(UNKNOWN_TYPE, ERROR) \
c99ba492 61 FUNC(ZERO_PADDED_DATE, ERROR) \
159e7b08
JK
62 FUNC(GITMODULES_MISSING, ERROR) \
63 FUNC(GITMODULES_BLOB, ERROR) \
0d68764d 64 FUNC(GITMODULES_LARGE, ERROR) \
ed8b10f6 65 FUNC(GITMODULES_NAME, ERROR) \
b7b1fca1 66 FUNC(GITMODULES_SYMLINK, ERROR) \
a124133e 67 FUNC(GITMODULES_URL, ERROR) \
1a7fd1fb 68 FUNC(GITMODULES_PATH, ERROR) \
bb92255e 69 FUNC(GITMODULES_UPDATE, ERROR) \
c99ba492
JS
70 /* warnings */ \
71 FUNC(BAD_FILEMODE, WARN) \
c99ba492
JS
72 FUNC(EMPTY_NAME, WARN) \
73 FUNC(FULL_PATHNAME, WARN) \
74 FUNC(HAS_DOT, WARN) \
75 FUNC(HAS_DOTDOT, WARN) \
76 FUNC(HAS_DOTGIT, WARN) \
c99ba492 77 FUNC(NULL_SHA1, WARN) \
f27d05b1 78 FUNC(ZERO_PADDED_FILEMODE, WARN) \
6d2d780f 79 FUNC(NUL_IN_COMMIT, WARN) \
f27d05b1 80 /* infos (reported as warnings, but ignored by default) */ \
64eb14d3 81 FUNC(GITMODULES_PARSE, INFO) \
f27d05b1
JS
82 FUNC(BAD_TAG_NAME, INFO) \
83 FUNC(MISSING_TAGGER_ENTRY, INFO)
c99ba492
JS
84
85#define MSG_ID(id, msg_type) FSCK_MSG_##id,
86enum fsck_msg_id {
87 FOREACH_MSG_ID(MSG_ID)
88 FSCK_MSG_MAX
89};
90#undef MSG_ID
91
f417eed8 92#define STR(x) #x
a4a9cc19 93#define MSG_ID(id, msg_type) { STR(id), NULL, NULL, FSCK_##msg_type },
c99ba492 94static struct {
f417eed8
JS
95 const char *id_string;
96 const char *downcased;
a4a9cc19 97 const char *camelcased;
c99ba492
JS
98 int msg_type;
99} msg_id_info[FSCK_MSG_MAX + 1] = {
100 FOREACH_MSG_ID(MSG_ID)
a4a9cc19 101 { NULL, NULL, NULL, -1 }
c99ba492
JS
102};
103#undef MSG_ID
104
a46baac6 105static void prepare_msg_ids(void)
f417eed8
JS
106{
107 int i;
108
a46baac6
NTND
109 if (msg_id_info[0].downcased)
110 return;
111
112 /* convert id_string to lower case, without underscores. */
113 for (i = 0; i < FSCK_MSG_MAX; i++) {
114 const char *p = msg_id_info[i].id_string;
115 int len = strlen(p);
116 char *q = xmalloc(len);
117
118 msg_id_info[i].downcased = q;
119 while (*p)
120 if (*p == '_')
121 p++;
122 else
123 *(q)++ = tolower(*(p)++);
124 *q = '\0';
a4a9cc19
NTND
125
126 p = msg_id_info[i].id_string;
127 q = xmalloc(len);
128 msg_id_info[i].camelcased = q;
129 while (*p) {
130 if (*p == '_') {
131 p++;
132 if (*p)
133 *q++ = *p++;
134 } else {
135 *q++ = tolower(*p++);
136 }
f417eed8 137 }
a4a9cc19 138 *q = '\0';
f417eed8 139 }
a46baac6
NTND
140}
141
142static int parse_msg_id(const char *text)
143{
144 int i;
145
146 prepare_msg_ids();
f417eed8
JS
147
148 for (i = 0; i < FSCK_MSG_MAX; i++)
149 if (!strcmp(text, msg_id_info[i].downcased))
150 return i;
151
152 return -1;
153}
154
3ac68a93
NTND
155void list_config_fsck_msg_ids(struct string_list *list, const char *prefix)
156{
157 int i;
158
159 prepare_msg_ids();
160
3ac68a93 161 for (i = 0; i < FSCK_MSG_MAX; i++)
a4a9cc19 162 list_config_item(list, prefix, msg_id_info[i].camelcased);
3ac68a93
NTND
163}
164
c99ba492
JS
165static int fsck_msg_type(enum fsck_msg_id msg_id,
166 struct fsck_options *options)
167{
168 int msg_type;
169
0282f4dc
JS
170 assert(msg_id >= 0 && msg_id < FSCK_MSG_MAX);
171
172 if (options->msg_type)
173 msg_type = options->msg_type[msg_id];
174 else {
175 msg_type = msg_id_info[msg_id].msg_type;
176 if (options->strict && msg_type == FSCK_WARN)
177 msg_type = FSCK_ERROR;
178 }
c99ba492
JS
179
180 return msg_type;
181}
182
0282f4dc
JS
183static int parse_msg_type(const char *str)
184{
185 if (!strcmp(str, "error"))
186 return FSCK_ERROR;
187 else if (!strcmp(str, "warn"))
188 return FSCK_WARN;
efaba7cc
JS
189 else if (!strcmp(str, "ignore"))
190 return FSCK_IGNORE;
0282f4dc
JS
191 else
192 die("Unknown fsck message type: '%s'", str);
193}
194
5d477a33
JS
195int is_valid_msg_type(const char *msg_id, const char *msg_type)
196{
197 if (parse_msg_id(msg_id) < 0)
198 return 0;
199 parse_msg_type(msg_type);
200 return 1;
201}
202
0282f4dc
JS
203void fsck_set_msg_type(struct fsck_options *options,
204 const char *msg_id, const char *msg_type)
205{
206 int id = parse_msg_id(msg_id), type;
207
208 if (id < 0)
209 die("Unhandled message id: %s", msg_id);
210 type = parse_msg_type(msg_type);
211
f50c4407
JS
212 if (type != FSCK_ERROR && msg_id_info[id].msg_type == FSCK_FATAL)
213 die("Cannot demote %s to %s", msg_id, msg_type);
214
0282f4dc
JS
215 if (!options->msg_type) {
216 int i;
b32fa95f
JK
217 int *msg_type;
218 ALLOC_ARRAY(msg_type, FSCK_MSG_MAX);
0282f4dc
JS
219 for (i = 0; i < FSCK_MSG_MAX; i++)
220 msg_type[i] = fsck_msg_type(i, options);
221 options->msg_type = msg_type;
222 }
223
224 options->msg_type[id] = type;
225}
226
227void fsck_set_msg_types(struct fsck_options *options, const char *values)
228{
229 char *buf = xstrdup(values), *to_free = buf;
230 int done = 0;
231
232 while (!done) {
233 int len = strcspn(buf, " ,|"), equal;
234
235 done = !buf[len];
236 if (!len) {
237 buf++;
238 continue;
239 }
240 buf[len] = '\0';
241
242 for (equal = 0;
243 equal < len && buf[equal] != '=' && buf[equal] != ':';
244 equal++)
245 buf[equal] = tolower(buf[equal]);
246 buf[equal] = '\0';
247
cd94c6f9
JS
248 if (!strcmp(buf, "skiplist")) {
249 if (equal == len)
250 die("skiplist requires a path");
24eb33eb 251 oidset_parse_file(&options->skiplist, buf + equal + 1);
cd94c6f9
JS
252 buf += len + 1;
253 continue;
254 }
255
0282f4dc
JS
256 if (equal == len)
257 die("Missing '=': '%s'", buf);
355885d5 258
0282f4dc
JS
259 fsck_set_msg_type(options, buf, buf + equal + 1);
260 buf += len + 1;
261 }
262 free(to_free);
263}
264
71ab8fa8
JS
265static void append_msg_id(struct strbuf *sb, const char *msg_id)
266{
267 for (;;) {
268 char c = *(msg_id)++;
269
270 if (!c)
271 break;
272 if (c != '_')
273 strbuf_addch(sb, tolower(c));
274 else {
275 assert(*msg_id);
276 strbuf_addch(sb, *(msg_id)++);
277 }
278 }
279
280 strbuf_addstr(sb, ": ");
281}
282
f5979376
JK
283static int object_on_skiplist(struct fsck_options *opts,
284 const struct object_id *oid)
fb162877 285{
f5979376 286 return opts && oid && oidset_contains(&opts->skiplist, oid);
fb162877
RJ
287}
288
38370253
JK
289__attribute__((format (printf, 5, 6)))
290static int report(struct fsck_options *options,
291 const struct object_id *oid, enum object_type object_type,
292 enum fsck_msg_id id, const char *fmt, ...)
c99ba492
JS
293{
294 va_list ap;
295 struct strbuf sb = STRBUF_INIT;
296 int msg_type = fsck_msg_type(id, options), result;
297
efaba7cc
JS
298 if (msg_type == FSCK_IGNORE)
299 return 0;
300
38370253 301 if (object_on_skiplist(options, oid))
cd94c6f9
JS
302 return 0;
303
f50c4407
JS
304 if (msg_type == FSCK_FATAL)
305 msg_type = FSCK_ERROR;
f27d05b1
JS
306 else if (msg_type == FSCK_INFO)
307 msg_type = FSCK_WARN;
f50c4407 308
71ab8fa8
JS
309 append_msg_id(&sb, msg_id_info[id].id_string);
310
c99ba492
JS
311 va_start(ap, fmt);
312 strbuf_vaddf(&sb, fmt, ap);
38370253 313 result = options->error_func(options, oid, object_type,
5afc4b1d 314 msg_type, sb.buf);
c99ba492
JS
315 strbuf_release(&sb);
316 va_end(ap);
317
318 return result;
319}
320
a59cfb32
JK
321void fsck_enable_object_names(struct fsck_options *options)
322{
323 if (!options->object_names)
73390290 324 options->object_names = kh_init_oid_map();
a59cfb32
JK
325}
326
73390290
JK
327const char *fsck_get_object_name(struct fsck_options *options,
328 const struct object_id *oid)
7b35efd7 329{
73390290 330 khiter_t pos;
7b35efd7
JS
331 if (!options->object_names)
332 return NULL;
73390290
JK
333 pos = kh_get_oid_map(options->object_names, *oid);
334 if (pos >= kh_end(options->object_names))
335 return NULL;
336 return kh_value(options->object_names, pos);
7b35efd7
JS
337}
338
73390290
JK
339void fsck_put_object_name(struct fsck_options *options,
340 const struct object_id *oid,
a59cfb32 341 const char *fmt, ...)
7b35efd7
JS
342{
343 va_list ap;
344 struct strbuf buf = STRBUF_INIT;
73390290
JK
345 khiter_t pos;
346 int hashret;
7b35efd7
JS
347
348 if (!options->object_names)
349 return;
73390290
JK
350
351 pos = kh_put_oid_map(options->object_names, *oid, &hashret);
352 if (!hashret)
7b35efd7
JS
353 return;
354 va_start(ap, fmt);
355 strbuf_vaddf(&buf, fmt, ap);
73390290 356 kh_value(options->object_names, pos) = strbuf_detach(&buf, NULL);
7b35efd7
JS
357 va_end(ap);
358}
359
a59cfb32 360const char *fsck_describe_object(struct fsck_options *options,
73390290 361 const struct object_id *oid)
90cf590f 362{
a59cfb32
JK
363 static struct strbuf bufs[] = {
364 STRBUF_INIT, STRBUF_INIT, STRBUF_INIT, STRBUF_INIT
365 };
366 static int b = 0;
367 struct strbuf *buf;
73390290 368 const char *name = fsck_get_object_name(options, oid);
a59cfb32
JK
369
370 buf = bufs + b;
371 b = (b + 1) % ARRAY_SIZE(bufs);
372 strbuf_reset(buf);
73390290 373 strbuf_addstr(buf, oid_to_hex(oid));
a59cfb32
JK
374 if (name)
375 strbuf_addf(buf, " (%s)", name);
90cf590f 376
a59cfb32 377 return buf->buf;
90cf590f
JS
378}
379
22410549 380static int fsck_walk_tree(struct tree *tree, void *data, struct fsck_options *options)
355885d5
MK
381{
382 struct tree_desc desc;
383 struct name_entry entry;
384 int res = 0;
7b35efd7 385 const char *name;
355885d5
MK
386
387 if (parse_tree(tree))
388 return -1;
389
73390290 390 name = fsck_get_object_name(options, &tree->object.oid);
8354fa3d
DT
391 if (init_tree_desc_gently(&desc, tree->buffer, tree->size))
392 return -1;
393 while (tree_entry_gently(&desc, &entry)) {
7b35efd7 394 struct object *obj;
355885d5
MK
395 int result;
396
397 if (S_ISGITLINK(entry.mode))
398 continue;
7b35efd7
JS
399
400 if (S_ISDIR(entry.mode)) {
ea82b2a0 401 obj = (struct object *)lookup_tree(the_repository, &entry.oid);
2720f6db 402 if (name && obj)
73390290 403 fsck_put_object_name(options, &entry.oid, "%s%s/",
a59cfb32 404 name, entry.path);
7b35efd7
JS
405 result = options->walk(obj, OBJ_TREE, data, options);
406 }
407 else if (S_ISREG(entry.mode) || S_ISLNK(entry.mode)) {
ea82b2a0 408 obj = (struct object *)lookup_blob(the_repository, &entry.oid);
2720f6db 409 if (name && obj)
73390290 410 fsck_put_object_name(options, &entry.oid, "%s%s",
a59cfb32 411 name, entry.path);
7b35efd7
JS
412 result = options->walk(obj, OBJ_BLOB, data, options);
413 }
355885d5 414 else {
82247e9b 415 result = error("in tree %s: entry %s has bad mode %.6o",
73390290 416 fsck_describe_object(options, &tree->object.oid),
a59cfb32 417 entry.path, entry.mode);
355885d5
MK
418 }
419 if (result < 0)
420 return result;
421 if (!res)
422 res = result;
423 }
424 return res;
425}
426
22410549 427static int fsck_walk_commit(struct commit *commit, void *data, struct fsck_options *options)
355885d5 428{
7b35efd7 429 int counter = 0, generation = 0, name_prefix_len = 0;
355885d5
MK
430 struct commit_list *parents;
431 int res;
432 int result;
7b35efd7 433 const char *name;
355885d5
MK
434
435 if (parse_commit(commit))
436 return -1;
437
73390290 438 name = fsck_get_object_name(options, &commit->object.oid);
7b35efd7 439 if (name)
73390290 440 fsck_put_object_name(options, get_commit_tree_oid(commit),
a59cfb32 441 "%s:", name);
7b35efd7 442
2e27bd77
DS
443 result = options->walk((struct object *)get_commit_tree(commit),
444 OBJ_TREE, data, options);
355885d5
MK
445 if (result < 0)
446 return result;
447 res = result;
448
449 parents = commit->parents;
7b35efd7
JS
450 if (name && parents) {
451 int len = strlen(name), power;
452
453 if (len && name[len - 1] == '^') {
454 generation = 1;
455 name_prefix_len = len - 1;
456 }
457 else { /* parse ~<generation> suffix */
458 for (generation = 0, power = 1;
459 len && isdigit(name[len - 1]);
460 power *= 10)
461 generation += power * (name[--len] - '0');
462 if (power > 1 && len && name[len - 1] == '~')
463 name_prefix_len = len - 1;
464 }
465 }
466
355885d5 467 while (parents) {
7b35efd7 468 if (name) {
73390290 469 struct object_id *oid = &parents->item->object.oid;
7b35efd7 470
b84c7838 471 if (counter++)
73390290 472 fsck_put_object_name(options, oid, "%s^%d",
a59cfb32 473 name, counter);
7b35efd7 474 else if (generation > 0)
73390290 475 fsck_put_object_name(options, oid, "%.*s~%d",
a59cfb32
JK
476 name_prefix_len, name,
477 generation + 1);
7b35efd7 478 else
73390290 479 fsck_put_object_name(options, oid, "%s^", name);
7b35efd7 480 }
22410549 481 result = options->walk((struct object *)parents->item, OBJ_COMMIT, data, options);
355885d5
MK
482 if (result < 0)
483 return result;
484 if (!res)
485 res = result;
486 parents = parents->next;
487 }
488 return res;
489}
490
22410549 491static int fsck_walk_tag(struct tag *tag, void *data, struct fsck_options *options)
355885d5 492{
73390290 493 const char *name = fsck_get_object_name(options, &tag->object.oid);
7b35efd7 494
355885d5
MK
495 if (parse_tag(tag))
496 return -1;
7b35efd7 497 if (name)
73390290 498 fsck_put_object_name(options, &tag->tagged->oid, "%s", name);
22410549 499 return options->walk(tag->tagged, OBJ_ANY, data, options);
355885d5
MK
500}
501
22410549 502int fsck_walk(struct object *obj, void *data, struct fsck_options *options)
355885d5
MK
503{
504 if (!obj)
505 return -1;
a2b22854
JK
506
507 if (obj->type == OBJ_NONE)
109cd76d 508 parse_object(the_repository, &obj->oid);
a2b22854 509
355885d5
MK
510 switch (obj->type) {
511 case OBJ_BLOB:
512 return 0;
513 case OBJ_TREE:
22410549 514 return fsck_walk_tree((struct tree *)obj, data, options);
355885d5 515 case OBJ_COMMIT:
22410549 516 return fsck_walk_commit((struct commit *)obj, data, options);
355885d5 517 case OBJ_TAG:
22410549 518 return fsck_walk_tag((struct tag *)obj, data, options);
355885d5 519 default:
a59cfb32 520 error("Unknown object type for %s",
73390290 521 fsck_describe_object(options, &obj->oid));
355885d5
MK
522 return -1;
523 }
524}
ba002f3b 525
9068cfb2
RS
526struct name_stack {
527 const char **names;
528 size_t nr, alloc;
529};
530
531static void name_stack_push(struct name_stack *stack, const char *name)
532{
533 ALLOC_GROW(stack->names, stack->nr + 1, stack->alloc);
534 stack->names[stack->nr++] = name;
535}
536
537static const char *name_stack_pop(struct name_stack *stack)
538{
539 return stack->nr ? stack->names[--stack->nr] : NULL;
540}
541
542static void name_stack_clear(struct name_stack *stack)
543{
544 FREE_AND_NULL(stack->names);
545 stack->nr = stack->alloc = 0;
546}
547
ba002f3b
MK
548/*
549 * The entries in a tree are ordered in the _path_ order,
550 * which means that a directory entry is ordered by adding
551 * a slash to the end of it.
552 *
553 * So a directory called "a" is ordered _after_ a file
554 * called "a.c", because "a/" sorts after "a.c".
555 */
556#define TREE_UNORDERED (-1)
557#define TREE_HAS_DUPS (-2)
558
9068cfb2
RS
559static int is_less_than_slash(unsigned char c)
560{
561 return '\0' < c && c < '/';
562}
563
564static int verify_ordered(unsigned mode1, const char *name1,
565 unsigned mode2, const char *name2,
566 struct name_stack *candidates)
ba002f3b
MK
567{
568 int len1 = strlen(name1);
569 int len2 = strlen(name2);
570 int len = len1 < len2 ? len1 : len2;
571 unsigned char c1, c2;
572 int cmp;
573
574 cmp = memcmp(name1, name2, len);
575 if (cmp < 0)
576 return 0;
577 if (cmp > 0)
578 return TREE_UNORDERED;
579
580 /*
581 * Ok, the first <len> characters are the same.
582 * Now we need to order the next one, but turn
583 * a '\0' into a '/' for a directory entry.
584 */
585 c1 = name1[len];
586 c2 = name2[len];
587 if (!c1 && !c2)
588 /*
589 * git-write-tree used to write out a nonsense tree that has
590 * entries with the same name, one blob and one tree. Make
591 * sure we do not have duplicate entries.
592 */
593 return TREE_HAS_DUPS;
594 if (!c1 && S_ISDIR(mode1))
595 c1 = '/';
596 if (!c2 && S_ISDIR(mode2))
597 c2 = '/';
9068cfb2
RS
598
599 /*
600 * There can be non-consecutive duplicates due to the implicitly
601 * add slash, e.g.:
602 *
603 * foo
604 * foo.bar
605 * foo.bar.baz
606 * foo.bar/
607 * foo/
608 *
609 * Record non-directory candidates (like "foo" and "foo.bar" in
610 * the example) on a stack and check directory candidates (like
611 * foo/" and "foo.bar/") against that stack.
612 */
613 if (!c1 && is_less_than_slash(c2)) {
614 name_stack_push(candidates, name1);
615 } else if (c2 == '/' && is_less_than_slash(c1)) {
616 for (;;) {
617 const char *p;
618 const char *f_name = name_stack_pop(candidates);
619
620 if (!f_name)
621 break;
622 if (!skip_prefix(name2, f_name, &p))
623 break;
624 if (!*p)
625 return TREE_HAS_DUPS;
626 if (is_less_than_slash(*p)) {
627 name_stack_push(candidates, f_name);
628 break;
629 }
630 }
631 }
632
ba002f3b
MK
633 return c1 < c2 ? 0 : TREE_UNORDERED;
634}
635
b2f2039c 636static int fsck_tree(const struct object_id *oid,
23a173a7
JK
637 const char *buffer, unsigned long size,
638 struct fsck_options *options)
ba002f3b 639{
8354fa3d 640 int retval = 0;
c479d14a 641 int has_null_sha1 = 0;
ba002f3b
MK
642 int has_full_path = 0;
643 int has_empty_name = 0;
5d34a435
JK
644 int has_dot = 0;
645 int has_dotdot = 0;
5c17f512 646 int has_dotgit = 0;
ba002f3b
MK
647 int has_zero_pad = 0;
648 int has_bad_modes = 0;
649 int has_dup_entries = 0;
650 int not_properly_sorted = 0;
651 struct tree_desc desc;
652 unsigned o_mode;
653 const char *o_name;
9068cfb2 654 struct name_stack df_dup_candidates = { NULL };
ba002f3b 655
23a173a7 656 if (init_tree_desc_gently(&desc, buffer, size)) {
b2f2039c 657 retval += report(options, oid, OBJ_TREE, FSCK_MSG_BAD_TREE, "cannot be parsed as a tree");
8354fa3d
DT
658 return retval;
659 }
ba002f3b
MK
660
661 o_mode = 0;
662 o_name = NULL;
ba002f3b
MK
663
664 while (desc.size) {
5ec1e728 665 unsigned short mode;
288a74bc 666 const char *name, *backslash;
ce6663a9 667 const struct object_id *oid;
ba002f3b 668
ce6663a9 669 oid = tree_entry_extract(&desc, &name, &mode);
ba002f3b 670
ce6663a9 671 has_null_sha1 |= is_null_oid(oid);
effd12ec
HS
672 has_full_path |= !!strchr(name, '/');
673 has_empty_name |= !*name;
674 has_dot |= !strcmp(name, ".");
675 has_dotdot |= !strcmp(name, "..");
ed9c3220 676 has_dotgit |= is_hfs_dotgit(name) || is_ntfs_dotgit(name);
ba002f3b 677 has_zero_pad |= *(char *)desc.buffer == '0';
159e7b08 678
b7b1fca1
JK
679 if (is_hfs_dotgitmodules(name) || is_ntfs_dotgitmodules(name)) {
680 if (!S_ISLNK(mode))
681 oidset_insert(&gitmodules_found, oid);
682 else
38370253 683 retval += report(options,
b2f2039c 684 oid, OBJ_TREE,
b7b1fca1
JK
685 FSCK_MSG_GITMODULES_SYMLINK,
686 ".gitmodules is a symbolic link");
687 }
159e7b08 688
288a74bc
JS
689 if ((backslash = strchr(name, '\\'))) {
690 while (backslash) {
691 backslash++;
692 has_dotgit |= is_ntfs_dotgit(backslash);
bdfef049
JS
693 if (is_ntfs_dotgitmodules(backslash)) {
694 if (!S_ISLNK(mode))
695 oidset_insert(&gitmodules_found, oid);
696 else
7034cd09 697 retval += report(options, oid, OBJ_TREE,
bdfef049
JS
698 FSCK_MSG_GITMODULES_SYMLINK,
699 ".gitmodules is a symbolic link");
700 }
288a74bc
JS
701 backslash = strchr(backslash, '\\');
702 }
703 }
704
8354fa3d 705 if (update_tree_entry_gently(&desc)) {
b2f2039c 706 retval += report(options, oid, OBJ_TREE, FSCK_MSG_BAD_TREE, "cannot be parsed as a tree");
8354fa3d
DT
707 break;
708 }
ba002f3b
MK
709
710 switch (mode) {
711 /*
712 * Standard modes..
713 */
714 case S_IFREG | 0755:
715 case S_IFREG | 0644:
716 case S_IFLNK:
717 case S_IFDIR:
718 case S_IFGITLINK:
719 break;
720 /*
721 * This is nonstandard, but we had a few of these
722 * early on when we honored the full set of mode
723 * bits..
724 */
725 case S_IFREG | 0664:
22410549 726 if (!options->strict)
ba002f3b 727 break;
1cf01a34 728 /* fallthrough */
ba002f3b
MK
729 default:
730 has_bad_modes = 1;
731 }
732
733 if (o_name) {
9068cfb2
RS
734 switch (verify_ordered(o_mode, o_name, mode, name,
735 &df_dup_candidates)) {
ba002f3b
MK
736 case TREE_UNORDERED:
737 not_properly_sorted = 1;
738 break;
739 case TREE_HAS_DUPS:
740 has_dup_entries = 1;
741 break;
742 default:
743 break;
744 }
745 }
746
747 o_mode = mode;
748 o_name = name;
ba002f3b
MK
749 }
750
9068cfb2
RS
751 name_stack_clear(&df_dup_candidates);
752
c479d14a 753 if (has_null_sha1)
b2f2039c 754 retval += report(options, oid, OBJ_TREE, FSCK_MSG_NULL_SHA1, "contains entries pointing to null sha1");
ba002f3b 755 if (has_full_path)
b2f2039c 756 retval += report(options, oid, OBJ_TREE, FSCK_MSG_FULL_PATHNAME, "contains full pathnames");
ba002f3b 757 if (has_empty_name)
b2f2039c 758 retval += report(options, oid, OBJ_TREE, FSCK_MSG_EMPTY_NAME, "contains empty pathname");
5d34a435 759 if (has_dot)
b2f2039c 760 retval += report(options, oid, OBJ_TREE, FSCK_MSG_HAS_DOT, "contains '.'");
5d34a435 761 if (has_dotdot)
b2f2039c 762 retval += report(options, oid, OBJ_TREE, FSCK_MSG_HAS_DOTDOT, "contains '..'");
5c17f512 763 if (has_dotgit)
b2f2039c 764 retval += report(options, oid, OBJ_TREE, FSCK_MSG_HAS_DOTGIT, "contains '.git'");
ba002f3b 765 if (has_zero_pad)
b2f2039c 766 retval += report(options, oid, OBJ_TREE, FSCK_MSG_ZERO_PADDED_FILEMODE, "contains zero-padded file modes");
ba002f3b 767 if (has_bad_modes)
b2f2039c 768 retval += report(options, oid, OBJ_TREE, FSCK_MSG_BAD_FILEMODE, "contains bad file modes");
ba002f3b 769 if (has_dup_entries)
b2f2039c 770 retval += report(options, oid, OBJ_TREE, FSCK_MSG_DUPLICATE_ENTRIES, "contains duplicate file entries");
ba002f3b 771 if (not_properly_sorted)
b2f2039c 772 retval += report(options, oid, OBJ_TREE, FSCK_MSG_TREE_NOT_SORTED, "not properly sorted");
ba002f3b
MK
773 return retval;
774}
775
84d18c0b 776static int verify_headers(const void *data, unsigned long size,
cc579000
JK
777 const struct object_id *oid, enum object_type type,
778 struct fsck_options *options)
4d0d8975
JS
779{
780 const char *buffer = (const char *)data;
781 unsigned long i;
782
783 for (i = 0; i < size; i++) {
784 switch (buffer[i]) {
785 case '\0':
cc579000 786 return report(options, oid, type,
c99ba492
JS
787 FSCK_MSG_NUL_IN_HEADER,
788 "unterminated header: NUL at offset %ld", i);
4d0d8975
JS
789 case '\n':
790 if (i + 1 < size && buffer[i + 1] == '\n')
791 return 0;
792 }
793 }
794
84d18c0b
JH
795 /*
796 * We did not find double-LF that separates the header
797 * and the body. Not having a body is not a crime but
798 * we do want to see the terminating LF for the last header
799 * line.
800 */
801 if (size && buffer[size - 1] == '\n')
802 return 0;
803
cc579000 804 return report(options, oid, type,
c99ba492 805 FSCK_MSG_UNTERMINATED_HEADER, "unterminated header");
4d0d8975
JS
806}
807
78543993
JK
808static int fsck_ident(const char **ident,
809 const struct object_id *oid, enum object_type type,
810 struct fsck_options *options)
daae1922 811{
e6826e33 812 const char *p = *ident;
d4b8de04
JK
813 char *end;
814
e6826e33
JS
815 *ident = strchrnul(*ident, '\n');
816 if (**ident == '\n')
817 (*ident)++;
818
819 if (*p == '<')
78543993 820 return report(options, oid, type, FSCK_MSG_MISSING_NAME_BEFORE_EMAIL, "invalid author/committer line - missing space before email");
e6826e33
JS
821 p += strcspn(p, "<>\n");
822 if (*p == '>')
78543993 823 return report(options, oid, type, FSCK_MSG_BAD_NAME, "invalid author/committer line - bad name");
e6826e33 824 if (*p != '<')
78543993 825 return report(options, oid, type, FSCK_MSG_MISSING_EMAIL, "invalid author/committer line - missing email");
e6826e33 826 if (p[-1] != ' ')
78543993 827 return report(options, oid, type, FSCK_MSG_MISSING_SPACE_BEFORE_EMAIL, "invalid author/committer line - missing space before email");
e6826e33
JS
828 p++;
829 p += strcspn(p, "<>\n");
830 if (*p != '>')
78543993 831 return report(options, oid, type, FSCK_MSG_BAD_EMAIL, "invalid author/committer line - bad email");
e6826e33
JS
832 p++;
833 if (*p != ' ')
78543993 834 return report(options, oid, type, FSCK_MSG_MISSING_SPACE_BEFORE_DATE, "invalid author/committer line - missing space before date");
e6826e33
JS
835 p++;
836 if (*p == '0' && p[1] != ' ')
78543993 837 return report(options, oid, type, FSCK_MSG_ZERO_PADDED_DATE, "invalid author/committer line - zero-padded date");
1aeb7e75 838 if (date_overflows(parse_timestamp(p, &end, 10)))
78543993 839 return report(options, oid, type, FSCK_MSG_BAD_DATE_OVERFLOW, "invalid author/committer line - date causes integer overflow");
e6826e33 840 if ((end == p || *end != ' '))
78543993 841 return report(options, oid, type, FSCK_MSG_BAD_DATE, "invalid author/committer line - bad date");
e6826e33
JS
842 p = end + 1;
843 if ((*p != '+' && *p != '-') ||
844 !isdigit(p[1]) ||
845 !isdigit(p[2]) ||
846 !isdigit(p[3]) ||
847 !isdigit(p[4]) ||
848 (p[5] != '\n'))
78543993 849 return report(options, oid, type, FSCK_MSG_BAD_TIMEZONE, "invalid author/committer line - bad time zone");
e6826e33 850 p += 6;
daae1922
JN
851 return 0;
852}
853
c5b4269b
JK
854static int fsck_commit(const struct object_id *oid,
855 const char *buffer, unsigned long size,
856 struct fsck_options *options)
ba002f3b 857{
f648ee70 858 struct object_id tree_oid, parent_oid;
ec652315 859 unsigned author_count;
daae1922 860 int err;
6d2d780f 861 const char *buffer_begin = buffer;
c54f5ca9 862 const char *p;
ba002f3b 863
c5b4269b 864 if (verify_headers(buffer, size, oid, OBJ_COMMIT, options))
4d0d8975
JS
865 return -1;
866
cf4fff57 867 if (!skip_prefix(buffer, "tree ", &buffer))
c5b4269b 868 return report(options, oid, OBJ_COMMIT, FSCK_MSG_MISSING_TREE, "invalid format - expected 'tree' line");
c54f5ca9 869 if (parse_oid_hex(buffer, &tree_oid, &p) || *p != '\n') {
c5b4269b 870 err = report(options, oid, OBJ_COMMIT, FSCK_MSG_BAD_TREE_SHA1, "invalid 'tree' line format - bad sha1");
b3584761
JS
871 if (err)
872 return err;
873 }
c54f5ca9 874 buffer = p + 1;
cf4fff57 875 while (skip_prefix(buffer, "parent ", &buffer)) {
f648ee70 876 if (parse_oid_hex(buffer, &parent_oid, &p) || *p != '\n') {
c5b4269b 877 err = report(options, oid, OBJ_COMMIT, FSCK_MSG_BAD_PARENT_SHA1, "invalid 'parent' line format - bad sha1");
b3584761
JS
878 if (err)
879 return err;
880 }
c54f5ca9 881 buffer = p + 1;
ba002f3b 882 }
c9ad147f
JS
883 author_count = 0;
884 while (skip_prefix(buffer, "author ", &buffer)) {
885 author_count++;
c5b4269b 886 err = fsck_ident(&buffer, oid, OBJ_COMMIT, options);
c9ad147f
JS
887 if (err)
888 return err;
ba002f3b 889 }
c9ad147f 890 if (author_count < 1)
c5b4269b 891 err = report(options, oid, OBJ_COMMIT, FSCK_MSG_MISSING_AUTHOR, "invalid format - expected 'author' line");
c9ad147f 892 else if (author_count > 1)
c5b4269b 893 err = report(options, oid, OBJ_COMMIT, FSCK_MSG_MULTIPLE_AUTHORS, "invalid format - multiple 'author' lines");
daae1922
JN
894 if (err)
895 return err;
cf4fff57 896 if (!skip_prefix(buffer, "committer ", &buffer))
c5b4269b
JK
897 return report(options, oid, OBJ_COMMIT, FSCK_MSG_MISSING_COMMITTER, "invalid format - expected 'committer' line");
898 err = fsck_ident(&buffer, oid, OBJ_COMMIT, options);
daae1922
JN
899 if (err)
900 return err;
6d2d780f 901 if (memchr(buffer_begin, '\0', size)) {
c5b4269b 902 err = report(options, oid, OBJ_COMMIT, FSCK_MSG_NUL_IN_COMMIT,
6d2d780f
JH
903 "NUL byte in the commit object body");
904 if (err)
905 return err;
906 }
ba002f3b
MK
907 return 0;
908}
909
103fb6d4 910static int fsck_tag(const struct object_id *oid, const char *buffer,
2175a0c6 911 unsigned long size, struct fsck_options *options)
cec097be 912{
f648ee70 913 struct object_id tagged_oid;
cec097be 914 int ret = 0;
23a173a7 915 char *eol;
cec097be 916 struct strbuf sb = STRBUF_INIT;
c54f5ca9 917 const char *p;
cec097be 918
103fb6d4 919 ret = verify_headers(buffer, size, oid, OBJ_TAG, options);
8a272f29 920 if (ret)
cec097be
JS
921 goto done;
922
923 if (!skip_prefix(buffer, "object ", &buffer)) {
103fb6d4 924 ret = report(options, oid, OBJ_TAG, FSCK_MSG_MISSING_OBJECT, "invalid format - expected 'object' line");
cec097be
JS
925 goto done;
926 }
f648ee70 927 if (parse_oid_hex(buffer, &tagged_oid, &p) || *p != '\n') {
103fb6d4 928 ret = report(options, oid, OBJ_TAG, FSCK_MSG_BAD_OBJECT_SHA1, "invalid 'object' line format - bad sha1");
7d7d5b05
JS
929 if (ret)
930 goto done;
cec097be 931 }
c54f5ca9 932 buffer = p + 1;
cec097be
JS
933
934 if (!skip_prefix(buffer, "type ", &buffer)) {
103fb6d4 935 ret = report(options, oid, OBJ_TAG, FSCK_MSG_MISSING_TYPE_ENTRY, "invalid format - expected 'type' line");
cec097be
JS
936 goto done;
937 }
938 eol = strchr(buffer, '\n');
939 if (!eol) {
103fb6d4 940 ret = report(options, oid, OBJ_TAG, FSCK_MSG_MISSING_TYPE, "invalid format - unexpected end after 'type' line");
cec097be
JS
941 goto done;
942 }
943 if (type_from_string_gently(buffer, eol - buffer, 1) < 0)
103fb6d4 944 ret = report(options, oid, OBJ_TAG, FSCK_MSG_BAD_TYPE, "invalid 'type' value");
cec097be
JS
945 if (ret)
946 goto done;
947 buffer = eol + 1;
948
949 if (!skip_prefix(buffer, "tag ", &buffer)) {
103fb6d4 950 ret = report(options, oid, OBJ_TAG, FSCK_MSG_MISSING_TAG_ENTRY, "invalid format - expected 'tag' line");
cec097be
JS
951 goto done;
952 }
953 eol = strchr(buffer, '\n');
954 if (!eol) {
103fb6d4 955 ret = report(options, oid, OBJ_TAG, FSCK_MSG_MISSING_TAG, "invalid format - unexpected end after 'type' line");
cec097be
JS
956 goto done;
957 }
958 strbuf_addf(&sb, "refs/tags/%.*s", (int)(eol - buffer), buffer);
f27d05b1 959 if (check_refname_format(sb.buf, 0)) {
103fb6d4 960 ret = report(options, oid, OBJ_TAG,
38370253
JK
961 FSCK_MSG_BAD_TAG_NAME,
962 "invalid 'tag' name: %.*s",
963 (int)(eol - buffer), buffer);
f27d05b1
JS
964 if (ret)
965 goto done;
966 }
cec097be
JS
967 buffer = eol + 1;
968
f27d05b1 969 if (!skip_prefix(buffer, "tagger ", &buffer)) {
cec097be 970 /* early tags do not contain 'tagger' lines; warn only */
103fb6d4 971 ret = report(options, oid, OBJ_TAG, FSCK_MSG_MISSING_TAGGER_ENTRY, "invalid format - expected 'tagger' line");
f27d05b1
JS
972 if (ret)
973 goto done;
974 }
cec097be 975 else
103fb6d4 976 ret = fsck_ident(&buffer, oid, OBJ_TAG, options);
cec097be
JS
977
978done:
979 strbuf_release(&sb);
cec097be
JS
980 return ret;
981}
982
a2b26ffb
JN
983/*
984 * Like builtin/submodule--helper.c's starts_with_dot_slash, but without
985 * relying on the platform-dependent is_dir_sep helper.
986 *
987 * This is for use in checking whether a submodule URL is interpreted as
988 * relative to the current directory on any platform, since \ is a
989 * directory separator on Windows but not on other platforms.
990 */
991static int starts_with_dot_slash(const char *str)
992{
993 return str[0] == '.' && (str[1] == '/' || str[1] == '\\');
994}
995
996/*
997 * Like starts_with_dot_slash, this is a variant of submodule--helper's
998 * helper of the same name with the twist that it accepts backslash as a
999 * directory separator even on non-Windows platforms.
1000 */
1001static int starts_with_dot_dot_slash(const char *str)
1002{
1003 return str[0] == '.' && starts_with_dot_slash(str + 1);
1004}
1005
1006static int submodule_url_is_relative(const char *url)
1007{
1008 return starts_with_dot_slash(url) || starts_with_dot_dot_slash(url);
1009}
1010
c44088ec
JN
1011/*
1012 * Count directory components that a relative submodule URL should chop
1013 * from the remote_url it is to be resolved against.
1014 *
1015 * In other words, this counts "../" components at the start of a
1016 * submodule URL.
1017 *
1018 * Returns the number of directory components to chop and writes a
1019 * pointer to the next character of url after all leading "./" and
1020 * "../" components to out.
1021 */
1022static int count_leading_dotdots(const char *url, const char **out)
1023{
1024 int result = 0;
1025 while (1) {
1026 if (starts_with_dot_dot_slash(url)) {
1027 result++;
1028 url += strlen("../");
1029 continue;
1030 }
1031 if (starts_with_dot_slash(url)) {
1032 url += strlen("./");
1033 continue;
1034 }
1035 *out = url;
1036 return result;
1037 }
1038}
a2b26ffb
JN
1039/*
1040 * Check whether a transport is implemented by git-remote-curl.
1041 *
1042 * If it is, returns 1 and writes the URL that would be passed to
1043 * git-remote-curl to the "out" parameter.
1044 *
1045 * Otherwise, returns 0 and leaves "out" untouched.
1046 *
1047 * Examples:
1048 * http::https://example.com/repo.git -> 1, https://example.com/repo.git
1049 * https://example.com/repo.git -> 1, https://example.com/repo.git
1050 * git://example.com/repo.git -> 0
1051 *
1052 * This is for use in checking for previously exploitable bugs that
1053 * required a submodule URL to be passed to git-remote-curl.
1054 */
1055static int url_to_curl_url(const char *url, const char **out)
1056{
1057 /*
1058 * We don't need to check for case-aliases, "http.exe", and so
1059 * on because in the default configuration, is_transport_allowed
1060 * prevents URLs with those schemes from being cloned
1061 * automatically.
1062 */
1063 if (skip_prefix(url, "http::", out) ||
1064 skip_prefix(url, "https::", out) ||
1065 skip_prefix(url, "ftp::", out) ||
1066 skip_prefix(url, "ftps::", out))
1067 return 1;
1068 if (starts_with(url, "http://") ||
1069 starts_with(url, "https://") ||
1070 starts_with(url, "ftp://") ||
1071 starts_with(url, "ftps://")) {
1072 *out = url;
1073 return 1;
1074 }
1075 return 0;
1076}
1077
07259e74
JK
1078static int check_submodule_url(const char *url)
1079{
a2b26ffb 1080 const char *curl_url;
07259e74
JK
1081
1082 if (looks_like_command_line_option(url))
1083 return -1;
1084
a2b26ffb 1085 if (submodule_url_is_relative(url)) {
c44088ec
JN
1086 char *decoded;
1087 const char *next;
1088 int has_nl;
1089
a2b26ffb
JN
1090 /*
1091 * This could be appended to an http URL and url-decoded;
1092 * check for malicious characters.
1093 */
c44088ec
JN
1094 decoded = url_decode(url);
1095 has_nl = !!strchr(decoded, '\n');
1096
a2b26ffb
JN
1097 free(decoded);
1098 if (has_nl)
1099 return -1;
c44088ec
JN
1100
1101 /*
1102 * URLs which escape their root via "../" can overwrite
1103 * the host field and previous components, resolving to
1a3609e4
JN
1104 * URLs like https::example.com/submodule.git and
1105 * https:///example.com/submodule.git that were
c44088ec
JN
1106 * susceptible to CVE-2020-11008.
1107 */
1108 if (count_leading_dotdots(url, &next) > 0 &&
1a3609e4 1109 (*next == ':' || *next == '/'))
c44088ec 1110 return -1;
a2b26ffb
JN
1111 }
1112
1113 else if (url_to_curl_url(url, &curl_url)) {
1114 struct credential c = CREDENTIAL_INIT;
1a3609e4
JN
1115 int ret = 0;
1116 if (credential_from_url_gently(&c, curl_url, 1) ||
1117 !*c.host)
1118 ret = -1;
a2b26ffb
JN
1119 credential_clear(&c);
1120 return ret;
1121 }
1122
1123 return 0;
07259e74
JK
1124}
1125
ed8b10f6 1126struct fsck_gitmodules_data {
6da40b22 1127 const struct object_id *oid;
ed8b10f6
JK
1128 struct fsck_options *options;
1129 int ret;
1130};
1131
1132static int fsck_gitmodules_fn(const char *var, const char *value, void *vdata)
1133{
1134 struct fsck_gitmodules_data *data = vdata;
1135 const char *subsection, *key;
1136 int subsection_len;
1137 char *name;
1138
1139 if (parse_config_key(var, "submodule", &subsection, &subsection_len, &key) < 0 ||
1140 !subsection)
1141 return 0;
1142
1143 name = xmemdupz(subsection, subsection_len);
1144 if (check_submodule_name(name) < 0)
38370253 1145 data->ret |= report(data->options,
6da40b22 1146 data->oid, OBJ_BLOB,
ed8b10f6
JK
1147 FSCK_MSG_GITMODULES_NAME,
1148 "disallowed submodule name: %s",
1149 name);
a124133e 1150 if (!strcmp(key, "url") && value &&
07259e74 1151 check_submodule_url(value) < 0)
38370253 1152 data->ret |= report(data->options,
6da40b22 1153 data->oid, OBJ_BLOB,
a124133e
JK
1154 FSCK_MSG_GITMODULES_URL,
1155 "disallowed submodule url: %s",
1156 value);
1a7fd1fb
JK
1157 if (!strcmp(key, "path") && value &&
1158 looks_like_command_line_option(value))
38370253 1159 data->ret |= report(data->options,
6da40b22 1160 data->oid, OBJ_BLOB,
1a7fd1fb
JK
1161 FSCK_MSG_GITMODULES_PATH,
1162 "disallowed submodule path: %s",
1163 value);
bb92255e
JN
1164 if (!strcmp(key, "update") && value &&
1165 parse_submodule_update_type(value) == SM_UPDATE_COMMAND)
7034cd09 1166 data->ret |= report(data->options, data->oid, OBJ_BLOB,
bb92255e
JN
1167 FSCK_MSG_GITMODULES_UPDATE,
1168 "disallowed submodule update setting: %s",
1169 value);
ed8b10f6
JK
1170 free(name);
1171
1172 return 0;
1173}
1174
6da40b22 1175static int fsck_blob(const struct object_id *oid, const char *buf,
7ac4f3a0
JK
1176 unsigned long size, struct fsck_options *options)
1177{
ed8b10f6 1178 struct fsck_gitmodules_data data;
de6bd9e3 1179 struct config_options config_opts = { 0 };
ed8b10f6 1180
6da40b22 1181 if (!oidset_contains(&gitmodules_found, oid))
ed8b10f6 1182 return 0;
6da40b22 1183 oidset_insert(&gitmodules_done, oid);
ed8b10f6 1184
6da40b22 1185 if (object_on_skiplist(options, oid))
fb162877
RJ
1186 return 0;
1187
ed8b10f6
JK
1188 if (!buf) {
1189 /*
1190 * A missing buffer here is a sign that the caller found the
1191 * blob too gigantic to load into memory. Let's just consider
1192 * that an error.
1193 */
6da40b22 1194 return report(options, oid, OBJ_BLOB,
0d68764d 1195 FSCK_MSG_GITMODULES_LARGE,
ed8b10f6
JK
1196 ".gitmodules too large to parse");
1197 }
1198
6da40b22 1199 data.oid = oid;
ed8b10f6
JK
1200 data.options = options;
1201 data.ret = 0;
de6bd9e3 1202 config_opts.error_action = CONFIG_ERROR_SILENT;
ed8b10f6 1203 if (git_config_from_mem(fsck_gitmodules_fn, CONFIG_ORIGIN_BLOB,
de6bd9e3 1204 ".gitmodules", buf, size, &data, &config_opts))
6da40b22 1205 data.ret |= report(options, oid, OBJ_BLOB,
ed8b10f6
JK
1206 FSCK_MSG_GITMODULES_PARSE,
1207 "could not parse gitmodules blob");
1208
1209 return data.ret;
7ac4f3a0
JK
1210}
1211
90a398bb 1212int fsck_object(struct object *obj, void *data, unsigned long size,
22410549 1213 struct fsck_options *options)
ba002f3b
MK
1214{
1215 if (!obj)
38370253 1216 return report(options, NULL, OBJ_NONE, FSCK_MSG_BAD_OBJECT_SHA1, "no valid object to fsck");
ba002f3b
MK
1217
1218 if (obj->type == OBJ_BLOB)
6da40b22 1219 return fsck_blob(&obj->oid, data, size, options);
ba002f3b 1220 if (obj->type == OBJ_TREE)
b2f2039c 1221 return fsck_tree(&obj->oid, data, size, options);
ba002f3b 1222 if (obj->type == OBJ_COMMIT)
c5b4269b 1223 return fsck_commit(&obj->oid, data, size, options);
ba002f3b 1224 if (obj->type == OBJ_TAG)
103fb6d4 1225 return fsck_tag(&obj->oid, data, size, options);
ba002f3b 1226
38370253
JK
1227 return report(options, &obj->oid, obj->type,
1228 FSCK_MSG_UNKNOWN_TYPE,
1229 "unknown type '%d' (internal fsck error)",
1230 obj->type);
ba002f3b 1231}
d6ffc8d7 1232
1cd772cc 1233int fsck_error_function(struct fsck_options *o,
5afc4b1d
JK
1234 const struct object_id *oid,
1235 enum object_type object_type,
1236 int msg_type, const char *message)
d6ffc8d7 1237{
0282f4dc 1238 if (msg_type == FSCK_WARN) {
5afc4b1d 1239 warning("object %s: %s", fsck_describe_object(o, oid), message);
0282f4dc
JS
1240 return 0;
1241 }
5afc4b1d 1242 error("object %s: %s", fsck_describe_object(o, oid), message);
d6ffc8d7
MK
1243 return 1;
1244}
159e7b08
JK
1245
1246int fsck_finish(struct fsck_options *options)
1247{
1248 int ret = 0;
1249 struct oidset_iter iter;
1250 const struct object_id *oid;
1251
1252 oidset_iter_init(&gitmodules_found, &iter);
1253 while ((oid = oidset_iter_next(&iter))) {
159e7b08
JK
1254 enum object_type type;
1255 unsigned long size;
1256 char *buf;
1257
1258 if (oidset_contains(&gitmodules_done, oid))
1259 continue;
1260
7913f53b 1261 buf = read_object_file(oid, &type, &size);
159e7b08 1262 if (!buf) {
b8b00f16 1263 if (is_promisor_object(oid))
27387444 1264 continue;
38370253 1265 ret |= report(options,
b8b00f16 1266 oid, OBJ_BLOB,
159e7b08
JK
1267 FSCK_MSG_GITMODULES_MISSING,
1268 "unable to read .gitmodules blob");
1269 continue;
1270 }
1271
1272 if (type == OBJ_BLOB)
b8b00f16 1273 ret |= fsck_blob(oid, buf, size, options);
159e7b08 1274 else
38370253 1275 ret |= report(options,
b8b00f16 1276 oid, type,
159e7b08
JK
1277 FSCK_MSG_GITMODULES_BLOB,
1278 "non-blob found at .gitmodules");
1279 free(buf);
1280 }
1281
1282
1283 oidset_clear(&gitmodules_found);
1284 oidset_clear(&gitmodules_done);
1285 return ret;
1286}