unpack-objects.c

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