Suppress some bash redirection error messages
[gitweb.git] / pack-check.c
index 3623c716e3e3b7d4a28800e34afd0e5f0e13a43d..f596bf2db5e0a0065e6856b8caa3ded8a134f74d 100644 (file)
@@ -1,5 +1,46 @@
 #include "cache.h"
 #include "pack.h"
+#include "pack-revindex.h"
+
+struct idx_entry
+{
+       off_t                offset;
+       const unsigned char *sha1;
+       unsigned int nr;
+};
+
+static int compare_entries(const void *e1, const void *e2)
+{
+       const struct idx_entry *entry1 = e1;
+       const struct idx_entry *entry2 = e2;
+       if (entry1->offset < entry2->offset)
+               return -1;
+       if (entry1->offset > entry2->offset)
+               return 1;
+       return 0;
+}
+
+int check_pack_crc(struct packed_git *p, struct pack_window **w_curs,
+                  off_t offset, off_t len, unsigned int nr)
+{
+       const uint32_t *index_crc;
+       uint32_t data_crc = crc32(0, Z_NULL, 0);
+
+       do {
+               unsigned int avail;
+               void *data = use_pack(p, w_curs, offset, &avail);
+               if (avail > len)
+                       avail = len;
+               data_crc = crc32(data_crc, data, avail);
+               offset += avail;
+               len -= avail;
+       } while (len);
+
+       index_crc = p->index_data;
+       index_crc += 2 + 256 + p->num_objects * (20/4) + nr;
+
+       return data_crc != ntohl(*index_crc);
+}
 
 static int verify_packfile(struct packed_git *p,
                struct pack_window **w_curs)
@@ -7,10 +48,11 @@ static int verify_packfile(struct packed_git *p,
        off_t index_size = p->index_size;
        const unsigned char *index_base = p->index_data;
        SHA_CTX ctx;
-       unsigned char sha1[20];
-       off_t offset = 0, pack_sig = p->pack_size - 20;
+       unsigned char sha1[20], *pack_sig;
+       off_t offset = 0, pack_sig_ofs = p->pack_size - 20;
        uint32_t nr_objects, i;
-       int err;
+       int err = 0;
+       struct idx_entry *entries;
 
        /* Note that the pack header checks are actually performed by
         * use_pack when it first opens the pack file.  If anything
@@ -19,21 +61,22 @@ static int verify_packfile(struct packed_git *p,
         */
 
        SHA1_Init(&ctx);
-       while (offset < pack_sig) {
+       while (offset < pack_sig_ofs) {
                unsigned int remaining;
                unsigned char *in = use_pack(p, w_curs, offset, &remaining);
                offset += remaining;
-               if (offset > pack_sig)
-                       remaining -= (unsigned int)(offset - pack_sig);
+               if (offset > pack_sig_ofs)
+                       remaining -= (unsigned int)(offset - pack_sig_ofs);
                SHA1_Update(&ctx, in, remaining);
        }
        SHA1_Final(sha1, &ctx);
-       if (hashcmp(sha1, use_pack(p, w_curs, pack_sig, NULL)))
-               return error("Packfile %s SHA1 mismatch with itself",
-                            p->pack_name);
-       if (hashcmp(sha1, index_base + index_size - 40))
-               return error("Packfile %s SHA1 mismatch with idx",
-                            p->pack_name);
+       pack_sig = use_pack(p, w_curs, pack_sig_ofs, NULL);
+       if (hashcmp(sha1, pack_sig))
+               err = error("%s SHA1 checksum mismatch",
+                           p->pack_name);
+       if (hashcmp(index_base + index_size - 40, pack_sig))
+               err = error("%s SHA1 does not match its inddex",
+                           p->pack_name);
        unuse_pack(w_curs);
 
        /* Make sure everything reachable from idx is valid.  Since we
@@ -41,128 +84,78 @@ static int verify_packfile(struct packed_git *p,
         * we do not do scan-streaming check on the pack file.
         */
        nr_objects = p->num_objects;
-       for (i = 0, err = 0; i < nr_objects; i++) {
-               const unsigned char *sha1;
+       entries = xmalloc((nr_objects + 1) * sizeof(*entries));
+       entries[nr_objects].offset = pack_sig_ofs;
+       /* first sort entries by pack offset, since unpacking them is more efficient that way */
+       for (i = 0; i < nr_objects; i++) {
+               entries[i].sha1 = nth_packed_object_sha1(p, i);
+               if (!entries[i].sha1)
+                       die("internal error pack-check nth-packed-object");
+               entries[i].offset = nth_packed_object_offset(p, i);
+               entries[i].nr = i;
+       }
+       qsort(entries, nr_objects, sizeof(*entries), compare_entries);
+
+       for (i = 0; i < nr_objects; i++) {
                void *data;
                enum object_type type;
                unsigned long size;
-               off_t offset;
 
-               sha1 = nth_packed_object_sha1(p, i);
-               if (!sha1)
-                       die("internal error pack-check nth-packed-object");
-               offset = find_pack_entry_one(sha1, p);
-               if (!offset)
-                       die("internal error pack-check find-pack-entry-one");
-               data = unpack_entry(p, offset, &type, &size);
+               if (p->index_version > 1) {
+                       off_t offset = entries[i].offset;
+                       off_t len = entries[i+1].offset - offset;
+                       unsigned int nr = entries[i].nr;
+                       if (check_pack_crc(p, w_curs, offset, len, nr))
+                               err = error("index CRC mismatch for object %s "
+                                           "from %s at offset %"PRIuMAX"",
+                                           sha1_to_hex(entries[i].sha1),
+                                           p->pack_name, (uintmax_t)offset);
+               }
+               data = unpack_entry(p, entries[i].offset, &type, &size);
                if (!data) {
-                       err = error("cannot unpack %s from %s",
-                                   sha1_to_hex(sha1), p->pack_name);
-                       continue;
+                       err = error("cannot unpack %s from %s at offset %"PRIuMAX"",
+                                   sha1_to_hex(entries[i].sha1), p->pack_name,
+                                   (uintmax_t)entries[i].offset);
+                       break;
                }
-               if (check_sha1_signature(sha1, data, size, typename(type))) {
+               if (check_sha1_signature(entries[i].sha1, data, size, typename(type))) {
                        err = error("packed %s from %s is corrupt",
-                                   sha1_to_hex(sha1), p->pack_name);
+                                   sha1_to_hex(entries[i].sha1), p->pack_name);
                        free(data);
-                       continue;
+                       break;
                }
                free(data);
        }
+       free(entries);
 
        return err;
 }
 
-
-#define MAX_CHAIN 50
-
-static void show_pack_info(struct packed_git *p)
-{
-       uint32_t nr_objects, i, chain_histogram[MAX_CHAIN+1];
-       nr_objects = p->num_objects;
-       memset(chain_histogram, 0, sizeof(chain_histogram));
-
-       for (i = 0; i < nr_objects; i++) {
-               const unsigned char *sha1;
-               unsigned char base_sha1[20];
-               const char *type;
-               unsigned long size;
-               unsigned long store_size;
-               off_t offset;
-               unsigned int delta_chain_length;
-
-               sha1 = nth_packed_object_sha1(p, i);
-               if (!sha1)
-                       die("internal error pack-check nth-packed-object");
-               offset = find_pack_entry_one(sha1, p);
-               if (!offset)
-                       die("internal error pack-check find-pack-entry-one");
-
-               type = packed_object_info_detail(p, offset, &size, &store_size,
-                                                &delta_chain_length,
-                                                base_sha1);
-               printf("%s ", sha1_to_hex(sha1));
-               if (!delta_chain_length)
-                       printf("%-6s %lu %"PRIuMAX"\n",
-                              type, size, (uintmax_t)offset);
-               else {
-                       printf("%-6s %lu %"PRIuMAX" %u %s\n",
-                              type, size, (uintmax_t)offset,
-                              delta_chain_length, sha1_to_hex(base_sha1));
-                       if (delta_chain_length <= MAX_CHAIN)
-                               chain_histogram[delta_chain_length]++;
-                       else
-                               chain_histogram[0]++;
-               }
-       }
-
-       for (i = 0; i <= MAX_CHAIN; i++) {
-               if (!chain_histogram[i])
-                       continue;
-               printf("chain length = %d: %d object%s\n", i,
-                      chain_histogram[i], chain_histogram[i] > 1 ? "s" : "");
-       }
-       if (chain_histogram[0])
-               printf("chain length > %d: %d object%s\n", MAX_CHAIN,
-                      chain_histogram[0], chain_histogram[0] > 1 ? "s" : "");
-}
-
-int verify_pack(struct packed_git *p, int verbose)
+int verify_pack(struct packed_git *p)
 {
        off_t index_size;
        const unsigned char *index_base;
        SHA_CTX ctx;
        unsigned char sha1[20];
-       int ret;
+       int err = 0;
+       struct pack_window *w_curs = NULL;
 
        if (open_pack_index(p))
                return error("packfile %s index not opened", p->pack_name);
        index_size = p->index_size;
        index_base = p->index_data;
 
-       ret = 0;
        /* Verify SHA1 sum of the index file */
        SHA1_Init(&ctx);
        SHA1_Update(&ctx, index_base, (unsigned int)(index_size - 20));
        SHA1_Final(sha1, &ctx);
        if (hashcmp(sha1, index_base + index_size - 20))
-               ret = error("Packfile index for %s SHA1 mismatch",
+               err = error("Packfile index for %s SHA1 mismatch",
                            p->pack_name);
 
-       if (!ret) {
-               /* Verify pack file */
-               struct pack_window *w_curs = NULL;
-               ret = verify_packfile(p, &w_curs);
-               unuse_pack(&w_curs);
-       }
+       /* Verify pack file */
+       err |= verify_packfile(p, &w_curs);
+       unuse_pack(&w_curs);
 
-       if (verbose) {
-               if (ret)
-                       printf("%s: bad\n", p->pack_name);
-               else {
-                       show_pack_info(p);
-                       printf("%s: ok\n", p->pack_name);
-               }
-       }
-
-       return ret;
+       return err;
 }