[PATCH] Update fsck-cache (take 2)

[git.git] / fsck-cache.c

diff --git a/fsck-cache.c b/fsck-cache.c
index 6c65f2b..eae73cc 100644 (file)
--- a/fsck-cache.c
+++ b/fsck-cache.c
@@ -12,6 +12,8 @@
 static int show_root = 0;
 static int show_tags = 0;
 static int show_unreachable = 0;
+static int standalone = 0;
+static int check_full = 0;
 static int keep_cache_objects = 0; 
 static unsigned char head_sha1[20];
 
@@ -25,12 +27,17 @@ static void check_connectivity(void)
                struct object_list *refs;
 
                if (!obj->parsed) {
-                       printf("missing %s %s\n", obj->type, sha1_to_hex(obj->sha1));
+                       if (!standalone && has_sha1_file(obj->sha1))
+                               ; /* it is in pack */
+                       else
+                               printf("missing %s %s\n",
+                                      obj->type, sha1_to_hex(obj->sha1));
                        continue;
                }
 
                for (refs = obj->refs; refs; refs = refs->next) {
-                       if (refs->item->parsed)
+                       if (refs->item->parsed ||
+                           (!standalone && has_sha1_file(refs->item->sha1)))
                                continue;
                        printf("broken link from %7s %s\n",
                               obj->type, sha1_to_hex(obj->sha1));
@@ -38,12 +45,9 @@ static void check_connectivity(void)
                               refs->item->type, sha1_to_hex(refs->item->sha1));
                }
 
-               /* Don't bother with tag reachability. */
-               if (obj->type == tag_type)
-                       continue;
-
                if (show_unreachable && !(obj->flags & REACHABLE)) {
-                       printf("unreachable %s %s\n", obj->type, sha1_to_hex(obj->sha1));
+                       printf("unreachable %s %s\n",
+                              obj->type, sha1_to_hex(obj->sha1));
                        continue;
                }
 
@@ -162,6 +166,8 @@ static int fsck_tree(struct tree *item)
 
 static int fsck_commit(struct commit *commit)
 {
+       free(commit->buffer);
+       commit->buffer = NULL;
        if (!commit->tree)
                return -1;
        if (!commit->parents && show_root)
@@ -315,15 +321,18 @@ static int read_sha1_reference(const char *path)
                return -1;
 
        obj = lookup_object(sha1);
-       if (!obj)
+       if (!obj) {
+               if (!standalone && has_sha1_file(sha1))
+                       return 0; /* it is in pack */
                return error("%s: invalid sha1 pointer %.40s", path, hexname);
+       }
 
        obj->used = 1;
        mark_reachable(obj, REACHABLE);
        return 0;
 }
 
-static void find_file_objects(const char *base, const char *name)
+static int find_file_objects(const char *base, const char *name)
 {
        int baselen = strlen(base);
        int namelen = strlen(name);
@@ -334,40 +343,52 @@ static void find_file_objects(const char *base, const char *name)
        path[baselen] = '/';
        memcpy(path + baselen + 1, name, namelen+1);
        if (stat(path, &st) < 0)
-               return;
+               return 0;
 
        /*
         * Recurse into directories
         */
        if (S_ISDIR(st.st_mode)) {
+               int count = 0;
                DIR *dir = opendir(path);
                if (dir) {
                        struct dirent *de;
                        while ((de = readdir(dir)) != NULL) {
                                if (de->d_name[0] == '.')
                                        continue;
-                               find_file_objects(path, de->d_name);
+                               count += find_file_objects(path, de->d_name);
                        }
                        closedir(dir);
                }
-               return;
-       }
-       if (S_ISREG(st.st_mode)) {
-               read_sha1_reference(path);
-               return;
+               return count;
        }
+       if (S_ISREG(st.st_mode))
+               return read_sha1_reference(path) == 0;
+       return 0;
 }
 
 static void get_default_heads(void)
 {
        char *git_dir = gitenv(GIT_DIR_ENVIRONMENT) ? : DEFAULT_GIT_DIR_ENVIRONMENT;
-       find_file_objects(git_dir, "refs");
+       int count = find_file_objects(git_dir, "refs");
+       if (!count)
+               die("No default references");
+}
+
+static void fsck_object_dir(const char *path)
+{
+       int i;
+       for (i = 0; i < 256; i++) {
+               static char dir[4096];
+               sprintf(dir, "%s/%02x", path, i);
+               fsck_dir(i, dir);
+       }
+       fsck_sha1_list();
 }
 
 int main(int argc, char **argv)
 {
        int i, heads;
-       char *sha1_dir;
 
        for (i = 1; i < argc; i++) {
                const char *arg = argv[i];
@@ -388,17 +409,45 @@ int main(int argc, char **argv)
                        keep_cache_objects = 1;
                        continue;
                }
+               if (!strcmp(arg, "--standalone")) {
+                       standalone = 1;
+                       continue;
+               }
+               if (!strcmp(arg, "--full")) {
+                       check_full = 1;
+                       continue;
+               }
                if (*arg == '-')
-                       usage("git-fsck-cache [--tags] [[--unreachable] [--cache] <head-sha1>*]");
+                       usage("git-fsck-cache [--tags] [[--unreachable] [--cache] [--standalone | --full] <head-sha1>*]");
        }
 
-       sha1_dir = get_object_directory();
-       for (i = 0; i < 256; i++) {
-               static char dir[4096];
-               sprintf(dir, "%s/%02x", sha1_dir, i);
-               fsck_dir(i, dir);
+       if (standalone && check_full)
+               die("Only one of --standalone or --full can be used.");
+       if (standalone)
+               unsetenv("GIT_ALTERNATE_OBJECT_DIRECTORIES");
+
+       fsck_object_dir(get_object_directory());
+       if (check_full) {
+               int j;
+               struct packed_git *p;
+               prepare_alt_odb();
+               for (j = 0; alt_odb[j].base; j++) {
+                       alt_odb[j].name[-1] = 0; /* was slash */
+                       fsck_object_dir(alt_odb[j].base);
+                       alt_odb[j].name[-1] = '/';
+               }
+               prepare_packed_git();
+               for (p = packed_git; p; p = p->next) {
+                       int num = num_packed_objects(p);
+                       for (i = 0; i < num; i++) {
+                               unsigned char sha1[20];
+                               nth_packed_object_sha1(p, i, sha1);
+                               if (fsck_sha1(sha1) < 0)
+                                       fprintf(stderr, "bad sha1 entry '%s'\n", sha1_to_hex(sha1));
+
+                       }
+               }
        }
-       fsck_sha1_list();
 
        heads = 0;
        for (i = 1; i < argc; i++) {
@@ -423,7 +472,7 @@ int main(int argc, char **argv)
        }
 
        /*
-        * If we've not been gived any explicit head information, do the
+        * If we've not been given any explicit head information, do the
         * default ones from .git/refs. We also consider the index file
         * in this case (ie this implies --cache).
         */