| #include "cache.h" |
| #include "object.h" |
| #include "blob.h" |
| #include "tree.h" |
| #include "tree-walk.h" |
| #include "commit.h" |
| #include "tag.h" |
| #include "fsck.h" |
| |
| static int fsck_walk_tree(struct tree *tree, fsck_walk_func walk, void *data) |
| { |
| struct tree_desc desc; |
| struct name_entry entry; |
| int res = 0; |
| |
| if (parse_tree(tree)) |
| return -1; |
| |
| init_tree_desc(&desc, tree->buffer, tree->size); |
| while (tree_entry(&desc, &entry)) { |
| int result; |
| |
| if (S_ISGITLINK(entry.mode)) |
| continue; |
| if (S_ISDIR(entry.mode)) |
| result = walk(&lookup_tree(entry.sha1)->object, OBJ_TREE, data); |
| else if (S_ISREG(entry.mode) || S_ISLNK(entry.mode)) |
| result = walk(&lookup_blob(entry.sha1)->object, OBJ_BLOB, data); |
| else { |
| result = error("in tree %s: entry %s has bad mode %.6o", |
| sha1_to_hex(tree->object.sha1), entry.path, entry.mode); |
| } |
| if (result < 0) |
| return result; |
| if (!res) |
| res = result; |
| } |
| return res; |
| } |
| |
| static int fsck_walk_commit(struct commit *commit, fsck_walk_func walk, void *data) |
| { |
| struct commit_list *parents; |
| int res; |
| int result; |
| |
| if (parse_commit(commit)) |
| return -1; |
| |
| result = walk((struct object *)commit->tree, OBJ_TREE, data); |
| if (result < 0) |
| return result; |
| res = result; |
| |
| parents = commit->parents; |
| while (parents) { |
| result = walk((struct object *)parents->item, OBJ_COMMIT, data); |
| if (result < 0) |
| return result; |
| if (!res) |
| res = result; |
| parents = parents->next; |
| } |
| return res; |
| } |
| |
| static int fsck_walk_tag(struct tag *tag, fsck_walk_func walk, void *data) |
| { |
| if (parse_tag(tag)) |
| return -1; |
| return walk(tag->tagged, OBJ_ANY, data); |
| } |
| |
| int fsck_walk(struct object *obj, fsck_walk_func walk, void *data) |
| { |
| if (!obj) |
| return -1; |
| switch (obj->type) { |
| case OBJ_BLOB: |
| return 0; |
| case OBJ_TREE: |
| return fsck_walk_tree((struct tree *)obj, walk, data); |
| case OBJ_COMMIT: |
| return fsck_walk_commit((struct commit *)obj, walk, data); |
| case OBJ_TAG: |
| return fsck_walk_tag((struct tag *)obj, walk, data); |
| default: |
| error("Unknown object type for %s", sha1_to_hex(obj->sha1)); |
| return -1; |
| } |
| } |
| |
| /* |
| * The entries in a tree are ordered in the _path_ order, |
| * which means that a directory entry is ordered by adding |
| * a slash to the end of it. |
| * |
| * So a directory called "a" is ordered _after_ a file |
| * called "a.c", because "a/" sorts after "a.c". |
| */ |
| #define TREE_UNORDERED (-1) |
| #define TREE_HAS_DUPS (-2) |
| |
| static int verify_ordered(unsigned mode1, const char *name1, unsigned mode2, const char *name2) |
| { |
| int len1 = strlen(name1); |
| int len2 = strlen(name2); |
| int len = len1 < len2 ? len1 : len2; |
| unsigned char c1, c2; |
| int cmp; |
| |
| cmp = memcmp(name1, name2, len); |
| if (cmp < 0) |
| return 0; |
| if (cmp > 0) |
| return TREE_UNORDERED; |
| |
| /* |
| * Ok, the first <len> characters are the same. |
| * Now we need to order the next one, but turn |
| * a '\0' into a '/' for a directory entry. |
| */ |
| c1 = name1[len]; |
| c2 = name2[len]; |
| if (!c1 && !c2) |
| /* |
| * git-write-tree used to write out a nonsense tree that has |
| * entries with the same name, one blob and one tree. Make |
| * sure we do not have duplicate entries. |
| */ |
| return TREE_HAS_DUPS; |
| if (!c1 && S_ISDIR(mode1)) |
| c1 = '/'; |
| if (!c2 && S_ISDIR(mode2)) |
| c2 = '/'; |
| return c1 < c2 ? 0 : TREE_UNORDERED; |
| } |
| |
| static int fsck_tree(struct tree *item, int strict, fsck_error error_func) |
| { |
| int retval; |
| int has_null_sha1 = 0; |
| int has_full_path = 0; |
| int has_empty_name = 0; |
| int has_dot = 0; |
| int has_dotdot = 0; |
| int has_dotgit = 0; |
| int has_zero_pad = 0; |
| int has_bad_modes = 0; |
| int has_dup_entries = 0; |
| int not_properly_sorted = 0; |
| struct tree_desc desc; |
| unsigned o_mode; |
| const char *o_name; |
| |
| init_tree_desc(&desc, item->buffer, item->size); |
| |
| o_mode = 0; |
| o_name = NULL; |
| |
| while (desc.size) { |
| unsigned mode; |
| const char *name; |
| const unsigned char *sha1; |
| |
| sha1 = tree_entry_extract(&desc, &name, &mode); |
| |
| if (is_null_sha1(sha1)) |
| has_null_sha1 = 1; |
| if (strchr(name, '/')) |
| has_full_path = 1; |
| if (!*name) |
| has_empty_name = 1; |
| if (!strcmp(name, ".")) |
| has_dot = 1; |
| if (!strcmp(name, "..")) |
| has_dotdot = 1; |
| if (!strcmp(name, ".git")) |
| has_dotgit = 1; |
| has_zero_pad |= *(char *)desc.buffer == '0'; |
| update_tree_entry(&desc); |
| |
| switch (mode) { |
| /* |
| * Standard modes.. |
| */ |
| case S_IFREG | 0755: |
| case S_IFREG | 0644: |
| case S_IFLNK: |
| case S_IFDIR: |
| case S_IFGITLINK: |
| break; |
| /* |
| * This is nonstandard, but we had a few of these |
| * early on when we honored the full set of mode |
| * bits.. |
| */ |
| case S_IFREG | 0664: |
| if (!strict) |
| break; |
| default: |
| has_bad_modes = 1; |
| } |
| |
| if (o_name) { |
| switch (verify_ordered(o_mode, o_name, mode, name)) { |
| case TREE_UNORDERED: |
| not_properly_sorted = 1; |
| break; |
| case TREE_HAS_DUPS: |
| has_dup_entries = 1; |
| break; |
| default: |
| break; |
| } |
| } |
| |
| o_mode = mode; |
| o_name = name; |
| } |
| |
| retval = 0; |
| if (has_null_sha1) |
| retval += error_func(&item->object, FSCK_WARN, "contains entries pointing to null sha1"); |
| if (has_full_path) |
| retval += error_func(&item->object, FSCK_WARN, "contains full pathnames"); |
| if (has_empty_name) |
| retval += error_func(&item->object, FSCK_WARN, "contains empty pathname"); |
| if (has_dot) |
| retval += error_func(&item->object, FSCK_WARN, "contains '.'"); |
| if (has_dotdot) |
| retval += error_func(&item->object, FSCK_WARN, "contains '..'"); |
| if (has_dotgit) |
| retval += error_func(&item->object, FSCK_WARN, "contains '.git'"); |
| if (has_zero_pad) |
| retval += error_func(&item->object, FSCK_WARN, "contains zero-padded file modes"); |
| if (has_bad_modes) |
| retval += error_func(&item->object, FSCK_WARN, "contains bad file modes"); |
| if (has_dup_entries) |
| retval += error_func(&item->object, FSCK_ERROR, "contains duplicate file entries"); |
| if (not_properly_sorted) |
| retval += error_func(&item->object, FSCK_ERROR, "not properly sorted"); |
| return retval; |
| } |
| |
| static int fsck_ident(char **ident, struct object *obj, fsck_error error_func) |
| { |
| if (**ident == '<') |
| return error_func(obj, FSCK_ERROR, "invalid author/committer line - missing space before email"); |
| *ident += strcspn(*ident, "<>\n"); |
| if (**ident == '>') |
| return error_func(obj, FSCK_ERROR, "invalid author/committer line - bad name"); |
| if (**ident != '<') |
| return error_func(obj, FSCK_ERROR, "invalid author/committer line - missing email"); |
| if ((*ident)[-1] != ' ') |
| return error_func(obj, FSCK_ERROR, "invalid author/committer line - missing space before email"); |
| (*ident)++; |
| *ident += strcspn(*ident, "<>\n"); |
| if (**ident != '>') |
| return error_func(obj, FSCK_ERROR, "invalid author/committer line - bad email"); |
| (*ident)++; |
| if (**ident != ' ') |
| return error_func(obj, FSCK_ERROR, "invalid author/committer line - missing space before date"); |
| (*ident)++; |
| if (**ident == '0' && (*ident)[1] != ' ') |
| return error_func(obj, FSCK_ERROR, "invalid author/committer line - zero-padded date"); |
| *ident += strspn(*ident, "0123456789"); |
| if (**ident != ' ') |
| return error_func(obj, FSCK_ERROR, "invalid author/committer line - bad date"); |
| (*ident)++; |
| if ((**ident != '+' && **ident != '-') || |
| !isdigit((*ident)[1]) || |
| !isdigit((*ident)[2]) || |
| !isdigit((*ident)[3]) || |
| !isdigit((*ident)[4]) || |
| ((*ident)[5] != '\n')) |
| return error_func(obj, FSCK_ERROR, "invalid author/committer line - bad time zone"); |
| (*ident) += 6; |
| return 0; |
| } |
| |
| static int fsck_commit(struct commit *commit, fsck_error error_func) |
| { |
| char *buffer = commit->buffer; |
| unsigned char tree_sha1[20], sha1[20]; |
| struct commit_graft *graft; |
| int parents = 0; |
| int err; |
| |
| if (commit->date == ULONG_MAX) |
| return error_func(&commit->object, FSCK_ERROR, "invalid author/committer line"); |
| |
| if (memcmp(buffer, "tree ", 5)) |
| return error_func(&commit->object, FSCK_ERROR, "invalid format - expected 'tree' line"); |
| if (get_sha1_hex(buffer+5, tree_sha1) || buffer[45] != '\n') |
| return error_func(&commit->object, FSCK_ERROR, "invalid 'tree' line format - bad sha1"); |
| buffer += 46; |
| while (!memcmp(buffer, "parent ", 7)) { |
| if (get_sha1_hex(buffer+7, sha1) || buffer[47] != '\n') |
| return error_func(&commit->object, FSCK_ERROR, "invalid 'parent' line format - bad sha1"); |
| buffer += 48; |
| parents++; |
| } |
| graft = lookup_commit_graft(commit->object.sha1); |
| if (graft) { |
| struct commit_list *p = commit->parents; |
| parents = 0; |
| while (p) { |
| p = p->next; |
| parents++; |
| } |
| if (graft->nr_parent == -1 && !parents) |
| ; /* shallow commit */ |
| else if (graft->nr_parent != parents) |
| return error_func(&commit->object, FSCK_ERROR, "graft objects missing"); |
| } else { |
| struct commit_list *p = commit->parents; |
| while (p && parents) { |
| p = p->next; |
| parents--; |
| } |
| if (p || parents) |
| return error_func(&commit->object, FSCK_ERROR, "parent objects missing"); |
| } |
| if (memcmp(buffer, "author ", 7)) |
| return error_func(&commit->object, FSCK_ERROR, "invalid format - expected 'author' line"); |
| buffer += 7; |
| err = fsck_ident(&buffer, &commit->object, error_func); |
| if (err) |
| return err; |
| if (memcmp(buffer, "committer ", strlen("committer "))) |
| return error_func(&commit->object, FSCK_ERROR, "invalid format - expected 'committer' line"); |
| buffer += strlen("committer "); |
| err = fsck_ident(&buffer, &commit->object, error_func); |
| if (err) |
| return err; |
| if (!commit->tree) |
| return error_func(&commit->object, FSCK_ERROR, "could not load commit's tree %s", sha1_to_hex(tree_sha1)); |
| |
| return 0; |
| } |
| |
| static int fsck_tag(struct tag *tag, fsck_error error_func) |
| { |
| struct object *tagged = tag->tagged; |
| |
| if (!tagged) |
| return error_func(&tag->object, FSCK_ERROR, "could not load tagged object"); |
| return 0; |
| } |
| |
| int fsck_object(struct object *obj, int strict, fsck_error error_func) |
| { |
| if (!obj) |
| return error_func(obj, FSCK_ERROR, "no valid object to fsck"); |
| |
| if (obj->type == OBJ_BLOB) |
| return 0; |
| if (obj->type == OBJ_TREE) |
| return fsck_tree((struct tree *) obj, strict, error_func); |
| if (obj->type == OBJ_COMMIT) |
| return fsck_commit((struct commit *) obj, error_func); |
| if (obj->type == OBJ_TAG) |
| return fsck_tag((struct tag *) obj, error_func); |
| |
| return error_func(obj, FSCK_ERROR, "unknown type '%d' (internal fsck error)", |
| obj->type); |
| } |
| |
| int fsck_error_function(struct object *obj, int type, const char *fmt, ...) |
| { |
| va_list ap; |
| struct strbuf sb = STRBUF_INIT; |
| |
| strbuf_addf(&sb, "object %s:", sha1_to_hex(obj->sha1)); |
| |
| va_start(ap, fmt); |
| strbuf_vaddf(&sb, fmt, ap); |
| va_end(ap); |
| |
| error("%s", sb.buf); |
| strbuf_release(&sb); |
| return 1; |
| } |
