1 #define USE_THE_REPOSITORY_VARIABLE
3 #include "git-compat-util.h"
7 #include "object-store-ll.h"
9 #include "repository.h"
14 #include "tree-walk.h"
23 #include "submodule-config.h"
27 static ssize_t max_tree_entry_len
= 4096;
30 #define MSG_ID(id, msg_type) { STR(id), NULL, NULL, FSCK_##msg_type },
32 const char *id_string
;
33 const char *downcased
;
34 const char *camelcased
;
35 enum fsck_msg_type msg_type
;
36 } msg_id_info
[FSCK_MSG_MAX
+ 1] = {
37 FOREACH_FSCK_MSG_ID(MSG_ID
)
38 { NULL
, NULL
, NULL
, -1 }
43 static void prepare_msg_ids(void)
47 if (msg_id_info
[0].downcased
)
50 /* convert id_string to lower case, without underscores. */
51 for (i
= 0; i
< FSCK_MSG_MAX
; i
++) {
52 const char *p
= msg_id_info
[i
].id_string
;
54 char *q
= xmalloc(len
);
56 msg_id_info
[i
].downcased
= q
;
61 *(q
)++ = tolower(*(p
)++);
64 p
= msg_id_info
[i
].id_string
;
66 msg_id_info
[i
].camelcased
= q
;
80 static int parse_msg_id(const char *text
)
86 for (i
= 0; i
< FSCK_MSG_MAX
; i
++)
87 if (!strcmp(text
, msg_id_info
[i
].downcased
))
93 void list_config_fsck_msg_ids(struct string_list
*list
, const char *prefix
)
99 for (i
= 0; i
< FSCK_MSG_MAX
; i
++)
100 list_config_item(list
, prefix
, msg_id_info
[i
].camelcased
);
103 static enum fsck_msg_type
fsck_msg_type(enum fsck_msg_id msg_id
,
104 struct fsck_options
*options
)
106 assert(msg_id
>= 0 && msg_id
< FSCK_MSG_MAX
);
108 if (!options
->msg_type
) {
109 enum fsck_msg_type msg_type
= msg_id_info
[msg_id
].msg_type
;
111 if (options
->strict
&& msg_type
== FSCK_WARN
)
112 msg_type
= FSCK_ERROR
;
116 return options
->msg_type
[msg_id
];
119 static enum fsck_msg_type
parse_msg_type(const char *str
)
121 if (!strcmp(str
, "error"))
123 else if (!strcmp(str
, "warn"))
125 else if (!strcmp(str
, "ignore"))
128 die("Unknown fsck message type: '%s'", str
);
131 int is_valid_msg_type(const char *msg_id
, const char *msg_type
)
133 if (parse_msg_id(msg_id
) < 0)
135 parse_msg_type(msg_type
);
139 void fsck_set_msg_type_from_ids(struct fsck_options
*options
,
140 enum fsck_msg_id msg_id
,
141 enum fsck_msg_type msg_type
)
143 if (!options
->msg_type
) {
145 enum fsck_msg_type
*severity
;
146 ALLOC_ARRAY(severity
, FSCK_MSG_MAX
);
147 for (i
= 0; i
< FSCK_MSG_MAX
; i
++)
148 severity
[i
] = fsck_msg_type(i
, options
);
149 options
->msg_type
= severity
;
152 options
->msg_type
[msg_id
] = msg_type
;
155 void fsck_set_msg_type(struct fsck_options
*options
,
156 const char *msg_id_str
, const char *msg_type_str
)
158 int msg_id
= parse_msg_id(msg_id_str
);
159 char *to_free
= NULL
;
160 enum fsck_msg_type msg_type
;
163 die("Unhandled message id: %s", msg_id_str
);
165 if (msg_id
== FSCK_MSG_LARGE_PATHNAME
) {
166 const char *colon
= strchr(msg_type_str
, ':');
168 msg_type_str
= to_free
=
169 xmemdupz(msg_type_str
, colon
- msg_type_str
);
171 if (!git_parse_ssize_t(colon
, &max_tree_entry_len
))
172 die("unable to parse max tree entry len: %s", colon
);
175 msg_type
= parse_msg_type(msg_type_str
);
177 if (msg_type
!= FSCK_ERROR
&& msg_id_info
[msg_id
].msg_type
== FSCK_FATAL
)
178 die("Cannot demote %s to %s", msg_id_str
, msg_type_str
);
180 fsck_set_msg_type_from_ids(options
, msg_id
, msg_type
);
184 void fsck_set_msg_types(struct fsck_options
*options
, const char *values
)
186 char *buf
= xstrdup(values
), *to_free
= buf
;
190 int len
= strcspn(buf
, " ,|"), equal
;
200 equal
< len
&& buf
[equal
] != '=' && buf
[equal
] != ':';
202 buf
[equal
] = tolower(buf
[equal
]);
205 if (!strcmp(buf
, "skiplist")) {
207 die("skiplist requires a path");
208 oidset_parse_file(&options
->skiplist
, buf
+ equal
+ 1,
209 the_repository
->hash_algo
);
215 die("Missing '=': '%s'", buf
);
217 fsck_set_msg_type(options
, buf
, buf
+ equal
+ 1);
223 static int object_on_skiplist(struct fsck_options
*opts
,
224 const struct object_id
*oid
)
226 return opts
&& oid
&& oidset_contains(&opts
->skiplist
, oid
);
229 __attribute__((format (printf
, 5, 6)))
230 static int report(struct fsck_options
*options
,
231 const struct object_id
*oid
, enum object_type object_type
,
232 enum fsck_msg_id msg_id
, const char *fmt
, ...)
235 struct strbuf sb
= STRBUF_INIT
;
236 enum fsck_msg_type msg_type
= fsck_msg_type(msg_id
, options
);
239 if (msg_type
== FSCK_IGNORE
)
242 if (object_on_skiplist(options
, oid
))
245 if (msg_type
== FSCK_FATAL
)
246 msg_type
= FSCK_ERROR
;
247 else if (msg_type
== FSCK_INFO
)
248 msg_type
= FSCK_WARN
;
251 strbuf_addf(&sb
, "%s: ", msg_id_info
[msg_id
].camelcased
);
254 strbuf_vaddf(&sb
, fmt
, ap
);
255 result
= options
->error_func(options
, oid
, object_type
,
256 msg_type
, msg_id
, sb
.buf
);
263 void fsck_enable_object_names(struct fsck_options
*options
)
265 if (!options
->object_names
)
266 options
->object_names
= kh_init_oid_map();
269 const char *fsck_get_object_name(struct fsck_options
*options
,
270 const struct object_id
*oid
)
273 if (!options
->object_names
)
275 pos
= kh_get_oid_map(options
->object_names
, *oid
);
276 if (pos
>= kh_end(options
->object_names
))
278 return kh_value(options
->object_names
, pos
);
281 void fsck_put_object_name(struct fsck_options
*options
,
282 const struct object_id
*oid
,
283 const char *fmt
, ...)
286 struct strbuf buf
= STRBUF_INIT
;
290 if (!options
->object_names
)
293 pos
= kh_put_oid_map(options
->object_names
, *oid
, &hashret
);
297 strbuf_vaddf(&buf
, fmt
, ap
);
298 kh_value(options
->object_names
, pos
) = strbuf_detach(&buf
, NULL
);
302 const char *fsck_describe_object(struct fsck_options
*options
,
303 const struct object_id
*oid
)
305 static struct strbuf bufs
[] = {
306 STRBUF_INIT
, STRBUF_INIT
, STRBUF_INIT
, STRBUF_INIT
310 const char *name
= fsck_get_object_name(options
, oid
);
313 b
= (b
+ 1) % ARRAY_SIZE(bufs
);
315 strbuf_addstr(buf
, oid_to_hex(oid
));
317 strbuf_addf(buf
, " (%s)", name
);
322 static int fsck_walk_tree(struct tree
*tree
, void *data
, struct fsck_options
*options
)
324 struct tree_desc desc
;
325 struct name_entry entry
;
329 if (parse_tree(tree
))
332 name
= fsck_get_object_name(options
, &tree
->object
.oid
);
333 if (init_tree_desc_gently(&desc
, &tree
->object
.oid
,
334 tree
->buffer
, tree
->size
, 0))
336 while (tree_entry_gently(&desc
, &entry
)) {
340 if (S_ISGITLINK(entry
.mode
))
343 if (S_ISDIR(entry
.mode
)) {
344 obj
= (struct object
*)lookup_tree(the_repository
, &entry
.oid
);
346 fsck_put_object_name(options
, &entry
.oid
, "%s%s/",
348 result
= options
->walk(obj
, OBJ_TREE
, data
, options
);
350 else if (S_ISREG(entry
.mode
) || S_ISLNK(entry
.mode
)) {
351 obj
= (struct object
*)lookup_blob(the_repository
, &entry
.oid
);
353 fsck_put_object_name(options
, &entry
.oid
, "%s%s",
355 result
= options
->walk(obj
, OBJ_BLOB
, data
, options
);
358 result
= error("in tree %s: entry %s has bad mode %.6o",
359 fsck_describe_object(options
, &tree
->object
.oid
),
360 entry
.path
, entry
.mode
);
370 static int fsck_walk_commit(struct commit
*commit
, void *data
, struct fsck_options
*options
)
372 int counter
= 0, generation
= 0, name_prefix_len
= 0;
373 struct commit_list
*parents
;
378 if (repo_parse_commit(the_repository
, commit
))
381 name
= fsck_get_object_name(options
, &commit
->object
.oid
);
383 fsck_put_object_name(options
, get_commit_tree_oid(commit
),
386 result
= options
->walk((struct object
*) repo_get_commit_tree(the_repository
, commit
),
387 OBJ_TREE
, data
, options
);
392 parents
= commit
->parents
;
393 if (name
&& parents
) {
394 int len
= strlen(name
), power
;
396 if (len
&& name
[len
- 1] == '^') {
398 name_prefix_len
= len
- 1;
400 else { /* parse ~<generation> suffix */
401 for (generation
= 0, power
= 1;
402 len
&& isdigit(name
[len
- 1]);
404 generation
+= power
* (name
[--len
] - '0');
405 if (power
> 1 && len
&& name
[len
- 1] == '~')
406 name_prefix_len
= len
- 1;
408 /* Maybe a non-first parent, e.g. HEAD^2 */
410 name_prefix_len
= len
;
417 struct object_id
*oid
= &parents
->item
->object
.oid
;
420 fsck_put_object_name(options
, oid
, "%s^%d",
422 else if (generation
> 0)
423 fsck_put_object_name(options
, oid
, "%.*s~%d",
424 name_prefix_len
, name
,
427 fsck_put_object_name(options
, oid
, "%s^", name
);
429 result
= options
->walk((struct object
*)parents
->item
, OBJ_COMMIT
, data
, options
);
434 parents
= parents
->next
;
439 static int fsck_walk_tag(struct tag
*tag
, void *data
, struct fsck_options
*options
)
441 const char *name
= fsck_get_object_name(options
, &tag
->object
.oid
);
446 fsck_put_object_name(options
, &tag
->tagged
->oid
, "%s", name
);
447 return options
->walk(tag
->tagged
, OBJ_ANY
, data
, options
);
450 int fsck_walk(struct object
*obj
, void *data
, struct fsck_options
*options
)
455 if (obj
->type
== OBJ_NONE
)
456 parse_object(the_repository
, &obj
->oid
);
462 return fsck_walk_tree((struct tree
*)obj
, data
, options
);
464 return fsck_walk_commit((struct commit
*)obj
, data
, options
);
466 return fsck_walk_tag((struct tag
*)obj
, data
, options
);
468 error("Unknown object type for %s",
469 fsck_describe_object(options
, &obj
->oid
));
479 static void name_stack_push(struct name_stack
*stack
, const char *name
)
481 ALLOC_GROW(stack
->names
, stack
->nr
+ 1, stack
->alloc
);
482 stack
->names
[stack
->nr
++] = name
;
485 static const char *name_stack_pop(struct name_stack
*stack
)
487 return stack
->nr
? stack
->names
[--stack
->nr
] : NULL
;
490 static void name_stack_clear(struct name_stack
*stack
)
492 FREE_AND_NULL(stack
->names
);
493 stack
->nr
= stack
->alloc
= 0;
497 * The entries in a tree are ordered in the _path_ order,
498 * which means that a directory entry is ordered by adding
499 * a slash to the end of it.
501 * So a directory called "a" is ordered _after_ a file
502 * called "a.c", because "a/" sorts after "a.c".
504 #define TREE_UNORDERED (-1)
505 #define TREE_HAS_DUPS (-2)
507 static int is_less_than_slash(unsigned char c
)
509 return '\0' < c
&& c
< '/';
512 static int verify_ordered(unsigned mode1
, const char *name1
,
513 unsigned mode2
, const char *name2
,
514 struct name_stack
*candidates
)
516 int len1
= strlen(name1
);
517 int len2
= strlen(name2
);
518 int len
= len1
< len2
? len1
: len2
;
519 unsigned char c1
, c2
;
522 cmp
= memcmp(name1
, name2
, len
);
526 return TREE_UNORDERED
;
529 * Ok, the first <len> characters are the same.
530 * Now we need to order the next one, but turn
531 * a '\0' into a '/' for a directory entry.
537 * git-write-tree used to write out a nonsense tree that has
538 * entries with the same name, one blob and one tree. Make
539 * sure we do not have duplicate entries.
541 return TREE_HAS_DUPS
;
542 if (!c1
&& S_ISDIR(mode1
))
544 if (!c2
&& S_ISDIR(mode2
))
548 * There can be non-consecutive duplicates due to the implicitly
557 * Record non-directory candidates (like "foo" and "foo.bar" in
558 * the example) on a stack and check directory candidates (like
559 * foo/" and "foo.bar/") against that stack.
561 if (!c1
&& is_less_than_slash(c2
)) {
562 name_stack_push(candidates
, name1
);
563 } else if (c2
== '/' && is_less_than_slash(c1
)) {
566 const char *f_name
= name_stack_pop(candidates
);
570 if (!skip_prefix(name2
, f_name
, &p
))
573 return TREE_HAS_DUPS
;
574 if (is_less_than_slash(*p
)) {
575 name_stack_push(candidates
, f_name
);
581 return c1
< c2
? 0 : TREE_UNORDERED
;
584 static int fsck_tree(const struct object_id
*tree_oid
,
585 const char *buffer
, unsigned long size
,
586 struct fsck_options
*options
)
589 int has_null_sha1
= 0;
590 int has_full_path
= 0;
591 int has_empty_name
= 0;
595 int has_zero_pad
= 0;
596 int has_bad_modes
= 0;
597 int has_dup_entries
= 0;
598 int not_properly_sorted
= 0;
599 int has_large_name
= 0;
600 struct tree_desc desc
;
603 struct name_stack df_dup_candidates
= { NULL
};
605 if (init_tree_desc_gently(&desc
, tree_oid
, buffer
, size
,
606 TREE_DESC_RAW_MODES
)) {
607 retval
+= report(options
, tree_oid
, OBJ_TREE
,
609 "cannot be parsed as a tree");
618 const char *name
, *backslash
;
619 const struct object_id
*entry_oid
;
621 entry_oid
= tree_entry_extract(&desc
, &name
, &mode
);
623 has_null_sha1
|= is_null_oid(entry_oid
);
624 has_full_path
|= !!strchr(name
, '/');
625 has_empty_name
|= !*name
;
626 has_dot
|= !strcmp(name
, ".");
627 has_dotdot
|= !strcmp(name
, "..");
628 has_dotgit
|= is_hfs_dotgit(name
) || is_ntfs_dotgit(name
);
629 has_zero_pad
|= *(char *)desc
.buffer
== '0';
630 has_large_name
|= tree_entry_len(&desc
.entry
) > max_tree_entry_len
;
632 if (is_hfs_dotgitmodules(name
) || is_ntfs_dotgitmodules(name
)) {
634 oidset_insert(&options
->gitmodules_found
,
637 retval
+= report(options
,
639 FSCK_MSG_GITMODULES_SYMLINK
,
640 ".gitmodules is a symbolic link");
643 if (is_hfs_dotgitattributes(name
) || is_ntfs_dotgitattributes(name
)) {
645 oidset_insert(&options
->gitattributes_found
,
648 retval
+= report(options
, tree_oid
, OBJ_TREE
,
649 FSCK_MSG_GITATTRIBUTES_SYMLINK
,
650 ".gitattributes is a symlink");
654 if (is_hfs_dotgitignore(name
) ||
655 is_ntfs_dotgitignore(name
))
656 retval
+= report(options
, tree_oid
, OBJ_TREE
,
657 FSCK_MSG_GITIGNORE_SYMLINK
,
658 ".gitignore is a symlink");
659 if (is_hfs_dotmailmap(name
) ||
660 is_ntfs_dotmailmap(name
))
661 retval
+= report(options
, tree_oid
, OBJ_TREE
,
662 FSCK_MSG_MAILMAP_SYMLINK
,
663 ".mailmap is a symlink");
666 if ((backslash
= strchr(name
, '\\'))) {
669 has_dotgit
|= is_ntfs_dotgit(backslash
);
670 if (is_ntfs_dotgitmodules(backslash
)) {
672 oidset_insert(&options
->gitmodules_found
,
675 retval
+= report(options
, tree_oid
, OBJ_TREE
,
676 FSCK_MSG_GITMODULES_SYMLINK
,
677 ".gitmodules is a symbolic link");
679 backslash
= strchr(backslash
, '\\');
683 if (update_tree_entry_gently(&desc
)) {
684 retval
+= report(options
, tree_oid
, OBJ_TREE
,
686 "cannot be parsed as a tree");
701 * This is nonstandard, but we had a few of these
702 * early on when we honored the full set of mode
706 if (!options
->strict
)
714 switch (verify_ordered(o_mode
, o_name
, mode
, name
,
715 &df_dup_candidates
)) {
717 not_properly_sorted
= 1;
731 name_stack_clear(&df_dup_candidates
);
734 retval
+= report(options
, tree_oid
, OBJ_TREE
,
736 "contains entries pointing to null sha1");
738 retval
+= report(options
, tree_oid
, OBJ_TREE
,
739 FSCK_MSG_FULL_PATHNAME
,
740 "contains full pathnames");
742 retval
+= report(options
, tree_oid
, OBJ_TREE
,
744 "contains empty pathname");
746 retval
+= report(options
, tree_oid
, OBJ_TREE
,
750 retval
+= report(options
, tree_oid
, OBJ_TREE
,
754 retval
+= report(options
, tree_oid
, OBJ_TREE
,
758 retval
+= report(options
, tree_oid
, OBJ_TREE
,
759 FSCK_MSG_ZERO_PADDED_FILEMODE
,
760 "contains zero-padded file modes");
762 retval
+= report(options
, tree_oid
, OBJ_TREE
,
763 FSCK_MSG_BAD_FILEMODE
,
764 "contains bad file modes");
766 retval
+= report(options
, tree_oid
, OBJ_TREE
,
767 FSCK_MSG_DUPLICATE_ENTRIES
,
768 "contains duplicate file entries");
769 if (not_properly_sorted
)
770 retval
+= report(options
, tree_oid
, OBJ_TREE
,
771 FSCK_MSG_TREE_NOT_SORTED
,
772 "not properly sorted");
774 retval
+= report(options
, tree_oid
, OBJ_TREE
,
775 FSCK_MSG_LARGE_PATHNAME
,
776 "contains excessively large pathname");
781 * Confirm that the headers of a commit or tag object end in a reasonable way,
782 * either with the usual "\n\n" separator, or at least with a trailing newline
783 * on the final header line.
785 * This property is important for the memory safety of our callers. It allows
786 * them to scan the buffer linewise without constantly checking the remaining
789 * - they check that there are bytes left in the buffer at the start of any
790 * line (i.e., that the last newline they saw was not the final one we
793 * - any intra-line scanning they do will stop at a newline, which will worst
794 * case hit the newline we found here as the end-of-header. This makes it
795 * OK for them to use helpers like parse_oid_hex(), or even skip_prefix().
797 static int verify_headers(const void *data
, unsigned long size
,
798 const struct object_id
*oid
, enum object_type type
,
799 struct fsck_options
*options
)
801 const char *buffer
= (const char *)data
;
804 for (i
= 0; i
< size
; i
++) {
807 return report(options
, oid
, type
,
808 FSCK_MSG_NUL_IN_HEADER
,
809 "unterminated header: NUL at offset %ld", i
);
811 if (i
+ 1 < size
&& buffer
[i
+ 1] == '\n')
817 * We did not find double-LF that separates the header
818 * and the body. Not having a body is not a crime but
819 * we do want to see the terminating LF for the last header
822 if (size
&& buffer
[size
- 1] == '\n')
825 return report(options
, oid
, type
,
826 FSCK_MSG_UNTERMINATED_HEADER
, "unterminated header");
829 static int fsck_ident(const char **ident
,
830 const struct object_id
*oid
, enum object_type type
,
831 struct fsck_options
*options
)
833 const char *p
= *ident
;
836 *ident
= strchrnul(*ident
, '\n');
841 return report(options
, oid
, type
, FSCK_MSG_MISSING_NAME_BEFORE_EMAIL
, "invalid author/committer line - missing space before email");
842 p
+= strcspn(p
, "<>\n");
844 return report(options
, oid
, type
, FSCK_MSG_BAD_NAME
, "invalid author/committer line - bad name");
846 return report(options
, oid
, type
, FSCK_MSG_MISSING_EMAIL
, "invalid author/committer line - missing email");
848 return report(options
, oid
, type
, FSCK_MSG_MISSING_SPACE_BEFORE_EMAIL
, "invalid author/committer line - missing space before email");
850 p
+= strcspn(p
, "<>\n");
852 return report(options
, oid
, type
, FSCK_MSG_BAD_EMAIL
, "invalid author/committer line - bad email");
855 return report(options
, oid
, type
, FSCK_MSG_MISSING_SPACE_BEFORE_DATE
, "invalid author/committer line - missing space before date");
858 * Our timestamp parser is based on the C strto*() functions, which
859 * will happily eat whitespace, including the newline that is supposed
860 * to prevent us walking past the end of the buffer. So do our own
861 * scan, skipping linear whitespace but not newlines, and then
862 * confirming we found a digit. We _could_ be even more strict here,
863 * as we really expect only a single space, but since we have
864 * traditionally allowed extra whitespace, we'll continue to do so.
866 while (*p
== ' ' || *p
== '\t')
869 return report(options
, oid
, type
, FSCK_MSG_BAD_DATE
,
870 "invalid author/committer line - bad date");
871 if (*p
== '0' && p
[1] != ' ')
872 return report(options
, oid
, type
, FSCK_MSG_ZERO_PADDED_DATE
, "invalid author/committer line - zero-padded date");
873 if (date_overflows(parse_timestamp(p
, &end
, 10)))
874 return report(options
, oid
, type
, FSCK_MSG_BAD_DATE_OVERFLOW
, "invalid author/committer line - date causes integer overflow");
875 if ((end
== p
|| *end
!= ' '))
876 return report(options
, oid
, type
, FSCK_MSG_BAD_DATE
, "invalid author/committer line - bad date");
878 if ((*p
!= '+' && *p
!= '-') ||
884 return report(options
, oid
, type
, FSCK_MSG_BAD_TIMEZONE
, "invalid author/committer line - bad time zone");
889 static int fsck_commit(const struct object_id
*oid
,
890 const char *buffer
, unsigned long size
,
891 struct fsck_options
*options
)
893 struct object_id tree_oid
, parent_oid
;
894 unsigned author_count
;
896 const char *buffer_begin
= buffer
;
897 const char *buffer_end
= buffer
+ size
;
901 * We _must_ stop parsing immediately if this reports failure, as the
902 * memory safety of the rest of the function depends on it. See the
903 * comment above the definition of verify_headers() for more details.
905 if (verify_headers(buffer
, size
, oid
, OBJ_COMMIT
, options
))
908 if (buffer
>= buffer_end
|| !skip_prefix(buffer
, "tree ", &buffer
))
909 return report(options
, oid
, OBJ_COMMIT
, FSCK_MSG_MISSING_TREE
, "invalid format - expected 'tree' line");
910 if (parse_oid_hex(buffer
, &tree_oid
, &p
) || *p
!= '\n') {
911 err
= report(options
, oid
, OBJ_COMMIT
, FSCK_MSG_BAD_TREE_SHA1
, "invalid 'tree' line format - bad sha1");
916 while (buffer
< buffer_end
&& skip_prefix(buffer
, "parent ", &buffer
)) {
917 if (parse_oid_hex(buffer
, &parent_oid
, &p
) || *p
!= '\n') {
918 err
= report(options
, oid
, OBJ_COMMIT
, FSCK_MSG_BAD_PARENT_SHA1
, "invalid 'parent' line format - bad sha1");
925 while (buffer
< buffer_end
&& skip_prefix(buffer
, "author ", &buffer
)) {
927 err
= fsck_ident(&buffer
, oid
, OBJ_COMMIT
, options
);
931 if (author_count
< 1)
932 err
= report(options
, oid
, OBJ_COMMIT
, FSCK_MSG_MISSING_AUTHOR
, "invalid format - expected 'author' line");
933 else if (author_count
> 1)
934 err
= report(options
, oid
, OBJ_COMMIT
, FSCK_MSG_MULTIPLE_AUTHORS
, "invalid format - multiple 'author' lines");
937 if (buffer
>= buffer_end
|| !skip_prefix(buffer
, "committer ", &buffer
))
938 return report(options
, oid
, OBJ_COMMIT
, FSCK_MSG_MISSING_COMMITTER
, "invalid format - expected 'committer' line");
939 err
= fsck_ident(&buffer
, oid
, OBJ_COMMIT
, options
);
942 if (memchr(buffer_begin
, '\0', size
)) {
943 err
= report(options
, oid
, OBJ_COMMIT
, FSCK_MSG_NUL_IN_COMMIT
,
944 "NUL byte in the commit object body");
951 static int fsck_tag(const struct object_id
*oid
, const char *buffer
,
952 unsigned long size
, struct fsck_options
*options
)
954 struct object_id tagged_oid
;
956 return fsck_tag_standalone(oid
, buffer
, size
, options
, &tagged_oid
,
960 int fsck_tag_standalone(const struct object_id
*oid
, const char *buffer
,
961 unsigned long size
, struct fsck_options
*options
,
962 struct object_id
*tagged_oid
,
967 struct strbuf sb
= STRBUF_INIT
;
968 const char *buffer_end
= buffer
+ size
;
972 * We _must_ stop parsing immediately if this reports failure, as the
973 * memory safety of the rest of the function depends on it. See the
974 * comment above the definition of verify_headers() for more details.
976 ret
= verify_headers(buffer
, size
, oid
, OBJ_TAG
, options
);
980 if (buffer
>= buffer_end
|| !skip_prefix(buffer
, "object ", &buffer
)) {
981 ret
= report(options
, oid
, OBJ_TAG
, FSCK_MSG_MISSING_OBJECT
, "invalid format - expected 'object' line");
984 if (parse_oid_hex(buffer
, tagged_oid
, &p
) || *p
!= '\n') {
985 ret
= report(options
, oid
, OBJ_TAG
, FSCK_MSG_BAD_OBJECT_SHA1
, "invalid 'object' line format - bad sha1");
991 if (buffer
>= buffer_end
|| !skip_prefix(buffer
, "type ", &buffer
)) {
992 ret
= report(options
, oid
, OBJ_TAG
, FSCK_MSG_MISSING_TYPE_ENTRY
, "invalid format - expected 'type' line");
995 eol
= memchr(buffer
, '\n', buffer_end
- buffer
);
997 ret
= report(options
, oid
, OBJ_TAG
, FSCK_MSG_MISSING_TYPE
, "invalid format - unexpected end after 'type' line");
1000 *tagged_type
= type_from_string_gently(buffer
, eol
- buffer
, 1);
1001 if (*tagged_type
< 0)
1002 ret
= report(options
, oid
, OBJ_TAG
, FSCK_MSG_BAD_TYPE
, "invalid 'type' value");
1007 if (buffer
>= buffer_end
|| !skip_prefix(buffer
, "tag ", &buffer
)) {
1008 ret
= report(options
, oid
, OBJ_TAG
, FSCK_MSG_MISSING_TAG_ENTRY
, "invalid format - expected 'tag' line");
1011 eol
= memchr(buffer
, '\n', buffer_end
- buffer
);
1013 ret
= report(options
, oid
, OBJ_TAG
, FSCK_MSG_MISSING_TAG
, "invalid format - unexpected end after 'type' line");
1016 strbuf_addf(&sb
, "refs/tags/%.*s", (int)(eol
- buffer
), buffer
);
1017 if (check_refname_format(sb
.buf
, 0)) {
1018 ret
= report(options
, oid
, OBJ_TAG
,
1019 FSCK_MSG_BAD_TAG_NAME
,
1020 "invalid 'tag' name: %.*s",
1021 (int)(eol
- buffer
), buffer
);
1027 if (buffer
>= buffer_end
|| !skip_prefix(buffer
, "tagger ", &buffer
)) {
1028 /* early tags do not contain 'tagger' lines; warn only */
1029 ret
= report(options
, oid
, OBJ_TAG
, FSCK_MSG_MISSING_TAGGER_ENTRY
, "invalid format - expected 'tagger' line");
1034 ret
= fsck_ident(&buffer
, oid
, OBJ_TAG
, options
);
1036 if (buffer
< buffer_end
&& !starts_with(buffer
, "\n")) {
1038 * The verify_headers() check will allow
1039 * e.g. "[...]tagger <tagger>\nsome
1040 * garbage\n\nmessage" to pass, thinking "some
1041 * garbage" could be a custom header. E.g. "mktag"
1042 * doesn't want any unknown headers.
1044 ret
= report(options
, oid
, OBJ_TAG
, FSCK_MSG_EXTRA_HEADER_ENTRY
, "invalid format - extra header(s) after 'tagger'");
1050 strbuf_release(&sb
);
1054 struct fsck_gitmodules_data
{
1055 const struct object_id
*oid
;
1056 struct fsck_options
*options
;
1060 static int fsck_gitmodules_fn(const char *var
, const char *value
,
1061 const struct config_context
*ctx UNUSED
,
1064 struct fsck_gitmodules_data
*data
= vdata
;
1065 const char *subsection
, *key
;
1066 size_t subsection_len
;
1069 if (parse_config_key(var
, "submodule", &subsection
, &subsection_len
, &key
) < 0 ||
1073 name
= xmemdupz(subsection
, subsection_len
);
1074 if (check_submodule_name(name
) < 0)
1075 data
->ret
|= report(data
->options
,
1076 data
->oid
, OBJ_BLOB
,
1077 FSCK_MSG_GITMODULES_NAME
,
1078 "disallowed submodule name: %s",
1080 if (!strcmp(key
, "url") && value
&&
1081 check_submodule_url(value
) < 0)
1082 data
->ret
|= report(data
->options
,
1083 data
->oid
, OBJ_BLOB
,
1084 FSCK_MSG_GITMODULES_URL
,
1085 "disallowed submodule url: %s",
1087 if (!strcmp(key
, "path") && value
&&
1088 looks_like_command_line_option(value
))
1089 data
->ret
|= report(data
->options
,
1090 data
->oid
, OBJ_BLOB
,
1091 FSCK_MSG_GITMODULES_PATH
,
1092 "disallowed submodule path: %s",
1094 if (!strcmp(key
, "update") && value
&&
1095 parse_submodule_update_type(value
) == SM_UPDATE_COMMAND
)
1096 data
->ret
|= report(data
->options
, data
->oid
, OBJ_BLOB
,
1097 FSCK_MSG_GITMODULES_UPDATE
,
1098 "disallowed submodule update setting: %s",
1105 static int fsck_blob(const struct object_id
*oid
, const char *buf
,
1106 unsigned long size
, struct fsck_options
*options
)
1110 if (object_on_skiplist(options
, oid
))
1113 if (oidset_contains(&options
->gitmodules_found
, oid
)) {
1114 struct config_options config_opts
= { 0 };
1115 struct fsck_gitmodules_data data
;
1117 oidset_insert(&options
->gitmodules_done
, oid
);
1121 * A missing buffer here is a sign that the caller found the
1122 * blob too gigantic to load into memory. Let's just consider
1125 return report(options
, oid
, OBJ_BLOB
,
1126 FSCK_MSG_GITMODULES_LARGE
,
1127 ".gitmodules too large to parse");
1131 data
.options
= options
;
1133 config_opts
.error_action
= CONFIG_ERROR_SILENT
;
1134 if (git_config_from_mem(fsck_gitmodules_fn
, CONFIG_ORIGIN_BLOB
,
1135 ".gitmodules", buf
, size
, &data
,
1136 CONFIG_SCOPE_UNKNOWN
, &config_opts
))
1137 data
.ret
|= report(options
, oid
, OBJ_BLOB
,
1138 FSCK_MSG_GITMODULES_PARSE
,
1139 "could not parse gitmodules blob");
1143 if (oidset_contains(&options
->gitattributes_found
, oid
)) {
1146 oidset_insert(&options
->gitattributes_done
, oid
);
1148 if (!buf
|| size
> ATTR_MAX_FILE_SIZE
) {
1150 * A missing buffer here is a sign that the caller found the
1151 * blob too gigantic to load into memory. Let's just consider
1154 return report(options
, oid
, OBJ_BLOB
,
1155 FSCK_MSG_GITATTRIBUTES_LARGE
,
1156 ".gitattributes too large to parse");
1159 for (ptr
= buf
; *ptr
; ) {
1160 const char *eol
= strchrnul(ptr
, '\n');
1161 if (eol
- ptr
>= ATTR_MAX_LINE_LENGTH
) {
1162 ret
|= report(options
, oid
, OBJ_BLOB
,
1163 FSCK_MSG_GITATTRIBUTES_LINE_LENGTH
,
1164 ".gitattributes has too long lines to parse");
1168 ptr
= *eol
? eol
+ 1 : eol
;
1175 int fsck_object(struct object
*obj
, void *data
, unsigned long size
,
1176 struct fsck_options
*options
)
1179 return report(options
, NULL
, OBJ_NONE
, FSCK_MSG_BAD_OBJECT_SHA1
, "no valid object to fsck");
1181 return fsck_buffer(&obj
->oid
, obj
->type
, data
, size
, options
);
1184 int fsck_buffer(const struct object_id
*oid
, enum object_type type
,
1185 const void *data
, unsigned long size
,
1186 struct fsck_options
*options
)
1188 if (type
== OBJ_BLOB
)
1189 return fsck_blob(oid
, data
, size
, options
);
1190 if (type
== OBJ_TREE
)
1191 return fsck_tree(oid
, data
, size
, options
);
1192 if (type
== OBJ_COMMIT
)
1193 return fsck_commit(oid
, data
, size
, options
);
1194 if (type
== OBJ_TAG
)
1195 return fsck_tag(oid
, data
, size
, options
);
1197 return report(options
, oid
, type
,
1198 FSCK_MSG_UNKNOWN_TYPE
,
1199 "unknown type '%d' (internal fsck error)",
1203 int fsck_error_function(struct fsck_options
*o
,
1204 const struct object_id
*oid
,
1205 enum object_type object_type UNUSED
,
1206 enum fsck_msg_type msg_type
,
1207 enum fsck_msg_id msg_id UNUSED
,
1208 const char *message
)
1210 if (msg_type
== FSCK_WARN
) {
1211 warning("object %s: %s", fsck_describe_object(o
, oid
), message
);
1214 error("object %s: %s", fsck_describe_object(o
, oid
), message
);
1218 static int fsck_blobs(struct oidset
*blobs_found
, struct oidset
*blobs_done
,
1219 enum fsck_msg_id msg_missing
, enum fsck_msg_id msg_type
,
1220 struct fsck_options
*options
, const char *blob_type
)
1223 struct oidset_iter iter
;
1224 const struct object_id
*oid
;
1226 oidset_iter_init(blobs_found
, &iter
);
1227 while ((oid
= oidset_iter_next(&iter
))) {
1228 enum object_type type
;
1232 if (oidset_contains(blobs_done
, oid
))
1235 buf
= repo_read_object_file(the_repository
, oid
, &type
, &size
);
1237 if (is_promisor_object(oid
))
1239 ret
|= report(options
,
1240 oid
, OBJ_BLOB
, msg_missing
,
1241 "unable to read %s blob", blob_type
);
1245 if (type
== OBJ_BLOB
)
1246 ret
|= fsck_blob(oid
, buf
, size
, options
);
1248 ret
|= report(options
, oid
, type
, msg_type
,
1249 "non-blob found at %s", blob_type
);
1253 oidset_clear(blobs_found
);
1254 oidset_clear(blobs_done
);
1259 int fsck_finish(struct fsck_options
*options
)
1263 ret
|= fsck_blobs(&options
->gitmodules_found
, &options
->gitmodules_done
,
1264 FSCK_MSG_GITMODULES_MISSING
, FSCK_MSG_GITMODULES_BLOB
,
1265 options
, ".gitmodules");
1266 ret
|= fsck_blobs(&options
->gitattributes_found
, &options
->gitattributes_done
,
1267 FSCK_MSG_GITATTRIBUTES_MISSING
, FSCK_MSG_GITATTRIBUTES_BLOB
,
1268 options
, ".gitattributes");
1273 int git_fsck_config(const char *var
, const char *value
,
1274 const struct config_context
*ctx
, void *cb
)
1276 struct fsck_options
*options
= cb
;
1279 if (strcmp(var
, "fsck.skiplist") == 0) {
1281 struct strbuf sb
= STRBUF_INIT
;
1283 if (git_config_pathname(&path
, var
, value
))
1285 strbuf_addf(&sb
, "skiplist=%s", path
);
1287 fsck_set_msg_types(options
, sb
.buf
);
1288 strbuf_release(&sb
);
1292 if (skip_prefix(var
, "fsck.", &msg_id
)) {
1294 return config_error_nonbool(var
);
1295 fsck_set_msg_type(options
, msg_id
, value
);
1299 return git_default_config(var
, value
, ctx
, cb
);
1303 * Custom error callbacks that are used in more than one place.
1306 int fsck_error_cb_print_missing_gitmodules(struct fsck_options
*o
,
1307 const struct object_id
*oid
,
1308 enum object_type object_type
,
1309 enum fsck_msg_type msg_type
,
1310 enum fsck_msg_id msg_id
,
1311 const char *message
)
1313 if (msg_id
== FSCK_MSG_GITMODULES_MISSING
) {
1314 puts(oid_to_hex(oid
));
1317 return fsck_error_function(o
, oid
, object_type
, msg_type
, msg_id
, message
);