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