12 #define FOREACH_MSG_ID(FUNC) \
14 FUNC(BAD_DATE, ERROR) \
15 FUNC(BAD_DATE_OVERFLOW, ERROR) \
16 FUNC(BAD_EMAIL, ERROR) \
17 FUNC(BAD_NAME, ERROR) \
18 FUNC(BAD_OBJECT_SHA1, ERROR) \
19 FUNC(BAD_PARENT_SHA1, ERROR) \
20 FUNC(BAD_TAG_OBJECT, ERROR) \
21 FUNC(BAD_TIMEZONE, ERROR) \
22 FUNC(BAD_TREE, ERROR) \
23 FUNC(BAD_TREE_SHA1, ERROR) \
24 FUNC(BAD_TYPE, ERROR) \
25 FUNC(DUPLICATE_ENTRIES, ERROR) \
26 FUNC(MISSING_AUTHOR, ERROR) \
27 FUNC(MISSING_COMMITTER, ERROR) \
28 FUNC(MISSING_EMAIL, ERROR) \
29 FUNC(MISSING_GRAFT, ERROR) \
30 FUNC(MISSING_NAME_BEFORE_EMAIL, ERROR) \
31 FUNC(MISSING_OBJECT, ERROR) \
32 FUNC(MISSING_PARENT, ERROR) \
33 FUNC(MISSING_SPACE_BEFORE_DATE, ERROR) \
34 FUNC(MISSING_SPACE_BEFORE_EMAIL, ERROR) \
35 FUNC(MISSING_TAG, ERROR) \
36 FUNC(MISSING_TAG_ENTRY, ERROR) \
37 FUNC(MISSING_TAG_OBJECT, ERROR) \
38 FUNC(MISSING_TREE, ERROR) \
39 FUNC(MISSING_TYPE, ERROR) \
40 FUNC(MISSING_TYPE_ENTRY, ERROR) \
41 FUNC(NUL_IN_HEADER, ERROR) \
42 FUNC(TAG_OBJECT_NOT_TAG, ERROR) \
43 FUNC(TREE_NOT_SORTED, ERROR) \
44 FUNC(UNKNOWN_TYPE, ERROR) \
45 FUNC(UNTERMINATED_HEADER, ERROR) \
46 FUNC(ZERO_PADDED_DATE, ERROR) \
48 FUNC(BAD_FILEMODE, WARN) \
49 FUNC(BAD_TAG_NAME, WARN) \
50 FUNC(EMPTY_NAME, WARN) \
51 FUNC(FULL_PATHNAME, WARN) \
53 FUNC(HAS_DOTDOT, WARN) \
54 FUNC(HAS_DOTGIT, WARN) \
55 FUNC(MISSING_TAGGER_ENTRY, WARN) \
56 FUNC(NULL_SHA1, WARN) \
57 FUNC(ZERO_PADDED_FILEMODE, WARN)
59 #define MSG_ID(id, msg_type) FSCK_MSG_##id,
61 FOREACH_MSG_ID(MSG_ID
)
67 #define MSG_ID(id, msg_type) { STR(id), NULL, FSCK_##msg_type },
69 const char *id_string
;
70 const char *downcased
;
72 } msg_id_info
[FSCK_MSG_MAX
+ 1] = {
73 FOREACH_MSG_ID(MSG_ID
)
78 static int parse_msg_id(const char *text
)
82 if (!msg_id_info
[0].downcased
) {
83 /* convert id_string to lower case, without underscores. */
84 for (i
= 0; i
< FSCK_MSG_MAX
; i
++) {
85 const char *p
= msg_id_info
[i
].id_string
;
87 char *q
= xmalloc(len
);
89 msg_id_info
[i
].downcased
= q
;
94 *(q
)++ = tolower(*(p
)++);
99 for (i
= 0; i
< FSCK_MSG_MAX
; i
++)
100 if (!strcmp(text
, msg_id_info
[i
].downcased
))
106 static int fsck_msg_type(enum fsck_msg_id msg_id
,
107 struct fsck_options
*options
)
111 assert(msg_id
>= 0 && msg_id
< FSCK_MSG_MAX
);
113 if (options
->msg_type
)
114 msg_type
= options
->msg_type
[msg_id
];
116 msg_type
= msg_id_info
[msg_id
].msg_type
;
117 if (options
->strict
&& msg_type
== FSCK_WARN
)
118 msg_type
= FSCK_ERROR
;
124 static int parse_msg_type(const char *str
)
126 if (!strcmp(str
, "error"))
128 else if (!strcmp(str
, "warn"))
131 die("Unknown fsck message type: '%s'", str
);
134 int is_valid_msg_type(const char *msg_id
, const char *msg_type
)
136 if (parse_msg_id(msg_id
) < 0)
138 parse_msg_type(msg_type
);
142 void fsck_set_msg_type(struct fsck_options
*options
,
143 const char *msg_id
, const char *msg_type
)
145 int id
= parse_msg_id(msg_id
), type
;
148 die("Unhandled message id: %s", msg_id
);
149 type
= parse_msg_type(msg_type
);
151 if (!options
->msg_type
) {
153 int *msg_type
= xmalloc(sizeof(int) * FSCK_MSG_MAX
);
154 for (i
= 0; i
< FSCK_MSG_MAX
; i
++)
155 msg_type
[i
] = fsck_msg_type(i
, options
);
156 options
->msg_type
= msg_type
;
159 options
->msg_type
[id
] = type
;
162 void fsck_set_msg_types(struct fsck_options
*options
, const char *values
)
164 char *buf
= xstrdup(values
), *to_free
= buf
;
168 int len
= strcspn(buf
, " ,|"), equal
;
178 equal
< len
&& buf
[equal
] != '=' && buf
[equal
] != ':';
180 buf
[equal
] = tolower(buf
[equal
]);
184 die("Missing '=': '%s'", buf
);
186 fsck_set_msg_type(options
, buf
, buf
+ equal
+ 1);
192 static void append_msg_id(struct strbuf
*sb
, const char *msg_id
)
195 char c
= *(msg_id
)++;
200 strbuf_addch(sb
, tolower(c
));
203 strbuf_addch(sb
, *(msg_id
)++);
207 strbuf_addstr(sb
, ": ");
210 __attribute__((format (printf
, 4, 5)))
211 static int report(struct fsck_options
*options
, struct object
*object
,
212 enum fsck_msg_id id
, const char *fmt
, ...)
215 struct strbuf sb
= STRBUF_INIT
;
216 int msg_type
= fsck_msg_type(id
, options
), result
;
218 append_msg_id(&sb
, msg_id_info
[id
].id_string
);
221 strbuf_vaddf(&sb
, fmt
, ap
);
222 result
= options
->error_func(object
, msg_type
, sb
.buf
);
229 static int fsck_walk_tree(struct tree
*tree
, void *data
, struct fsck_options
*options
)
231 struct tree_desc desc
;
232 struct name_entry entry
;
235 if (parse_tree(tree
))
238 init_tree_desc(&desc
, tree
->buffer
, tree
->size
);
239 while (tree_entry(&desc
, &entry
)) {
242 if (S_ISGITLINK(entry
.mode
))
244 if (S_ISDIR(entry
.mode
))
245 result
= options
->walk(&lookup_tree(entry
.sha1
)->object
, OBJ_TREE
, data
, options
);
246 else if (S_ISREG(entry
.mode
) || S_ISLNK(entry
.mode
))
247 result
= options
->walk(&lookup_blob(entry
.sha1
)->object
, OBJ_BLOB
, data
, options
);
249 result
= error("in tree %s: entry %s has bad mode %.6o",
250 sha1_to_hex(tree
->object
.sha1
), entry
.path
, entry
.mode
);
260 static int fsck_walk_commit(struct commit
*commit
, void *data
, struct fsck_options
*options
)
262 struct commit_list
*parents
;
266 if (parse_commit(commit
))
269 result
= options
->walk((struct object
*)commit
->tree
, OBJ_TREE
, data
, options
);
274 parents
= commit
->parents
;
276 result
= options
->walk((struct object
*)parents
->item
, OBJ_COMMIT
, data
, options
);
281 parents
= parents
->next
;
286 static int fsck_walk_tag(struct tag
*tag
, void *data
, struct fsck_options
*options
)
290 return options
->walk(tag
->tagged
, OBJ_ANY
, data
, options
);
293 int fsck_walk(struct object
*obj
, void *data
, struct fsck_options
*options
)
301 return fsck_walk_tree((struct tree
*)obj
, data
, options
);
303 return fsck_walk_commit((struct commit
*)obj
, data
, options
);
305 return fsck_walk_tag((struct tag
*)obj
, data
, options
);
307 error("Unknown object type for %s", sha1_to_hex(obj
->sha1
));
313 * The entries in a tree are ordered in the _path_ order,
314 * which means that a directory entry is ordered by adding
315 * a slash to the end of it.
317 * So a directory called "a" is ordered _after_ a file
318 * called "a.c", because "a/" sorts after "a.c".
320 #define TREE_UNORDERED (-1)
321 #define TREE_HAS_DUPS (-2)
323 static int verify_ordered(unsigned mode1
, const char *name1
, unsigned mode2
, const char *name2
)
325 int len1
= strlen(name1
);
326 int len2
= strlen(name2
);
327 int len
= len1
< len2
? len1
: len2
;
328 unsigned char c1
, c2
;
331 cmp
= memcmp(name1
, name2
, len
);
335 return TREE_UNORDERED
;
338 * Ok, the first <len> characters are the same.
339 * Now we need to order the next one, but turn
340 * a '\0' into a '/' for a directory entry.
346 * git-write-tree used to write out a nonsense tree that has
347 * entries with the same name, one blob and one tree. Make
348 * sure we do not have duplicate entries.
350 return TREE_HAS_DUPS
;
351 if (!c1
&& S_ISDIR(mode1
))
353 if (!c2
&& S_ISDIR(mode2
))
355 return c1
< c2
? 0 : TREE_UNORDERED
;
358 static int fsck_tree(struct tree
*item
, struct fsck_options
*options
)
361 int has_null_sha1
= 0;
362 int has_full_path
= 0;
363 int has_empty_name
= 0;
367 int has_zero_pad
= 0;
368 int has_bad_modes
= 0;
369 int has_dup_entries
= 0;
370 int not_properly_sorted
= 0;
371 struct tree_desc desc
;
375 init_tree_desc(&desc
, item
->buffer
, item
->size
);
383 const unsigned char *sha1
;
385 sha1
= tree_entry_extract(&desc
, &name
, &mode
);
387 has_null_sha1
|= is_null_sha1(sha1
);
388 has_full_path
|= !!strchr(name
, '/');
389 has_empty_name
|= !*name
;
390 has_dot
|= !strcmp(name
, ".");
391 has_dotdot
|= !strcmp(name
, "..");
392 has_dotgit
|= (!strcmp(name
, ".git") ||
393 is_hfs_dotgit(name
) ||
394 is_ntfs_dotgit(name
));
395 has_zero_pad
|= *(char *)desc
.buffer
== '0';
396 update_tree_entry(&desc
);
409 * This is nonstandard, but we had a few of these
410 * early on when we honored the full set of mode
414 if (!options
->strict
)
421 switch (verify_ordered(o_mode
, o_name
, mode
, name
)) {
423 not_properly_sorted
= 1;
439 retval
+= report(options
, &item
->object
, FSCK_MSG_NULL_SHA1
, "contains entries pointing to null sha1");
441 retval
+= report(options
, &item
->object
, FSCK_MSG_FULL_PATHNAME
, "contains full pathnames");
443 retval
+= report(options
, &item
->object
, FSCK_MSG_EMPTY_NAME
, "contains empty pathname");
445 retval
+= report(options
, &item
->object
, FSCK_MSG_HAS_DOT
, "contains '.'");
447 retval
+= report(options
, &item
->object
, FSCK_MSG_HAS_DOTDOT
, "contains '..'");
449 retval
+= report(options
, &item
->object
, FSCK_MSG_HAS_DOTGIT
, "contains '.git'");
451 retval
+= report(options
, &item
->object
, FSCK_MSG_ZERO_PADDED_FILEMODE
, "contains zero-padded file modes");
453 retval
+= report(options
, &item
->object
, FSCK_MSG_BAD_FILEMODE
, "contains bad file modes");
455 retval
+= report(options
, &item
->object
, FSCK_MSG_DUPLICATE_ENTRIES
, "contains duplicate file entries");
456 if (not_properly_sorted
)
457 retval
+= report(options
, &item
->object
, FSCK_MSG_TREE_NOT_SORTED
, "not properly sorted");
461 static int require_end_of_header(const void *data
, unsigned long size
,
462 struct object
*obj
, struct fsck_options
*options
)
464 const char *buffer
= (const char *)data
;
467 for (i
= 0; i
< size
; i
++) {
470 return report(options
, obj
,
471 FSCK_MSG_NUL_IN_HEADER
,
472 "unterminated header: NUL at offset %ld", i
);
474 if (i
+ 1 < size
&& buffer
[i
+ 1] == '\n')
479 return report(options
, obj
,
480 FSCK_MSG_UNTERMINATED_HEADER
, "unterminated header");
483 static int fsck_ident(const char **ident
, struct object
*obj
, struct fsck_options
*options
)
485 const char *p
= *ident
;
488 *ident
= strchrnul(*ident
, '\n');
493 return report(options
, obj
, FSCK_MSG_MISSING_NAME_BEFORE_EMAIL
, "invalid author/committer line - missing space before email");
494 p
+= strcspn(p
, "<>\n");
496 return report(options
, obj
, FSCK_MSG_BAD_NAME
, "invalid author/committer line - bad name");
498 return report(options
, obj
, FSCK_MSG_MISSING_EMAIL
, "invalid author/committer line - missing email");
500 return report(options
, obj
, FSCK_MSG_MISSING_SPACE_BEFORE_EMAIL
, "invalid author/committer line - missing space before email");
502 p
+= strcspn(p
, "<>\n");
504 return report(options
, obj
, FSCK_MSG_BAD_EMAIL
, "invalid author/committer line - bad email");
507 return report(options
, obj
, FSCK_MSG_MISSING_SPACE_BEFORE_DATE
, "invalid author/committer line - missing space before date");
509 if (*p
== '0' && p
[1] != ' ')
510 return report(options
, obj
, FSCK_MSG_ZERO_PADDED_DATE
, "invalid author/committer line - zero-padded date");
511 if (date_overflows(strtoul(p
, &end
, 10)))
512 return report(options
, obj
, FSCK_MSG_BAD_DATE_OVERFLOW
, "invalid author/committer line - date causes integer overflow");
513 if ((end
== p
|| *end
!= ' '))
514 return report(options
, obj
, FSCK_MSG_BAD_DATE
, "invalid author/committer line - bad date");
516 if ((*p
!= '+' && *p
!= '-') ||
522 return report(options
, obj
, FSCK_MSG_BAD_TIMEZONE
, "invalid author/committer line - bad time zone");
527 static int fsck_commit_buffer(struct commit
*commit
, const char *buffer
,
528 unsigned long size
, struct fsck_options
*options
)
530 unsigned char tree_sha1
[20], sha1
[20];
531 struct commit_graft
*graft
;
532 unsigned parent_count
, parent_line_count
= 0;
535 if (require_end_of_header(buffer
, size
, &commit
->object
, options
))
538 if (!skip_prefix(buffer
, "tree ", &buffer
))
539 return report(options
, &commit
->object
, FSCK_MSG_MISSING_TREE
, "invalid format - expected 'tree' line");
540 if (get_sha1_hex(buffer
, tree_sha1
) || buffer
[40] != '\n') {
541 err
= report(options
, &commit
->object
, FSCK_MSG_BAD_TREE_SHA1
, "invalid 'tree' line format - bad sha1");
546 while (skip_prefix(buffer
, "parent ", &buffer
)) {
547 if (get_sha1_hex(buffer
, sha1
) || buffer
[40] != '\n') {
548 err
= report(options
, &commit
->object
, FSCK_MSG_BAD_PARENT_SHA1
, "invalid 'parent' line format - bad sha1");
555 graft
= lookup_commit_graft(commit
->object
.sha1
);
556 parent_count
= commit_list_count(commit
->parents
);
558 if (graft
->nr_parent
== -1 && !parent_count
)
559 ; /* shallow commit */
560 else if (graft
->nr_parent
!= parent_count
) {
561 err
= report(options
, &commit
->object
, FSCK_MSG_MISSING_GRAFT
, "graft objects missing");
566 if (parent_count
!= parent_line_count
) {
567 err
= report(options
, &commit
->object
, FSCK_MSG_MISSING_PARENT
, "parent objects missing");
572 if (!skip_prefix(buffer
, "author ", &buffer
))
573 return report(options
, &commit
->object
, FSCK_MSG_MISSING_AUTHOR
, "invalid format - expected 'author' line");
574 err
= fsck_ident(&buffer
, &commit
->object
, options
);
577 if (!skip_prefix(buffer
, "committer ", &buffer
))
578 return report(options
, &commit
->object
, FSCK_MSG_MISSING_COMMITTER
, "invalid format - expected 'committer' line");
579 err
= fsck_ident(&buffer
, &commit
->object
, options
);
583 return report(options
, &commit
->object
, FSCK_MSG_BAD_TREE
, "could not load commit's tree %s", sha1_to_hex(tree_sha1
));
588 static int fsck_commit(struct commit
*commit
, const char *data
,
589 unsigned long size
, struct fsck_options
*options
)
591 const char *buffer
= data
? data
: get_commit_buffer(commit
, &size
);
592 int ret
= fsck_commit_buffer(commit
, buffer
, size
, options
);
594 unuse_commit_buffer(commit
, buffer
);
598 static int fsck_tag_buffer(struct tag
*tag
, const char *data
,
599 unsigned long size
, struct fsck_options
*options
)
601 unsigned char sha1
[20];
604 char *to_free
= NULL
, *eol
;
605 struct strbuf sb
= STRBUF_INIT
;
610 enum object_type type
;
613 read_sha1_file(tag
->object
.sha1
, &type
, &size
);
615 return report(options
, &tag
->object
,
616 FSCK_MSG_MISSING_TAG_OBJECT
,
617 "cannot read tag object");
619 if (type
!= OBJ_TAG
) {
620 ret
= report(options
, &tag
->object
,
621 FSCK_MSG_TAG_OBJECT_NOT_TAG
,
622 "expected tag got %s",
628 if (require_end_of_header(buffer
, size
, &tag
->object
, options
))
631 if (!skip_prefix(buffer
, "object ", &buffer
)) {
632 ret
= report(options
, &tag
->object
, FSCK_MSG_MISSING_OBJECT
, "invalid format - expected 'object' line");
635 if (get_sha1_hex(buffer
, sha1
) || buffer
[40] != '\n') {
636 ret
= report(options
, &tag
->object
, FSCK_MSG_BAD_OBJECT_SHA1
, "invalid 'object' line format - bad sha1");
641 if (!skip_prefix(buffer
, "type ", &buffer
)) {
642 ret
= report(options
, &tag
->object
, FSCK_MSG_MISSING_TYPE_ENTRY
, "invalid format - expected 'type' line");
645 eol
= strchr(buffer
, '\n');
647 ret
= report(options
, &tag
->object
, FSCK_MSG_MISSING_TYPE
, "invalid format - unexpected end after 'type' line");
650 if (type_from_string_gently(buffer
, eol
- buffer
, 1) < 0)
651 ret
= report(options
, &tag
->object
, FSCK_MSG_BAD_TYPE
, "invalid 'type' value");
656 if (!skip_prefix(buffer
, "tag ", &buffer
)) {
657 ret
= report(options
, &tag
->object
, FSCK_MSG_MISSING_TAG_ENTRY
, "invalid format - expected 'tag' line");
660 eol
= strchr(buffer
, '\n');
662 ret
= report(options
, &tag
->object
, FSCK_MSG_MISSING_TAG
, "invalid format - unexpected end after 'type' line");
665 strbuf_addf(&sb
, "refs/tags/%.*s", (int)(eol
- buffer
), buffer
);
666 if (check_refname_format(sb
.buf
, 0))
667 report(options
, &tag
->object
, FSCK_MSG_BAD_TAG_NAME
,
668 "invalid 'tag' name: %.*s",
669 (int)(eol
- buffer
), buffer
);
672 if (!skip_prefix(buffer
, "tagger ", &buffer
))
673 /* early tags do not contain 'tagger' lines; warn only */
674 report(options
, &tag
->object
, FSCK_MSG_MISSING_TAGGER_ENTRY
, "invalid format - expected 'tagger' line");
676 ret
= fsck_ident(&buffer
, &tag
->object
, options
);
684 static int fsck_tag(struct tag
*tag
, const char *data
,
685 unsigned long size
, struct fsck_options
*options
)
687 struct object
*tagged
= tag
->tagged
;
690 return report(options
, &tag
->object
, FSCK_MSG_BAD_TAG_OBJECT
, "could not load tagged object");
692 return fsck_tag_buffer(tag
, data
, size
, options
);
695 int fsck_object(struct object
*obj
, void *data
, unsigned long size
,
696 struct fsck_options
*options
)
699 return report(options
, obj
, FSCK_MSG_BAD_OBJECT_SHA1
, "no valid object to fsck");
701 if (obj
->type
== OBJ_BLOB
)
703 if (obj
->type
== OBJ_TREE
)
704 return fsck_tree((struct tree
*) obj
, options
);
705 if (obj
->type
== OBJ_COMMIT
)
706 return fsck_commit((struct commit
*) obj
, (const char *) data
,
708 if (obj
->type
== OBJ_TAG
)
709 return fsck_tag((struct tag
*) obj
, (const char *) data
,
712 return report(options
, obj
, FSCK_MSG_UNKNOWN_TYPE
, "unknown type '%d' (internal fsck error)",
716 int fsck_error_function(struct object
*obj
, int msg_type
, const char *message
)
718 if (msg_type
== FSCK_WARN
) {
719 warning("object %s: %s", sha1_to_hex(obj
->sha1
), message
);
722 error("object %s: %s", sha1_to_hex(obj
->sha1
), message
);