Andrew's git - gitweb.git/blob

a62eeb432d33bdfe4b609e11d48c72a81832874b
   1#include "cache.h"
   2#include "object.h"
   3#include "delta.h"
   4
   5static int dry_run;
   6static int nr_entries;
   7static const char *base_name;
   8static const char unpack_usage[] = "git-unpack-objects basename";
   9
  10struct pack_entry {
  11        unsigned int offset; /* network byte order */
  12        unsigned char sha1[20];
  13};
  14
  15static void *pack_base;
  16static unsigned long pack_size;
  17static void *index_base;
  18static unsigned long index_size;
  19
  20static struct pack_entry **pack_list;
  21
  22static void *map_file(const char *suffix, unsigned long *sizep)
  23{
  24        static char pathname[PATH_MAX];
  25        unsigned long len;
  26        int fd;
  27        struct stat st;
  28        void *map;
  29
  30        len = snprintf(pathname, PATH_MAX, "%s.%s", base_name, suffix);
  31        if (len >= PATH_MAX)
  32                die("bad pack base-name");
  33        fd = open(pathname, O_RDONLY);
  34        if (fd < 0 || fstat(fd, &st))
  35                die("unable to open '%s'", pathname);
  36        len = st.st_size;
  37        if (!len)
  38                die("bad pack file '%s'", pathname);
  39        map = mmap(NULL, len, PROT_READ, MAP_PRIVATE, fd, 0);
  40        if (-1 == (int)(long)map)
  41                die("unable to mmap '%s'", pathname);
  42        close(fd);
  43        *sizep = len;
  44        return map;
  45}
  46
  47static int sort_by_offset(const void *_a, const void *_b)
  48{
  49        struct pack_entry *a = *(struct pack_entry **)_a;
  50        struct pack_entry *b = *(struct pack_entry **)_b;
  51        unsigned int o1, o2;
  52
  53        o1 = ntohl(a->offset);
  54        o2 = ntohl(b->offset);
  55        return o1 < o2 ? -1 : 1;
  56}
  57
  58static int check_index(void)
  59{
  60        unsigned int *array = index_base;
  61        unsigned int nr;
  62        int i;
  63
  64        if (index_size < 4*256)
  65                return error("index file too small");
  66        nr = 0;
  67        for (i = 0; i < 256; i++) {
  68                unsigned int n = ntohl(array[i]);
  69                if (n < nr)
  70                        return error("non-monotonic index");
  71                nr = n;
  72        }
  73        if (index_size != 4*256 + nr * 24) {
  74                printf("index_size=%lu, expected %u (%u)\n",
  75                       index_size, 4*256 + nr * 24, nr);
  76                return error("wrong index file size");
  77        }
  78
  79        nr_entries = nr;
  80        pack_list = xmalloc(nr * sizeof(struct pack_entry *));
  81        for (i = 0; i < nr; i++)
  82                pack_list[i] = index_base + 4*256 + i*24;
  83
  84        qsort(pack_list, nr, sizeof(*pack_list), sort_by_offset);
  85
  86        printf("%d entries\n", nr);
  87        return 0;
  88}
  89
  90static int unpack_non_delta_entry(struct pack_entry *entry,
  91                                  int kind,
  92                                  unsigned char *data,
  93                                  unsigned long size,
  94                                  unsigned long left)
  95{
  96        int st;
  97        z_stream stream;
  98        char *buffer;
  99        unsigned char sha1[20];
 100        char *type_s;
 101
 102        printf("%s %c %lu\n", sha1_to_hex(entry->sha1), kind, size);
 103        if (dry_run)
 104                return 0;
 105
 106        buffer = xmalloc(size + 1);
 107        buffer[size] = 0;
 108        memset(&stream, 0, sizeof(stream));
 109        stream.next_in = data;
 110        stream.avail_in = left;
 111        stream.next_out = buffer;
 112        stream.avail_out = size;
 113
 114        inflateInit(&stream);
 115        st = inflate(&stream, Z_FINISH);
 116        inflateEnd(&stream);
 117        if ((st != Z_STREAM_END) || stream.total_out != size)
 118                goto err_finish;
 119        switch (kind) {
 120        case 'C': type_s = "commit"; break;
 121        case 'T': type_s = "tree"; break;
 122        case 'B': type_s = "blob"; break;
 123        default: goto err_finish;
 124        }
 125        if (write_sha1_file(buffer, size, type_s, sha1) < 0)
 126                die("failed to write %s (%s)",
 127                    sha1_to_hex(entry->sha1), type_s);
 128        printf("%s %s\n", sha1_to_hex(sha1), type_s);
 129        if (memcmp(sha1, entry->sha1, 20))
 130                die("resulting %s have wrong SHA1", type_s);
 131
 132 finish:
 133        st = 0;
 134        free(buffer);
 135        return st;
 136 err_finish:
 137        st = -1;
 138        goto finish;
 139}
 140
 141static int find_pack_entry(unsigned char *sha1, struct pack_entry **ent)
 142{
 143        int *level1_ofs = index_base;
 144        int hi = ntohl(level1_ofs[*sha1]);
 145        int lo = ((*sha1 == 0x0) ? 0 : ntohl(level1_ofs[*sha1 - 1]));
 146        void *index = index_base + 4*256;
 147
 148        do {
 149                int mi = (lo + hi) / 2;
 150                int cmp = memcmp(index + 24 * mi + 4, sha1, 20);
 151printf("lo=%d mi=%d hi=%d cmp=%d\n", lo, mi, hi, cmp);
 152                if (!cmp) {
 153                        *ent = index + 24 * mi;
 154                        return 1;
 155                }
 156                if (cmp > 0)
 157                        hi = mi;
 158                else
 159                        lo = mi+1;
 160        } while (lo < hi);
 161        return 0;
 162}
 163
 164/* forward declaration for a mutually recursive function */
 165static void unpack_entry(struct pack_entry *);
 166
 167static int unpack_delta_entry(struct pack_entry *entry,
 168                              unsigned char *base_sha1,
 169                              unsigned long delta_size,
 170                              unsigned long left)
 171{
 172        void *data, *delta_data, *result, *base;
 173        unsigned long data_size, result_size, base_size;
 174        z_stream stream;
 175        int st;
 176        char type[20];
 177        unsigned char sha1[20];
 178
 179        if (left < 20)
 180                die("truncated pack file");
 181        data = base_sha1 + 20;
 182        data_size = left - 20;
 183        printf("%s D %lu", sha1_to_hex(entry->sha1), delta_size);
 184        printf(" %s\n", sha1_to_hex(base_sha1));
 185
 186        if (dry_run)
 187                return 0;
 188
 189        /* pack+5 is the base sha1, unless we have it, we need to
 190         * unpack it first.
 191         */
 192        if (!has_sha1_file(base_sha1)) {
 193                struct pack_entry *base;
 194                if (!find_pack_entry(base_sha1, &base))
 195                        die("cannot find delta-pack base object");
 196                unpack_entry(base);
 197        }
 198        delta_data = xmalloc(delta_size);
 199
 200        memset(&stream, 0, sizeof(stream));
 201
 202        stream.next_in = data;
 203        stream.avail_in = data_size;
 204        stream.next_out = delta_data;
 205        stream.avail_out = delta_size;
 206
 207        inflateInit(&stream);
 208        st = inflate(&stream, Z_FINISH);
 209        inflateEnd(&stream);
 210        if ((st != Z_STREAM_END) || stream.total_out != delta_size)
 211                die("delta data unpack failed");
 212
 213        base = read_sha1_file(base_sha1, type, &base_size);
 214        if (!base)
 215                die("failed to read delta-pack base object %s", sha1_to_hex(base_sha1));
 216        result = patch_delta(base, base_size,
 217                             delta_data, delta_size,
 218                             &result_size);
 219        if (!result)
 220                die("failed to apply delta");
 221        free(delta_data);
 222
 223        if (write_sha1_file(result, result_size, type, sha1) < 0)
 224                die("failed to write %s (%s)",
 225                    sha1_to_hex(entry->sha1), type);
 226        free(result);
 227        printf("%s %s\n", sha1_to_hex(sha1), type);
 228        if (memcmp(sha1, entry->sha1, 20))
 229                die("resulting %s have wrong SHA1", type);
 230        return 0;
 231}
 232
 233static void unpack_entry(struct pack_entry *entry)
 234{
 235        unsigned long offset, size, left;
 236        unsigned char *pack;
 237
 238        /* Have we done this one already due to deltas based on it? */
 239        if (lookup_object(entry->sha1))
 240                return;
 241
 242        offset = ntohl(entry->offset);
 243        if (offset > pack_size - 5)
 244                die("object offset outside of pack file");
 245        pack = pack_base + offset;
 246        size = (pack[1] << 24) + (pack[2] << 16) + (pack[3] << 8) + pack[4];
 247        left = pack_size - offset - 5;
 248        switch (*pack) {
 249        case 'C': case 'T': case 'B':
 250                unpack_non_delta_entry(entry, *pack, pack+5, size, left);
 251                break;
 252        case 'D':
 253                unpack_delta_entry(entry, pack+5, size, left);
 254                break;
 255        default:
 256                die("corrupted pack file");
 257        }
 258}
 259
 260/*
 261 * We unpack from the end, older files first. Now, usually
 262 * there are deltas etc, so we'll not actually write the
 263 * objects in that order, but we might as well try..
 264 */
 265static void unpack_all(void)
 266{
 267        int i = nr_entries;
 268
 269        while (--i >= 0) {
 270                struct pack_entry *entry = pack_list[i];
 271                unpack_entry(entry);
 272        }
 273}
 274
 275int main(int argc, char **argv)
 276{
 277        int i;
 278
 279        for (i = 1 ; i < argc; i++) {
 280                const char *arg = argv[i];
 281
 282                if (*arg == '-') {
 283                        if (!strcmp(arg, "-n")) {
 284                                dry_run = 1;
 285                                continue;
 286                        }
 287                        usage(unpack_usage);
 288                }
 289                if (base_name)
 290                        usage(unpack_usage);
 291                base_name = arg;
 292        }
 293        if (!base_name)
 294                usage(unpack_usage);
 295        index_base = map_file("idx", &index_size);
 296        pack_base = map_file("pack", &pack_size);
 297        if (check_index() < 0)
 298                die("bad index file");
 299        unpack_all();
 300        return 0;
 301}