fsck.c

   1 #define USE_THE_REPOSITORY_VARIABLE
   2
   3 #include "git-compat-util.h"
   4 #include "date.h"
   5 #include "dir.h"
   6 #include "hex.h"
   7 #include "object-store-ll.h"
   8 #include "path.h"
   9 #include "repository.h"
  10 #include "object.h"
  11 #include "attr.h"
  12 #include "blob.h"
  13 #include "tree.h"
  14 #include "tree-walk.h"
  15 #include "commit.h"
  16 #include "tag.h"
  17 #include "fsck.h"
  18 #include "refs.h"
  19 #include "url.h"
  20 #include "utf8.h"
  21 #include "oidset.h"
  22 #include "packfile.h"
  23 #include "submodule-config.h"
  24 #include "config.h"
  25 #include "help.h"
  26
  27 static ssize_t max_tree_entry_len = 4096;
  28
  29 #define STR(x) #x
  30 #define MSG_ID(id, msg_type) { STR(id), NULL, NULL, FSCK_##msg_type },
  31 static struct {
  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 }
  39 };
  40 #undef MSG_ID
  41 #undef STR
  42
  43 static void prepare_msg_ids(void)
  44 {
  45         int i;
  46
  47         if (msg_id_info[0].downcased)
  48                 return;
  49
  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;
  53                 int len = strlen(p);
  54                 char *q = xmalloc(len);
  55
  56                 msg_id_info[i].downcased = q;
  57                 while (*p)
  58                         if (*p == '_')
  59                                 p++;
  60                         else
  61                                 *(q)++ = tolower(*(p)++);
  62                 *q = '\0';
  63
  64                 p = msg_id_info[i].id_string;
  65                 q = xmalloc(len);
  66                 msg_id_info[i].camelcased = q;
  67                 while (*p) {
  68                         if (*p == '_') {
  69                                 p++;
  70                                 if (*p)
  71                                         *q++ = *p++;
  72                         } else {
  73                                 *q++ = tolower(*p++);
  74                         }
  75                 }
  76                 *q = '\0';
  77         }
  78 }
  79
  80 static int parse_msg_id(const char *text)
  81 {
  82         int i;
  83
  84         prepare_msg_ids();
  85
  86         for (i = 0; i < FSCK_MSG_MAX; i++)
  87                 if (!strcmp(text, msg_id_info[i].downcased))
  88                         return i;
  89
  90         return -1;
  91 }
  92
  93 void list_config_fsck_msg_ids(struct string_list *list, const char *prefix)
  94 {
  95         int i;
  96
  97         prepare_msg_ids();
  98
  99         for (i = 0; i < FSCK_MSG_MAX; i++)
 100                 list_config_item(list, prefix, msg_id_info[i].camelcased);
 101 }
 102
 103 static enum fsck_msg_type fsck_msg_type(enum fsck_msg_id msg_id,
 104         struct fsck_options *options)
 105 {
 106         assert(msg_id >= 0 && msg_id < FSCK_MSG_MAX);
 107
 108         if (!options->msg_type) {
 109                 enum fsck_msg_type msg_type = msg_id_info[msg_id].msg_type;
 110
 111                 if (options->strict && msg_type == FSCK_WARN)
 112                         msg_type = FSCK_ERROR;
 113                 return msg_type;
 114         }
 115
 116         return options->msg_type[msg_id];
 117 }
 118
 119 static enum fsck_msg_type parse_msg_type(const char *str)
 120 {
 121         if (!strcmp(str, "error"))
 122                 return FSCK_ERROR;
 123         else if (!strcmp(str, "warn"))
 124                 return FSCK_WARN;
 125         else if (!strcmp(str, "ignore"))
 126                 return FSCK_IGNORE;
 127         else
 128                 die("Unknown fsck message type: '%s'", str);
 129 }
 130
 131 int is_valid_msg_type(const char *msg_id, const char *msg_type)
 132 {
 133         if (parse_msg_id(msg_id) < 0)
 134                 return 0;
 135         parse_msg_type(msg_type);
 136         return 1;
 137 }
 138
 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)
 142 {
 143         if (!options->msg_type) {
 144                 int i;
 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;
 150         }
 151
 152         options->msg_type[msg_id] = msg_type;
 153 }
 154
 155 void fsck_set_msg_type(struct fsck_options *options,
 156                        const char *msg_id_str, const char *msg_type_str)
 157 {
 158         int msg_id = parse_msg_id(msg_id_str);
 159         char *to_free = NULL;
 160         enum fsck_msg_type msg_type;
 161
 162         if (msg_id < 0)
 163                 die("Unhandled message id: %s", msg_id_str);
 164
 165         if (msg_id == FSCK_MSG_LARGE_PATHNAME) {
 166                 const char *colon = strchr(msg_type_str, ':');
 167                 if (colon) {
 168                         msg_type_str = to_free =
 169                                 xmemdupz(msg_type_str, colon - msg_type_str);
 170                         colon++;
 171                         if (!git_parse_ssize_t(colon, &max_tree_entry_len))
 172                                 die("unable to parse max tree entry len: %s", colon);
 173                 }
 174         }
 175         msg_type = parse_msg_type(msg_type_str);
 176
 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);
 179
 180         fsck_set_msg_type_from_ids(options, msg_id, msg_type);
 181         free(to_free);
 182 }
 183
 184 void fsck_set_msg_types(struct fsck_options *options, const char *values)
 185 {
 186         char *buf = xstrdup(values), *to_free = buf;
 187         int done = 0;
 188
 189         while (!done) {
 190                 int len = strcspn(buf, " ,|"), equal;
 191
 192                 done = !buf[len];
 193                 if (!len) {
 194                         buf++;
 195                         continue;
 196                 }
 197                 buf[len] = '\0';
 198
 199                 for (equal = 0;
 200                      equal < len && buf[equal] != '=' && buf[equal] != ':';
 201                      equal++)
 202                         buf[equal] = tolower(buf[equal]);
 203                 buf[equal] = '\0';
 204
 205                 if (!strcmp(buf, "skiplist")) {
 206                         if (equal == len)
 207                                 die("skiplist requires a path");
 208                         oidset_parse_file(&options->skiplist, buf + equal + 1,
 209                                           the_repository->hash_algo);
 210                         buf += len + 1;
 211                         continue;
 212                 }
 213
 214                 if (equal == len)
 215                         die("Missing '=': '%s'", buf);
 216
 217                 fsck_set_msg_type(options, buf, buf + equal + 1);
 218                 buf += len + 1;
 219         }
 220         free(to_free);
 221 }
 222
 223 static int object_on_skiplist(struct fsck_options *opts,
 224                               const struct object_id *oid)
 225 {
 226         return opts && oid && oidset_contains(&opts->skiplist, oid);
 227 }
 228
 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, ...)
 233 {
 234         va_list ap;
 235         struct strbuf sb = STRBUF_INIT;
 236         enum fsck_msg_type msg_type = fsck_msg_type(msg_id, options);
 237         int result;
 238
 239         if (msg_type == FSCK_IGNORE)
 240                 return 0;
 241
 242         if (object_on_skiplist(options, oid))
 243                 return 0;
 244
 245         if (msg_type == FSCK_FATAL)
 246                 msg_type = FSCK_ERROR;
 247         else if (msg_type == FSCK_INFO)
 248                 msg_type = FSCK_WARN;
 249
 250         prepare_msg_ids();
 251         strbuf_addf(&sb, "%s: ", msg_id_info[msg_id].camelcased);
 252
 253         va_start(ap, fmt);
 254         strbuf_vaddf(&sb, fmt, ap);
 255         result = options->error_func(options, oid, object_type,
 256                                      msg_type, msg_id, sb.buf);
 257         strbuf_release(&sb);
 258         va_end(ap);
 259
 260         return result;
 261 }
 262
 263 void fsck_enable_object_names(struct fsck_options *options)
 264 {
 265         if (!options->object_names)
 266                 options->object_names = kh_init_oid_map();
 267 }
 268
 269 const char *fsck_get_object_name(struct fsck_options *options,
 270                                  const struct object_id *oid)
 271 {
 272         khiter_t pos;
 273         if (!options->object_names)
 274                 return NULL;
 275         pos = kh_get_oid_map(options->object_names, *oid);
 276         if (pos >= kh_end(options->object_names))
 277                 return NULL;
 278         return kh_value(options->object_names, pos);
 279 }
 280
 281 void fsck_put_object_name(struct fsck_options *options,
 282                           const struct object_id *oid,
 283                           const char *fmt, ...)
 284 {
 285         va_list ap;
 286         struct strbuf buf = STRBUF_INIT;
 287         khiter_t pos;
 288         int hashret;
 289
 290         if (!options->object_names)
 291                 return;
 292
 293         pos = kh_put_oid_map(options->object_names, *oid, &hashret);
 294         if (!hashret)
 295                 return;
 296         va_start(ap, fmt);
 297         strbuf_vaddf(&buf, fmt, ap);
 298         kh_value(options->object_names, pos) = strbuf_detach(&buf, NULL);
 299         va_end(ap);
 300 }
 301
 302 const char *fsck_describe_object(struct fsck_options *options,
 303                                  const struct object_id *oid)
 304 {
 305         static struct strbuf bufs[] = {
 306                 STRBUF_INIT, STRBUF_INIT, STRBUF_INIT, STRBUF_INIT
 307         };
 308         static int b = 0;
 309         struct strbuf *buf;
 310         const char *name = fsck_get_object_name(options, oid);
 311
 312         buf = bufs + b;
 313         b = (b + 1) % ARRAY_SIZE(bufs);
 314         strbuf_reset(buf);
 315         strbuf_addstr(buf, oid_to_hex(oid));
 316         if (name)
 317                 strbuf_addf(buf, " (%s)", name);
 318
 319         return buf->buf;
 320 }
 321
 322 static int fsck_walk_tree(struct tree *tree, void *data, struct fsck_options *options)
 323 {
 324         struct tree_desc desc;
 325         struct name_entry entry;
 326         int res = 0;
 327         const char *name;
 328
 329         if (parse_tree(tree))
 330                 return -1;
 331
 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))
 335                 return -1;
 336         while (tree_entry_gently(&desc, &entry)) {
 337                 struct object *obj;
 338                 int result;
 339
 340                 if (S_ISGITLINK(entry.mode))
 341                         continue;
 342
 343                 if (S_ISDIR(entry.mode)) {
 344                         obj = (struct object *)lookup_tree(the_repository, &entry.oid);
 345                         if (name && obj)
 346                                 fsck_put_object_name(options, &entry.oid, "%s%s/",
 347                                                      name, entry.path);
 348                         result = options->walk(obj, OBJ_TREE, data, options);
 349                 }
 350                 else if (S_ISREG(entry.mode) || S_ISLNK(entry.mode)) {
 351                         obj = (struct object *)lookup_blob(the_repository, &entry.oid);
 352                         if (name && obj)
 353                                 fsck_put_object_name(options, &entry.oid, "%s%s",
 354                                                      name, entry.path);
 355                         result = options->walk(obj, OBJ_BLOB, data, options);
 356                 }
 357                 else {
 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);
 361                 }
 362                 if (result < 0)
 363                         return result;
 364                 if (!res)
 365                         res = result;
 366         }
 367         return res;
 368 }
 369
 370 static int fsck_walk_commit(struct commit *commit, void *data, struct fsck_options *options)
 371 {
 372         int counter = 0, generation = 0, name_prefix_len = 0;
 373         struct commit_list *parents;
 374         int res;
 375         int result;
 376         const char *name;
 377
 378         if (repo_parse_commit(the_repository, commit))
 379                 return -1;
 380
 381         name = fsck_get_object_name(options, &commit->object.oid);
 382         if (name)
 383                 fsck_put_object_name(options, get_commit_tree_oid(commit),
 384                                      "%s:", name);
 385
 386         result = options->walk((struct object *) repo_get_commit_tree(the_repository, commit),
 387                                OBJ_TREE, data, options);
 388         if (result < 0)
 389                 return result;
 390         res = result;
 391
 392         parents = commit->parents;
 393         if (name && parents) {
 394                 int len = strlen(name), power;
 395
 396                 if (len && name[len - 1] == '^') {
 397                         generation = 1;
 398                         name_prefix_len = len - 1;
 399                 }
 400                 else { /* parse ~<generation> suffix */
 401                         for (generation = 0, power = 1;
 402                              len && isdigit(name[len - 1]);
 403                              power *= 10)
 404                                 generation += power * (name[--len] - '0');
 405                         if (power > 1 && len && name[len - 1] == '~')
 406                                 name_prefix_len = len - 1;
 407                         else {
 408                                 /* Maybe a non-first parent, e.g. HEAD^2 */
 409                                 generation = 0;
 410                                 name_prefix_len = len;
 411                         }
 412                 }
 413         }
 414
 415         while (parents) {
 416                 if (name) {
 417                         struct object_id *oid = &parents->item->object.oid;
 418
 419                         if (counter++)
 420                                 fsck_put_object_name(options, oid, "%s^%d",
 421                                                      name, counter);
 422                         else if (generation > 0)
 423                                 fsck_put_object_name(options, oid, "%.*s~%d",
 424                                                      name_prefix_len, name,
 425                                                      generation + 1);
 426                         else
 427                                 fsck_put_object_name(options, oid, "%s^", name);
 428                 }
 429                 result = options->walk((struct object *)parents->item, OBJ_COMMIT, data, options);
 430                 if (result < 0)
 431                         return result;
 432                 if (!res)
 433                         res = result;
 434                 parents = parents->next;
 435         }
 436         return res;
 437 }
 438
 439 static int fsck_walk_tag(struct tag *tag, void *data, struct fsck_options *options)
 440 {
 441         const char *name = fsck_get_object_name(options, &tag->object.oid);
 442
 443         if (parse_tag(tag))
 444                 return -1;
 445         if (name)
 446                 fsck_put_object_name(options, &tag->tagged->oid, "%s", name);
 447         return options->walk(tag->tagged, OBJ_ANY, data, options);
 448 }
 449
 450 int fsck_walk(struct object *obj, void *data, struct fsck_options *options)
 451 {
 452         if (!obj)
 453                 return -1;
 454
 455         if (obj->type == OBJ_NONE)
 456                 parse_object(the_repository, &obj->oid);
 457
 458         switch (obj->type) {
 459         case OBJ_BLOB:
 460                 return 0;
 461         case OBJ_TREE:
 462                 return fsck_walk_tree((struct tree *)obj, data, options);
 463         case OBJ_COMMIT:
 464                 return fsck_walk_commit((struct commit *)obj, data, options);
 465         case OBJ_TAG:
 466                 return fsck_walk_tag((struct tag *)obj, data, options);
 467         default:
 468                 error("Unknown object type for %s",
 469                       fsck_describe_object(options, &obj->oid));
 470                 return -1;
 471         }
 472 }
 473
 474 struct name_stack {
 475         const char **names;
 476         size_t nr, alloc;
 477 };
 478
 479 static void name_stack_push(struct name_stack *stack, const char *name)
 480 {
 481         ALLOC_GROW(stack->names, stack->nr + 1, stack->alloc);
 482         stack->names[stack->nr++] = name;
 483 }
 484
 485 static const char *name_stack_pop(struct name_stack *stack)
 486 {
 487         return stack->nr ? stack->names[--stack->nr] : NULL;
 488 }
 489
 490 static void name_stack_clear(struct name_stack *stack)
 491 {
 492         FREE_AND_NULL(stack->names);
 493         stack->nr = stack->alloc = 0;
 494 }
 495
 496 /*
 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.
 500  *
 501  * So a directory called "a" is ordered _after_ a file
 502  * called "a.c", because "a/" sorts after "a.c".
 503  */
 504 #define TREE_UNORDERED (-1)
 505 #define TREE_HAS_DUPS  (-2)
 506
 507 static int is_less_than_slash(unsigned char c)
 508 {
 509         return '\0' < c && c < '/';
 510 }
 511
 512 static int verify_ordered(unsigned mode1, const char *name1,
 513                           unsigned mode2, const char *name2,
 514                           struct name_stack *candidates)
 515 {
 516         int len1 = strlen(name1);
 517         int len2 = strlen(name2);
 518         int len = len1 < len2 ? len1 : len2;
 519         unsigned char c1, c2;
 520         int cmp;
 521
 522         cmp = memcmp(name1, name2, len);
 523         if (cmp < 0)
 524                 return 0;
 525         if (cmp > 0)
 526                 return TREE_UNORDERED;
 527
 528         /*
 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.
 532          */
 533         c1 = name1[len];
 534         c2 = name2[len];
 535         if (!c1 && !c2)
 536                 /*
 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.
 540                  */
 541                 return TREE_HAS_DUPS;
 542         if (!c1 && S_ISDIR(mode1))
 543                 c1 = '/';
 544         if (!c2 && S_ISDIR(mode2))
 545                 c2 = '/';
 546
 547         /*
 548          * There can be non-consecutive duplicates due to the implicitly
 549          * added slash, e.g.:
 550          *
 551          *   foo
 552          *   foo.bar
 553          *   foo.bar.baz
 554          *   foo.bar/
 555          *   foo/
 556          *
 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.
 560          */
 561         if (!c1 && is_less_than_slash(c2)) {
 562                 name_stack_push(candidates, name1);
 563         } else if (c2 == '/' && is_less_than_slash(c1)) {
 564                 for (;;) {
 565                         const char *p;
 566                         const char *f_name = name_stack_pop(candidates);
 567
 568                         if (!f_name)
 569                                 break;
 570                         if (!skip_prefix(name2, f_name, &p))
 571                                 continue;
 572                         if (!*p)
 573                                 return TREE_HAS_DUPS;
 574                         if (is_less_than_slash(*p)) {
 575                                 name_stack_push(candidates, f_name);
 576                                 break;
 577                         }
 578                 }
 579         }
 580
 581         return c1 < c2 ? 0 : TREE_UNORDERED;
 582 }
 583
 584 static int fsck_tree(const struct object_id *tree_oid,
 585                      const char *buffer, unsigned long size,
 586                      struct fsck_options *options)
 587 {
 588         int retval = 0;
 589         int has_null_sha1 = 0;
 590         int has_full_path = 0;
 591         int has_empty_name = 0;
 592         int has_dot = 0;
 593         int has_dotdot = 0;
 594         int has_dotgit = 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;
 601         unsigned o_mode;
 602         const char *o_name;
 603         struct name_stack df_dup_candidates = { NULL };
 604
 605         if (init_tree_desc_gently(&desc, tree_oid, buffer, size,
 606                                   TREE_DESC_RAW_MODES)) {
 607                 retval += report(options, tree_oid, OBJ_TREE,
 608                                  FSCK_MSG_BAD_TREE,
 609                                  "cannot be parsed as a tree");
 610                 return retval;
 611         }
 612
 613         o_mode = 0;
 614         o_name = NULL;
 615
 616         while (desc.size) {
 617                 unsigned short mode;
 618                 const char *name, *backslash;
 619                 const struct object_id *entry_oid;
 620
 621                 entry_oid = tree_entry_extract(&desc, &name, &mode);
 622
 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;
 631
 632                 if (is_hfs_dotgitmodules(name) || is_ntfs_dotgitmodules(name)) {
 633                         if (!S_ISLNK(mode))
 634                                 oidset_insert(&options->gitmodules_found,
 635                                               entry_oid);
 636                         else
 637                                 retval += report(options,
 638                                                  tree_oid, OBJ_TREE,
 639                                                  FSCK_MSG_GITMODULES_SYMLINK,
 640                                                  ".gitmodules is a symbolic link");
 641                 }
 642
 643                 if (is_hfs_dotgitattributes(name) || is_ntfs_dotgitattributes(name)) {
 644                         if (!S_ISLNK(mode))
 645                                 oidset_insert(&options->gitattributes_found,
 646                                               entry_oid);
 647                         else
 648                                 retval += report(options, tree_oid, OBJ_TREE,
 649                                                  FSCK_MSG_GITATTRIBUTES_SYMLINK,
 650                                                  ".gitattributes is a symlink");
 651                 }
 652
 653                 if (S_ISLNK(mode)) {
 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");
 664                 }
 665
 666                 if ((backslash = strchr(name, '\\'))) {
 667                         while (backslash) {
 668                                 backslash++;
 669                                 has_dotgit |= is_ntfs_dotgit(backslash);
 670                                 if (is_ntfs_dotgitmodules(backslash)) {
 671                                         if (!S_ISLNK(mode))
 672                                                 oidset_insert(&options->gitmodules_found,
 673                                                               entry_oid);
 674                                         else
 675                                                 retval += report(options, tree_oid, OBJ_TREE,
 676                                                                  FSCK_MSG_GITMODULES_SYMLINK,
 677                                                                  ".gitmodules is a symbolic link");
 678                                 }
 679                                 backslash = strchr(backslash, '\\');
 680                         }
 681                 }
 682
 683                 if (update_tree_entry_gently(&desc)) {
 684                         retval += report(options, tree_oid, OBJ_TREE,
 685                                          FSCK_MSG_BAD_TREE,
 686                                          "cannot be parsed as a tree");
 687                         break;
 688                 }
 689
 690                 switch (mode) {
 691                 /*
 692                  * Standard modes..
 693                  */
 694                 case S_IFREG | 0755:
 695                 case S_IFREG | 0644:
 696                 case S_IFLNK:
 697                 case S_IFDIR:
 698                 case S_IFGITLINK:
 699                         break;
 700                 /*
 701                  * This is nonstandard, but we had a few of these
 702                  * early on when we honored the full set of mode
 703                  * bits..
 704                  */
 705                 case S_IFREG | 0664:
 706                         if (!options->strict)
 707                                 break;
 708                         /* fallthrough */
 709                 default:
 710                         has_bad_modes = 1;
 711                 }
 712
 713                 if (o_name) {
 714                         switch (verify_ordered(o_mode, o_name, mode, name,
 715                                                &df_dup_candidates)) {
 716                         case TREE_UNORDERED:
 717                                 not_properly_sorted = 1;
 718                                 break;
 719                         case TREE_HAS_DUPS:
 720                                 has_dup_entries = 1;
 721                                 break;
 722                         default:
 723                                 break;
 724                         }
 725                 }
 726
 727                 o_mode = mode;
 728                 o_name = name;
 729         }
 730
 731         name_stack_clear(&df_dup_candidates);
 732
 733         if (has_null_sha1)
 734                 retval += report(options, tree_oid, OBJ_TREE,
 735                                  FSCK_MSG_NULL_SHA1,
 736                                  "contains entries pointing to null sha1");
 737         if (has_full_path)
 738                 retval += report(options, tree_oid, OBJ_TREE,
 739                                  FSCK_MSG_FULL_PATHNAME,
 740                                  "contains full pathnames");
 741         if (has_empty_name)
 742                 retval += report(options, tree_oid, OBJ_TREE,
 743                                  FSCK_MSG_EMPTY_NAME,
 744                                  "contains empty pathname");
 745         if (has_dot)
 746                 retval += report(options, tree_oid, OBJ_TREE,
 747                                  FSCK_MSG_HAS_DOT,
 748                                  "contains '.'");
 749         if (has_dotdot)
 750                 retval += report(options, tree_oid, OBJ_TREE,
 751                                  FSCK_MSG_HAS_DOTDOT,
 752                                  "contains '..'");
 753         if (has_dotgit)
 754                 retval += report(options, tree_oid, OBJ_TREE,
 755                                  FSCK_MSG_HAS_DOTGIT,
 756                                  "contains '.git'");
 757         if (has_zero_pad)
 758                 retval += report(options, tree_oid, OBJ_TREE,
 759                                  FSCK_MSG_ZERO_PADDED_FILEMODE,
 760                                  "contains zero-padded file modes");
 761         if (has_bad_modes)
 762                 retval += report(options, tree_oid, OBJ_TREE,
 763                                  FSCK_MSG_BAD_FILEMODE,
 764                                  "contains bad file modes");
 765         if (has_dup_entries)
 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");
 773         if (has_large_name)
 774                 retval += report(options, tree_oid, OBJ_TREE,
 775                                  FSCK_MSG_LARGE_PATHNAME,
 776                                  "contains excessively large pathname");
 777         return retval;
 778 }
 779
 780 /*
 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.
 784  *
 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
 787  * size as long as:
 788  *
 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
 791  *     found here)
 792  *
 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().
 796  */
 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)
 800 {
 801         const char *buffer = (const char *)data;
 802         unsigned long i;
 803
 804         for (i = 0; i < size; i++) {
 805                 switch (buffer[i]) {
 806                 case '\0':
 807                         return report(options, oid, type,
 808                                 FSCK_MSG_NUL_IN_HEADER,
 809                                 "unterminated header: NUL at offset %ld", i);
 810                 case '\n':
 811                         if (i + 1 < size && buffer[i + 1] == '\n')
 812                                 return 0;
 813                 }
 814         }
 815
 816         /*
 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
 820          * line.
 821          */
 822         if (size && buffer[size - 1] == '\n')
 823                 return 0;
 824
 825         return report(options, oid, type,
 826                 FSCK_MSG_UNTERMINATED_HEADER, "unterminated header");
 827 }
 828
 829 static int fsck_ident(const char **ident,
 830                       const struct object_id *oid, enum object_type type,
 831                       struct fsck_options *options)
 832 {
 833         const char *p = *ident;
 834         char *end;
 835
 836         *ident = strchrnul(*ident, '\n');
 837         if (**ident == '\n')
 838                 (*ident)++;
 839
 840         if (*p == '<')
 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");
 843         if (*p == '>')
 844                 return report(options, oid, type, FSCK_MSG_BAD_NAME, "invalid author/committer line - bad name");
 845         if (*p != '<')
 846                 return report(options, oid, type, FSCK_MSG_MISSING_EMAIL, "invalid author/committer line - missing email");
 847         if (p[-1] != ' ')
 848                 return report(options, oid, type, FSCK_MSG_MISSING_SPACE_BEFORE_EMAIL, "invalid author/committer line - missing space before email");
 849         p++;
 850         p += strcspn(p, "<>\n");
 851         if (*p != '>')
 852                 return report(options, oid, type, FSCK_MSG_BAD_EMAIL, "invalid author/committer line - bad email");
 853         p++;
 854         if (*p != ' ')
 855                 return report(options, oid, type, FSCK_MSG_MISSING_SPACE_BEFORE_DATE, "invalid author/committer line - missing space before date");
 856         p++;
 857         /*
 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.
 865          */
 866         while (*p == ' ' || *p == '\t')
 867                 p++;
 868         if (!isdigit(*p))
 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");
 877         p = end + 1;
 878         if ((*p != '+' && *p != '-') ||
 879             !isdigit(p[1]) ||
 880             !isdigit(p[2]) ||
 881             !isdigit(p[3]) ||
 882             !isdigit(p[4]) ||
 883             (p[5] != '\n'))
 884                 return report(options, oid, type, FSCK_MSG_BAD_TIMEZONE, "invalid author/committer line - bad time zone");
 885         p += 6;
 886         return 0;
 887 }
 888
 889 static int fsck_commit(const struct object_id *oid,
 890                        const char *buffer, unsigned long size,
 891                        struct fsck_options *options)
 892 {
 893         struct object_id tree_oid, parent_oid;
 894         unsigned author_count;
 895         int err;
 896         const char *buffer_begin = buffer;
 897         const char *buffer_end = buffer + size;
 898         const char *p;
 899
 900         /*
 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.
 904          */
 905         if (verify_headers(buffer, size, oid, OBJ_COMMIT, options))
 906                 return -1;
 907
 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");
 912                 if (err)
 913                         return err;
 914         }
 915         buffer = p + 1;
 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");
 919                         if (err)
 920                                 return err;
 921                 }
 922                 buffer = p + 1;
 923         }
 924         author_count = 0;
 925         while (buffer < buffer_end && skip_prefix(buffer, "author ", &buffer)) {
 926                 author_count++;
 927                 err = fsck_ident(&buffer, oid, OBJ_COMMIT, options);
 928                 if (err)
 929                         return err;
 930         }
 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");
 935         if (err)
 936                 return err;
 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);
 940         if (err)
 941                 return err;
 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");
 945                 if (err)
 946                         return err;
 947         }
 948         return 0;
 949 }
 950
 951 static int fsck_tag(const struct object_id *oid, const char *buffer,
 952                     unsigned long size, struct fsck_options *options)
 953 {
 954         struct object_id tagged_oid;
 955         int tagged_type;
 956         return fsck_tag_standalone(oid, buffer, size, options, &tagged_oid,
 957                                    &tagged_type);
 958 }
 959
 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,
 963                         int *tagged_type)
 964 {
 965         int ret = 0;
 966         char *eol;
 967         struct strbuf sb = STRBUF_INIT;
 968         const char *buffer_end = buffer + size;
 969         const char *p;
 970
 971         /*
 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.
 975          */
 976         ret = verify_headers(buffer, size, oid, OBJ_TAG, options);
 977         if (ret)
 978                 goto done;
 979
 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");
 982                 goto done;
 983         }
 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");
 986                 if (ret)
 987                         goto done;
 988         }
 989         buffer = p + 1;
 990
 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");
 993                 goto done;
 994         }
 995         eol = memchr(buffer, '\n', buffer_end - buffer);
 996         if (!eol) {
 997                 ret = report(options, oid, OBJ_TAG, FSCK_MSG_MISSING_TYPE, "invalid format - unexpected end after 'type' line");
 998                 goto done;
 999         }
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");
1003         if (ret)
1004                 goto done;
1005         buffer = eol + 1;
1006
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");
1009                 goto done;
1010         }
1011         eol = memchr(buffer, '\n', buffer_end - buffer);
1012         if (!eol) {
1013                 ret = report(options, oid, OBJ_TAG, FSCK_MSG_MISSING_TAG, "invalid format - unexpected end after 'type' line");
1014                 goto done;
1015         }
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);
1022                 if (ret)
1023                         goto done;
1024         }
1025         buffer = eol + 1;
1026
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");
1030                 if (ret)
1031                         goto done;
1032         }
1033         else
1034                 ret = fsck_ident(&buffer, oid, OBJ_TAG, options);
1035
1036         if (buffer < buffer_end && !starts_with(buffer, "\n")) {
1037                 /*
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.
1043                  */
1044                 ret = report(options, oid, OBJ_TAG, FSCK_MSG_EXTRA_HEADER_ENTRY, "invalid format - extra header(s) after 'tagger'");
1045                 if (ret)
1046                         goto done;
1047         }
1048
1049 done:
1050         strbuf_release(&sb);
1051         return ret;
1052 }
1053
1054 struct fsck_gitmodules_data {
1055         const struct object_id *oid;
1056         struct fsck_options *options;
1057         int ret;
1058 };
1059
1060 static int fsck_gitmodules_fn(const char *var, const char *value,
1061                               const struct config_context *ctx UNUSED,
1062                               void *vdata)
1063 {
1064         struct fsck_gitmodules_data *data = vdata;
1065         const char *subsection, *key;
1066         size_t subsection_len;
1067         char *name;
1068
1069         if (parse_config_key(var, "submodule", &subsection, &subsection_len, &key) < 0 ||
1070             !subsection)
1071                 return 0;
1072
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",
1079                                     name);
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",
1086                                     value);
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",
1093                                     value);
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",
1099                                     value);
1100         free(name);
1101
1102         return 0;
1103 }
1104
1105 static int fsck_blob(const struct object_id *oid, const char *buf,
1106                      unsigned long size, struct fsck_options *options)
1107 {
1108         int ret = 0;
1109
1110         if (object_on_skiplist(options, oid))
1111                 return 0;
1112
1113         if (oidset_contains(&options->gitmodules_found, oid)) {
1114                 struct config_options config_opts = { 0 };
1115                 struct fsck_gitmodules_data data;
1116
1117                 oidset_insert(&options->gitmodules_done, oid);
1118
1119                 if (!buf) {
1120                         /*
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
1123                          * that an error.
1124                          */
1125                         return report(options, oid, OBJ_BLOB,
1126                                         FSCK_MSG_GITMODULES_LARGE,
1127                                         ".gitmodules too large to parse");
1128                 }
1129
1130                 data.oid = oid;
1131                 data.options = options;
1132                 data.ret = 0;
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");
1140                 ret |= data.ret;
1141         }
1142
1143         if (oidset_contains(&options->gitattributes_found, oid)) {
1144                 const char *ptr;
1145
1146                 oidset_insert(&options->gitattributes_done, oid);
1147
1148                 if (!buf || size > ATTR_MAX_FILE_SIZE) {
1149                         /*
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
1152                          * that an error.
1153                          */
1154                         return report(options, oid, OBJ_BLOB,
1155                                         FSCK_MSG_GITATTRIBUTES_LARGE,
1156                                         ".gitattributes too large to parse");
1157                 }
1158
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");
1165                                 break;
1166                         }
1167
1168                         ptr = *eol ? eol + 1 : eol;
1169                 }
1170         }
1171
1172         return ret;
1173 }
1174
1175 int fsck_object(struct object *obj, void *data, unsigned long size,
1176         struct fsck_options *options)
1177 {
1178         if (!obj)
1179                 return report(options, NULL, OBJ_NONE, FSCK_MSG_BAD_OBJECT_SHA1, "no valid object to fsck");
1180
1181         return fsck_buffer(&obj->oid, obj->type, data, size, options);
1182 }
1183
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)
1187 {
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);
1196
1197         return report(options, oid, type,
1198                       FSCK_MSG_UNKNOWN_TYPE,
1199                       "unknown type '%d' (internal fsck error)",
1200                       type);
1201 }
1202
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)
1209 {
1210         if (msg_type == FSCK_WARN) {
1211                 warning("object %s: %s", fsck_describe_object(o, oid), message);
1212                 return 0;
1213         }
1214         error("object %s: %s", fsck_describe_object(o, oid), message);
1215         return 1;
1216 }
1217
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)
1221 {
1222         int ret = 0;
1223         struct oidset_iter iter;
1224         const struct object_id *oid;
1225
1226         oidset_iter_init(blobs_found, &iter);
1227         while ((oid = oidset_iter_next(&iter))) {
1228                 enum object_type type;
1229                 unsigned long size;
1230                 char *buf;
1231
1232                 if (oidset_contains(blobs_done, oid))
1233                         continue;
1234
1235                 buf = repo_read_object_file(the_repository, oid, &type, &size);
1236                 if (!buf) {
1237                         if (is_promisor_object(oid))
1238                                 continue;
1239                         ret |= report(options,
1240                                       oid, OBJ_BLOB, msg_missing,
1241                                       "unable to read %s blob", blob_type);
1242                         continue;
1243                 }
1244
1245                 if (type == OBJ_BLOB)
1246                         ret |= fsck_blob(oid, buf, size, options);
1247                 else
1248                         ret |= report(options, oid, type, msg_type,
1249                                       "non-blob found at %s", blob_type);
1250                 free(buf);
1251         }
1252
1253         oidset_clear(blobs_found);
1254         oidset_clear(blobs_done);
1255
1256         return ret;
1257 }
1258
1259 int fsck_finish(struct fsck_options *options)
1260 {
1261         int ret = 0;
1262
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");
1269
1270         return ret;
1271 }
1272
1273 int git_fsck_config(const char *var, const char *value,
1274                     const struct config_context *ctx, void *cb)
1275 {
1276         struct fsck_options *options = cb;
1277         const char *msg_id;
1278
1279         if (strcmp(var, "fsck.skiplist") == 0) {
1280                 char *path;
1281                 struct strbuf sb = STRBUF_INIT;
1282
1283                 if (git_config_pathname(&path, var, value))
1284                         return 1;
1285                 strbuf_addf(&sb, "skiplist=%s", path);
1286                 free(path);
1287                 fsck_set_msg_types(options, sb.buf);
1288                 strbuf_release(&sb);
1289                 return 0;
1290         }
1291
1292         if (skip_prefix(var, "fsck.", &msg_id)) {
1293                 if (!value)
1294                         return config_error_nonbool(var);
1295                 fsck_set_msg_type(options, msg_id, value);
1296                 return 0;
1297         }
1298
1299         return git_default_config(var, value, ctx, cb);
1300 }
1301
1302 /*
1303  * Custom error callbacks that are used in more than one place.
1304  */
1305
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)
1312 {
1313         if (msg_id == FSCK_MSG_GITMODULES_MISSING) {
1314                 puts(oid_to_hex(oid));
1315                 return 0;
1316         }
1317         return fsck_error_function(o, oid, object_type, msg_type, msg_id, message);
1318 }