Merge branch 'sb/branch-attributes'
[gitweb.git] / fsck-objects.c
index 1922b6d84c51588b22553141f608c9a07182560b..4d994f3fc83d71501bbfde5159a869b4f2a38e99 100644 (file)
@@ -9,15 +9,17 @@
 #include "refs.h"
 #include "pack.h"
 #include "cache-tree.h"
+#include "tree-walk.h"
 
 #define REACHABLE 0x0001
-
-static int show_root = 0;
-static int show_tags = 0;
-static int show_unreachable = 0;
-static int check_full = 0;
-static int check_strict = 0;
-static int keep_cache_objects = 0;
+#define SEEN      0x0002
+
+static int show_root;
+static int show_tags;
+static int show_unreachable;
+static int check_full;
+static int check_strict;
+static int keep_cache_objects;
 static unsigned char head_sha1[20];
 
 #ifdef NO_D_INO_IN_DIRENT
@@ -32,7 +34,7 @@ static void objreport(struct object *obj, const char *severity,
                       const char *err, va_list params)
 {
        fprintf(stderr, "%s in %s %s: ",
-               severity, obj->type, sha1_to_hex(obj->sha1));
+               severity, typename(obj->type), sha1_to_hex(obj->sha1));
        vfprintf(stderr, err, params);
        fputs("\n", stderr);
 }
@@ -58,11 +60,13 @@ static int objwarning(struct object *obj, const char *err, ...)
 
 static void check_connectivity(void)
 {
-       int i;
+       int i, max;
 
        /* Look up all the requirements, warn about missing objects.. */
-       for (i = 0; i < obj_allocs; i++) {
-               struct object *obj = objs[i];
+       max = get_max_object_index();
+       for (i = 0; i < max; i++) {
+               const struct object_refs *refs;
+               struct object *obj = get_indexed_object(i);
 
                if (!obj)
                        continue;
@@ -72,12 +76,12 @@ static void check_connectivity(void)
                                ; /* it is in pack */
                        else
                                printf("missing %s %s\n",
-                                      obj->type, sha1_to_hex(obj->sha1));
+                                      typename(obj->type), sha1_to_hex(obj->sha1));
                        continue;
                }
 
-               if (obj->refs) {
-                       const struct object_refs *refs = obj->refs;
+               refs = lookup_object_refs(obj);
+               if (refs) {
                        unsigned j;
                        for (j = 0; j < refs->count; j++) {
                                struct object *ref = refs->ref[j];
@@ -85,20 +89,20 @@ static void check_connectivity(void)
                                    (has_sha1_file(ref->sha1)))
                                        continue;
                                printf("broken link from %7s %s\n",
-                                      obj->type, sha1_to_hex(obj->sha1));
+                                      typename(obj->type), sha1_to_hex(obj->sha1));
                                printf("              to %7s %s\n",
-                                      ref->type, sha1_to_hex(ref->sha1));
+                                      typename(ref->type), sha1_to_hex(ref->sha1));
                        }
                }
 
                if (show_unreachable && !(obj->flags & REACHABLE)) {
                        printf("unreachable %s %s\n",
-                              obj->type, sha1_to_hex(obj->sha1));
+                              typename(obj->type), sha1_to_hex(obj->sha1));
                        continue;
                }
 
                if (!obj->used) {
-                       printf("dangling %s %s\n", obj->type, 
+                       printf("dangling %s %s\n", typename(obj->type),
                               sha1_to_hex(obj->sha1));
                }
        }
@@ -115,15 +119,15 @@ static void check_connectivity(void)
 #define TREE_UNORDERED (-1)
 #define TREE_HAS_DUPS  (-2)
 
-static int verify_ordered(struct tree_entry_list *a, struct tree_entry_list *b)
+static int verify_ordered(unsigned mode1, const char *name1, unsigned mode2, const char *name2)
 {
-       int len1 = strlen(a->name);
-       int len2 = strlen(b->name);
+       int len1 = strlen(name1);
+       int len2 = strlen(name2);
        int len = len1 < len2 ? len1 : len2;
        unsigned char c1, c2;
        int cmp;
 
-       cmp = memcmp(a->name, b->name, len);
+       cmp = memcmp(name1, name2, len);
        if (cmp < 0)
                return 0;
        if (cmp > 0)
@@ -134,8 +138,8 @@ static int verify_ordered(struct tree_entry_list *a, struct tree_entry_list *b)
         * Now we need to order the next one, but turn
         * a '\0' into a '/' for a directory entry.
         */
-       c1 = a->name[len];
-       c2 = b->name[len];
+       c1 = name1[len];
+       c2 = name2[len];
        if (!c1 && !c2)
                /*
                 * git-write-tree used to write out a nonsense tree that has
@@ -143,9 +147,9 @@ static int verify_ordered(struct tree_entry_list *a, struct tree_entry_list *b)
                 * sure we do not have duplicate entries.
                 */
                return TREE_HAS_DUPS;
-       if (!c1 && a->directory)
+       if (!c1 && S_ISDIR(mode1))
                c1 = '/';
-       if (!c2 && b->directory)
+       if (!c2 && S_ISDIR(mode2))
                c2 = '/';
        return c1 < c2 ? 0 : TREE_UNORDERED;
 }
@@ -158,17 +162,32 @@ static int fsck_tree(struct tree *item)
        int has_bad_modes = 0;
        int has_dup_entries = 0;
        int not_properly_sorted = 0;
-       struct tree_entry_list *entry, *last;
+       struct tree_desc desc;
+       unsigned o_mode;
+       const char *o_name;
+       const unsigned char *o_sha1;
+
+       desc.buf = item->buffer;
+       desc.size = item->size;
+
+       o_mode = 0;
+       o_name = NULL;
+       o_sha1 = NULL;
+       while (desc.size) {
+               unsigned mode;
+               const char *name;
+               const unsigned char *sha1;
 
-       last = NULL;
-       for (entry = item->entries; entry; entry = entry->next) {
-               if (strchr(entry->name, '/'))
+               sha1 = tree_entry_extract(&desc, &name, &mode);
+
+               if (strchr(name, '/'))
                        has_full_path = 1;
-               has_zero_pad |= entry->zeropad;
+               has_zero_pad |= *(char *)desc.buf == '0';
+               update_tree_entry(&desc);
 
-               switch (entry->mode) {
+               switch (mode) {
                /*
-                * Standard modes.. 
+                * Standard modes..
                 */
                case S_IFREG | 0755:
                case S_IFREG | 0644:
@@ -187,8 +206,8 @@ static int fsck_tree(struct tree *item)
                        has_bad_modes = 1;
                }
 
-               if (last) {
-                       switch (verify_ordered(last, entry)) {
+               if (o_name) {
+                       switch (verify_ordered(o_mode, o_name, mode, name)) {
                        case TREE_UNORDERED:
                                not_properly_sorted = 1;
                                break;
@@ -198,17 +217,14 @@ static int fsck_tree(struct tree *item)
                        default:
                                break;
                        }
-                       free(last->name);
-                       free(last);
                }
 
-               last = entry;
-       }
-       if (last) {
-               free(last->name);
-               free(last);
+               o_mode = mode;
+               o_name = name;
+               o_sha1 = sha1;
        }
-       item->entries = NULL;
+       free(item->buffer);
+       item->buffer = NULL;
 
        retval = 0;
        if (has_full_path) {
@@ -268,7 +284,7 @@ static int fsck_tag(struct tag *tag)
        if (!show_tags)
                return 0;
 
-       printf("tagged %s %s", tagged->type, sha1_to_hex(tagged->sha1));
+       printf("tagged %s %s", typename(tagged->type), sha1_to_hex(tagged->sha1));
        printf(" (%s) in %s\n", tag->tag, sha1_to_hex(tag->object.sha1));
        return 0;
 }
@@ -278,16 +294,19 @@ static int fsck_sha1(unsigned char *sha1)
        struct object *obj = parse_object(sha1);
        if (!obj)
                return error("%s: object not found", sha1_to_hex(sha1));
-       if (obj->type == blob_type)
+       if (obj->flags & SEEN)
+               return 0;
+       obj->flags |= SEEN;
+       if (obj->type == OBJ_BLOB)
                return 0;
-       if (obj->type == tree_type)
+       if (obj->type == OBJ_TREE)
                return fsck_tree((struct tree *) obj);
-       if (obj->type == commit_type)
+       if (obj->type == OBJ_COMMIT)
                return fsck_commit((struct commit *) obj);
-       if (obj->type == tag_type)
+       if (obj->type == OBJ_TAG)
                return fsck_tag((struct tag *) obj);
        /* By now, parse_object() would've returned NULL instead. */
-       return objerror(obj, "unknown type '%s' (internal fsck error)", obj->type);
+       return objerror(obj, "unknown type '%d' (internal fsck error)", obj->type);
 }
 
 /*
@@ -337,7 +356,7 @@ static void add_sha1_list(unsigned char *sha1, unsigned long ino)
        int nr;
 
        entry->ino = ino;
-       memcpy(entry->sha1, sha1, 20);
+       hashcpy(entry->sha1, sha1);
        nr = sha1_list.nr;
        if (nr == MAX_SHA1_ENTRIES) {
                fsck_sha1_list();
@@ -347,13 +366,13 @@ static void add_sha1_list(unsigned char *sha1, unsigned long ino)
        sha1_list.nr = ++nr;
 }
 
-static int fsck_dir(int i, char *path)
+static void fsck_dir(int i, char *path)
 {
        DIR *dir = opendir(path);
        struct dirent *de;
 
        if (!dir)
-               return 0;
+               return;
 
        while ((de = readdir(dir)) != NULL) {
                char name[100];
@@ -379,10 +398,9 @@ static int fsck_dir(int i, char *path)
                fprintf(stderr, "bad sha1 file: %s/%s\n", path, de->d_name);
        }
        closedir(dir);
-       return 0;
 }
 
-static int default_refs = 0;
+static int default_refs;
 
 static int fsck_handle_ref(const char *refname, const unsigned char *sha1)
 {
@@ -407,8 +425,23 @@ static int fsck_handle_ref(const char *refname, const unsigned char *sha1)
 static void get_default_heads(void)
 {
        for_each_ref(fsck_handle_ref);
-       if (!default_refs)
-               die("No default references");
+
+       /*
+        * Not having any default heads isn't really fatal, but
+        * it does mean that "--unreachable" no longer makes any
+        * sense (since in this case everything will obviously
+        * be unreachable by definition.
+        *
+        * Showing dangling objects is valid, though (as those
+        * dangling objects are likely lost heads).
+        *
+        * So we just print a warning about it, and clear the
+        * "show_unreachable" flag.
+        */
+       if (!default_refs) {
+               error("No default references");
+               show_unreachable = 0;
+       }
 }
 
 static void fsck_object_dir(const char *path)
@@ -425,7 +458,7 @@ static void fsck_object_dir(const char *path)
 static int fsck_head_link(void)
 {
        unsigned char sha1[20];
-       const char *git_HEAD = strdup(git_path("HEAD"));
+       const char *git_HEAD = xstrdup(git_path("HEAD"));
        const char *git_refs_heads_master = resolve_ref(git_HEAD, sha1, 1);
        int pfxlen = strlen(git_HEAD) - 4; /* strip .../.git/ part */
 
@@ -434,7 +467,7 @@ static int fsck_head_link(void)
        if (strncmp(git_refs_heads_master + pfxlen, "refs/heads/", 11))
                return error("HEAD points to something strange (%s)",
                             git_refs_heads_master + pfxlen);
-       if (!memcmp(null_sha1, sha1, 20))
+       if (is_null_sha1(sha1))
                return error("HEAD: not a valid git pointer");
        return 0;
 }
@@ -453,7 +486,7 @@ static int fsck_cache_tree(struct cache_tree *it)
                }
                mark_reachable(obj, REACHABLE);
                obj->used = 1;
-               if (obj->type != tree_type)
+               if (obj->type != OBJ_TREE)
                        err |= objerror(obj, "non-tree in cache-tree");
        }
        for (i = 0; i < it->subtree_nr; i++)
@@ -465,6 +498,7 @@ int main(int argc, char **argv)
 {
        int i, heads;
 
+       track_object_refs = 1;
        setup_git_directory();
 
        for (i = 1; i < argc; i++) {