builtin-unpack-objects.c

   1 #include "builtin.h"
   2 #include "cache.h"
   3 #include "object.h"
   4 #include "delta.h"
   5 #include "pack.h"
   6 #include "blob.h"
   7 #include "commit.h"
   8 #include "tag.h"
   9 #include "tree.h"
  10 #include "progress.h"
  11
  12 static int dry_run, quiet, recover, has_errors;
  13 static const char unpack_usage[] = "git-unpack-objects [-n] [-q] [-r] < pack-file";
  14
  15 /* We always read in 4kB chunks. */
  16 static unsigned char buffer[4096];
  17 static unsigned int offset, len;
  18 static off_t consumed_bytes;
  19 static SHA_CTX ctx;
  20
  21 /*
  22  * Make sure at least "min" bytes are available in the buffer, and
  23  * return the pointer to the buffer.
  24  */
  25 static void *fill(int min)
  26 {
  27         if (min <= len)
  28                 return buffer + offset;
  29         if (min > sizeof(buffer))
  30                 die("cannot fill %d bytes", min);
  31         if (offset) {
  32                 SHA1_Update(&ctx, buffer, offset);
  33                 memmove(buffer, buffer + offset, len);
  34                 offset = 0;
  35         }
  36         do {
  37                 ssize_t ret = xread(0, buffer + len, sizeof(buffer) - len);
  38                 if (ret <= 0) {
  39                         if (!ret)
  40                                 die("early EOF");
  41                         die("read error on input: %s", strerror(errno));
  42                 }
  43                 len += ret;
  44         } while (len < min);
  45         return buffer;
  46 }
  47
  48 static void use(int bytes)
  49 {
  50         if (bytes > len)
  51                 die("used more bytes than were available");
  52         len -= bytes;
  53         offset += bytes;
  54
  55         /* make sure off_t is sufficiently large not to wrap */
  56         if (consumed_bytes > consumed_bytes + bytes)
  57                 die("pack too large for current definition of off_t");
  58         consumed_bytes += bytes;
  59 }
  60
  61 static void *get_data(unsigned long size)
  62 {
  63         z_stream stream;
  64         void *buf = xmalloc(size);
  65
  66         memset(&stream, 0, sizeof(stream));
  67
  68         stream.next_out = buf;
  69         stream.avail_out = size;
  70         stream.next_in = fill(1);
  71         stream.avail_in = len;
  72         inflateInit(&stream);
  73
  74         for (;;) {
  75                 int ret = inflate(&stream, 0);
  76                 use(len - stream.avail_in);
  77                 if (stream.total_out == size && ret == Z_STREAM_END)
  78                         break;
  79                 if (ret != Z_OK) {
  80                         error("inflate returned %d\n", ret);
  81                         free(buf);
  82                         buf = NULL;
  83                         if (!recover)
  84                                 exit(1);
  85                         has_errors = 1;
  86                         break;
  87                 }
  88                 stream.next_in = fill(1);
  89                 stream.avail_in = len;
  90         }
  91         inflateEnd(&stream);
  92         return buf;
  93 }
  94
  95 struct delta_info {
  96         unsigned char base_sha1[20];
  97         unsigned nr;
  98         off_t base_offset;
  99         unsigned long size;
 100         void *delta;
 101         struct delta_info *next;
 102 };
 103
 104 static struct delta_info *delta_list;
 105
 106 static void add_delta_to_list(unsigned nr, unsigned const char *base_sha1,
 107                               off_t base_offset,
 108                               void *delta, unsigned long size)
 109 {
 110         struct delta_info *info = xmalloc(sizeof(*info));
 111
 112         hashcpy(info->base_sha1, base_sha1);
 113         info->base_offset = base_offset;
 114         info->size = size;
 115         info->delta = delta;
 116         info->nr = nr;
 117         info->next = delta_list;
 118         delta_list = info;
 119 }
 120
 121 struct obj_info {
 122         off_t offset;
 123         unsigned char sha1[20];
 124 };
 125
 126 static struct obj_info *obj_list;
 127
 128 static void added_object(unsigned nr, enum object_type type,
 129                          void *data, unsigned long size);
 130
 131 static void write_object(unsigned nr, enum object_type type,
 132                          void *buf, unsigned long size)
 133 {
 134         if (write_sha1_file(buf, size, typename(type), obj_list[nr].sha1) < 0)
 135                 die("failed to write object");
 136         added_object(nr, type, buf, size);
 137 }
 138
 139 static void resolve_delta(unsigned nr, enum object_type type,
 140                           void *base, unsigned long base_size,
 141                           void *delta, unsigned long delta_size)
 142 {
 143         void *result;
 144         unsigned long result_size;
 145
 146         result = patch_delta(base, base_size,
 147                              delta, delta_size,
 148                              &result_size);
 149         if (!result)
 150                 die("failed to apply delta");
 151         free(delta);
 152         write_object(nr, type, result, result_size);
 153         free(result);
 154 }
 155
 156 static void added_object(unsigned nr, enum object_type type,
 157                          void *data, unsigned long size)
 158 {
 159         struct delta_info **p = &delta_list;
 160         struct delta_info *info;
 161
 162         while ((info = *p) != NULL) {
 163                 if (!hashcmp(info->base_sha1, obj_list[nr].sha1) ||
 164                     info->base_offset == obj_list[nr].offset) {
 165                         *p = info->next;
 166                         p = &delta_list;
 167                         resolve_delta(info->nr, type, data, size,
 168                                       info->delta, info->size);
 169                         free(info);
 170                         continue;
 171                 }
 172                 p = &info->next;
 173         }
 174 }
 175
 176 static void unpack_non_delta_entry(enum object_type type, unsigned long size,
 177                                    unsigned nr)
 178 {
 179         void *buf = get_data(size);
 180
 181         if (!dry_run && buf)
 182                 write_object(nr, type, buf, size);
 183         free(buf);
 184 }
 185
 186 static void unpack_delta_entry(enum object_type type, unsigned long delta_size,
 187                                unsigned nr)
 188 {
 189         void *delta_data, *base;
 190         unsigned long base_size;
 191         unsigned char base_sha1[20];
 192
 193         if (type == OBJ_REF_DELTA) {
 194                 hashcpy(base_sha1, fill(20));
 195                 use(20);
 196                 delta_data = get_data(delta_size);
 197                 if (dry_run || !delta_data) {
 198                         free(delta_data);
 199                         return;
 200                 }
 201                 if (!has_sha1_file(base_sha1)) {
 202                         hashcpy(obj_list[nr].sha1, null_sha1);
 203                         add_delta_to_list(nr, base_sha1, 0, delta_data, delta_size);
 204                         return;
 205                 }
 206         } else {
 207                 unsigned base_found = 0;
 208                 unsigned char *pack, c;
 209                 off_t base_offset;
 210                 unsigned lo, mid, hi;
 211
 212                 pack = fill(1);
 213                 c = *pack;
 214                 use(1);
 215                 base_offset = c & 127;
 216                 while (c & 128) {
 217                         base_offset += 1;
 218                         if (!base_offset || MSB(base_offset, 7))
 219                                 die("offset value overflow for delta base object");
 220                         pack = fill(1);
 221                         c = *pack;
 222                         use(1);
 223                         base_offset = (base_offset << 7) + (c & 127);
 224                 }
 225                 base_offset = obj_list[nr].offset - base_offset;
 226
 227                 delta_data = get_data(delta_size);
 228                 if (dry_run || !delta_data) {
 229                         free(delta_data);
 230                         return;
 231                 }
 232                 lo = 0;
 233                 hi = nr;
 234                 while (lo < hi) {
 235                         mid = (lo + hi)/2;
 236                         if (base_offset < obj_list[mid].offset) {
 237                                 hi = mid;
 238                         } else if (base_offset > obj_list[mid].offset) {
 239                                 lo = mid + 1;
 240                         } else {
 241                                 hashcpy(base_sha1, obj_list[mid].sha1);
 242                                 base_found = !is_null_sha1(base_sha1);
 243                                 break;
 244                         }
 245                 }
 246                 if (!base_found) {
 247                         /* The delta base object is itself a delta that
 248                            has not been resolved yet. */
 249                         hashcpy(obj_list[nr].sha1, null_sha1);
 250                         add_delta_to_list(nr, null_sha1, base_offset, delta_data, delta_size);
 251                         return;
 252                 }
 253         }
 254
 255         base = read_sha1_file(base_sha1, &type, &base_size);
 256         if (!base) {
 257                 error("failed to read delta-pack base object %s",
 258                       sha1_to_hex(base_sha1));
 259                 if (!recover)
 260                         exit(1);
 261                 has_errors = 1;
 262                 return;
 263         }
 264         resolve_delta(nr, type, base, base_size, delta_data, delta_size);
 265         free(base);
 266 }
 267
 268 static void unpack_one(unsigned nr)
 269 {
 270         unsigned shift;
 271         unsigned char *pack, c;
 272         unsigned long size;
 273         enum object_type type;
 274
 275         obj_list[nr].offset = consumed_bytes;
 276
 277         pack = fill(1);
 278         c = *pack;
 279         use(1);
 280         type = (c >> 4) & 7;
 281         size = (c & 15);
 282         shift = 4;
 283         while (c & 0x80) {
 284                 pack = fill(1);
 285                 c = *pack;
 286                 use(1);
 287                 size += (c & 0x7f) << shift;
 288                 shift += 7;
 289         }
 290
 291         switch (type) {
 292         case OBJ_COMMIT:
 293         case OBJ_TREE:
 294         case OBJ_BLOB:
 295         case OBJ_TAG:
 296                 unpack_non_delta_entry(type, size, nr);
 297                 return;
 298         case OBJ_REF_DELTA:
 299         case OBJ_OFS_DELTA:
 300                 unpack_delta_entry(type, size, nr);
 301                 return;
 302         default:
 303                 error("bad object type %d", type);
 304                 has_errors = 1;
 305                 if (recover)
 306                         return;
 307                 exit(1);
 308         }
 309 }
 310
 311 static void unpack_all(void)
 312 {
 313         int i;
 314         struct progress *progress = NULL;
 315         struct pack_header *hdr = fill(sizeof(struct pack_header));
 316         unsigned nr_objects = ntohl(hdr->hdr_entries);
 317
 318         if (ntohl(hdr->hdr_signature) != PACK_SIGNATURE)
 319                 die("bad pack file");
 320         if (!pack_version_ok(hdr->hdr_version))
 321                 die("unknown pack file version %d", ntohl(hdr->hdr_version));
 322         use(sizeof(struct pack_header));
 323
 324         if (!quiet)
 325                 progress = start_progress("Unpacking objects", nr_objects);
 326         obj_list = xmalloc(nr_objects * sizeof(*obj_list));
 327         for (i = 0; i < nr_objects; i++) {
 328                 unpack_one(i);
 329                 display_progress(progress, i + 1);
 330         }
 331         stop_progress(&progress);
 332
 333         if (delta_list)
 334                 die("unresolved deltas left after unpacking");
 335 }
 336
 337 int cmd_unpack_objects(int argc, const char **argv, const char *prefix)
 338 {
 339         int i;
 340         unsigned char sha1[20];
 341
 342         git_config(git_default_config);
 343
 344         quiet = !isatty(2);
 345
 346         for (i = 1 ; i < argc; i++) {
 347                 const char *arg = argv[i];
 348
 349                 if (*arg == '-') {
 350                         if (!strcmp(arg, "-n")) {
 351                                 dry_run = 1;
 352                                 continue;
 353                         }
 354                         if (!strcmp(arg, "-q")) {
 355                                 quiet = 1;
 356                                 continue;
 357                         }
 358                         if (!strcmp(arg, "-r")) {
 359                                 recover = 1;
 360                                 continue;
 361                         }
 362                         if (!prefixcmp(arg, "--pack_header=")) {
 363                                 struct pack_header *hdr;
 364                                 char *c;
 365
 366                                 hdr = (struct pack_header *)buffer;
 367                                 hdr->hdr_signature = htonl(PACK_SIGNATURE);
 368                                 hdr->hdr_version = htonl(strtoul(arg + 14, &c, 10));
 369                                 if (*c != ',')
 370                                         die("bad %s", arg);
 371                                 hdr->hdr_entries = htonl(strtoul(c + 1, &c, 10));
 372                                 if (*c)
 373                                         die("bad %s", arg);
 374                                 len = sizeof(*hdr);
 375                                 continue;
 376                         }
 377                         usage(unpack_usage);
 378                 }
 379
 380                 /* We don't take any non-flag arguments now.. Maybe some day */
 381                 usage(unpack_usage);
 382         }
 383         SHA1_Init(&ctx);
 384         unpack_all();
 385         SHA1_Update(&ctx, buffer, offset);
 386         SHA1_Final(sha1, &ctx);
 387         if (hashcmp(fill(20), sha1))
 388                 die("final sha1 did not match");
 389         use(20);
 390
 391         /* Write the last part of the buffer to stdout */
 392         while (len) {
 393                 int ret = xwrite(1, buffer + offset, len);
 394                 if (ret <= 0)
 395                         break;
 396                 len -= ret;
 397                 offset += ret;
 398         }
 399
 400         /* All done */
 401         return has_errors;
 402 }