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 "tree-walk.h"
  11 #include "progress.h"
  12 #include "decorate.h"
  13 #include "fsck.h"
  14
  15 static int dry_run, quiet, recover, has_errors, strict;
  16 static const char unpack_usage[] = "git unpack-objects [-n] [-q] [-r] [--strict] < pack-file";
  17
  18 /* We always read in 4kB chunks. */
  19 static unsigned char buffer[4096];
  20 static unsigned int offset, len;
  21 static off_t consumed_bytes;
  22 static git_SHA_CTX ctx;
  23
  24 /*
  25  * When running under --strict mode, objects whose reachability are
  26  * suspect are kept in core without getting written in the object
  27  * store.
  28  */
  29 struct obj_buffer {
  30         char *buffer;
  31         unsigned long size;
  32 };
  33
  34 static struct decoration obj_decorate;
  35
  36 static struct obj_buffer *lookup_object_buffer(struct object *base)
  37 {
  38         return lookup_decoration(&obj_decorate, base);
  39 }
  40
  41 static void add_object_buffer(struct object *object, char *buffer, unsigned long size)
  42 {
  43         struct obj_buffer *obj;
  44         obj = xcalloc(1, sizeof(struct obj_buffer));
  45         obj->buffer = buffer;
  46         obj->size = size;
  47         if (add_decoration(&obj_decorate, object, obj))
  48                 die("object %s tried to add buffer twice!", sha1_to_hex(object->sha1));
  49 }
  50
  51 /*
  52  * Make sure at least "min" bytes are available in the buffer, and
  53  * return the pointer to the buffer.
  54  */
  55 static void *fill(int min)
  56 {
  57         if (min <= len)
  58                 return buffer + offset;
  59         if (min > sizeof(buffer))
  60                 die("cannot fill %d bytes", min);
  61         if (offset) {
  62                 git_SHA1_Update(&ctx, buffer, offset);
  63                 memmove(buffer, buffer + offset, len);
  64                 offset = 0;
  65         }
  66         do {
  67                 ssize_t ret = xread(0, buffer + len, sizeof(buffer) - len);
  68                 if (ret <= 0) {
  69                         if (!ret)
  70                                 die("early EOF");
  71                         die_errno("read error on input");
  72                 }
  73                 len += ret;
  74         } while (len < min);
  75         return buffer;
  76 }
  77
  78 static void use(int bytes)
  79 {
  80         if (bytes > len)
  81                 die("used more bytes than were available");
  82         len -= bytes;
  83         offset += bytes;
  84
  85         /* make sure off_t is sufficiently large not to wrap */
  86         if (signed_add_overflows(consumed_bytes, bytes))
  87                 die("pack too large for current definition of off_t");
  88         consumed_bytes += bytes;
  89 }
  90
  91 static void *get_data(unsigned long size)
  92 {
  93         git_zstream stream;
  94         void *buf = xmalloc(size);
  95
  96         memset(&stream, 0, sizeof(stream));
  97
  98         stream.next_out = buf;
  99         stream.avail_out = size;
 100         stream.next_in = fill(1);
 101         stream.avail_in = len;
 102         git_inflate_init(&stream);
 103
 104         for (;;) {
 105                 int ret = git_inflate(&stream, 0);
 106                 use(len - stream.avail_in);
 107                 if (stream.total_out == size && ret == Z_STREAM_END)
 108                         break;
 109                 if (ret != Z_OK) {
 110                         error("inflate returned %d", ret);
 111                         free(buf);
 112                         buf = NULL;
 113                         if (!recover)
 114                                 exit(1);
 115                         has_errors = 1;
 116                         break;
 117                 }
 118                 stream.next_in = fill(1);
 119                 stream.avail_in = len;
 120         }
 121         git_inflate_end(&stream);
 122         return buf;
 123 }
 124
 125 struct delta_info {
 126         unsigned char base_sha1[20];
 127         unsigned nr;
 128         off_t base_offset;
 129         unsigned long size;
 130         void *delta;
 131         struct delta_info *next;
 132 };
 133
 134 static struct delta_info *delta_list;
 135
 136 static void add_delta_to_list(unsigned nr, unsigned const char *base_sha1,
 137                               off_t base_offset,
 138                               void *delta, unsigned long size)
 139 {
 140         struct delta_info *info = xmalloc(sizeof(*info));
 141
 142         hashcpy(info->base_sha1, base_sha1);
 143         info->base_offset = base_offset;
 144         info->size = size;
 145         info->delta = delta;
 146         info->nr = nr;
 147         info->next = delta_list;
 148         delta_list = info;
 149 }
 150
 151 struct obj_info {
 152         off_t offset;
 153         unsigned char sha1[20];
 154         struct object *obj;
 155 };
 156
 157 #define FLAG_OPEN (1u<<20)
 158 #define FLAG_WRITTEN (1u<<21)
 159
 160 static struct obj_info *obj_list;
 161 static unsigned nr_objects;
 162
 163 /*
 164  * Called only from check_object() after it verified this object
 165  * is Ok.
 166  */
 167 static void write_cached_object(struct object *obj, struct obj_buffer *obj_buf)
 168 {
 169         unsigned char sha1[20];
 170
 171         if (write_sha1_file(obj_buf->buffer, obj_buf->size, typename(obj->type), sha1) < 0)
 172                 die("failed to write object %s", sha1_to_hex(obj->sha1));
 173         obj->flags |= FLAG_WRITTEN;
 174 }
 175
 176 /*
 177  * At the very end of the processing, write_rest() scans the objects
 178  * that have reachability requirements and calls this function.
 179  * Verify its reachability and validity recursively and write it out.
 180  */
 181 static int check_object(struct object *obj, int type, void *data)
 182 {
 183         struct obj_buffer *obj_buf;
 184
 185         if (!obj)
 186                 return 1;
 187
 188         if (obj->flags & FLAG_WRITTEN)
 189                 return 0;
 190
 191         if (type != OBJ_ANY && obj->type != type)
 192                 die("object type mismatch");
 193
 194         if (!(obj->flags & FLAG_OPEN)) {
 195                 unsigned long size;
 196                 int type = sha1_object_info(obj->sha1, &size);
 197                 if (type != obj->type || type <= 0)
 198                         die("object of unexpected type");
 199                 obj->flags |= FLAG_WRITTEN;
 200                 return 0;
 201         }
 202
 203         obj_buf = lookup_object_buffer(obj);
 204         if (!obj_buf)
 205                 die("Whoops! Cannot find object '%s'", sha1_to_hex(obj->sha1));
 206         if (fsck_object(obj, obj_buf->buffer, obj_buf->size, 1,
 207                         fsck_error_function))
 208                 die("Error in object");
 209         if (fsck_walk(obj, check_object, NULL))
 210                 die("Error on reachable objects of %s", sha1_to_hex(obj->sha1));
 211         write_cached_object(obj, obj_buf);
 212         return 0;
 213 }
 214
 215 static void write_rest(void)
 216 {
 217         unsigned i;
 218         for (i = 0; i < nr_objects; i++) {
 219                 if (obj_list[i].obj)
 220                         check_object(obj_list[i].obj, OBJ_ANY, NULL);
 221         }
 222 }
 223
 224 static void added_object(unsigned nr, enum object_type type,
 225                          void *data, unsigned long size);
 226
 227 /*
 228  * Write out nr-th object from the list, now we know the contents
 229  * of it.  Under --strict, this buffers structured objects in-core,
 230  * to be checked at the end.
 231  */
 232 static void write_object(unsigned nr, enum object_type type,
 233                          void *buf, unsigned long size)
 234 {
 235         if (!strict) {
 236                 if (write_sha1_file(buf, size, typename(type), obj_list[nr].sha1) < 0)
 237                         die("failed to write object");
 238                 added_object(nr, type, buf, size);
 239                 free(buf);
 240                 obj_list[nr].obj = NULL;
 241         } else if (type == OBJ_BLOB) {
 242                 struct blob *blob;
 243                 if (write_sha1_file(buf, size, typename(type), obj_list[nr].sha1) < 0)
 244                         die("failed to write object");
 245                 added_object(nr, type, buf, size);
 246                 free(buf);
 247
 248                 blob = lookup_blob(obj_list[nr].sha1);
 249                 if (blob)
 250                         blob->object.flags |= FLAG_WRITTEN;
 251                 else
 252                         die("invalid blob object");
 253                 obj_list[nr].obj = NULL;
 254         } else {
 255                 struct object *obj;
 256                 int eaten;
 257                 hash_sha1_file(buf, size, typename(type), obj_list[nr].sha1);
 258                 added_object(nr, type, buf, size);
 259                 obj = parse_object_buffer(obj_list[nr].sha1, type, size, buf, &eaten);
 260                 if (!obj)
 261                         die("invalid %s", typename(type));
 262                 add_object_buffer(obj, buf, size);
 263                 obj->flags |= FLAG_OPEN;
 264                 obj_list[nr].obj = obj;
 265         }
 266 }
 267
 268 static void resolve_delta(unsigned nr, enum object_type type,
 269                           void *base, unsigned long base_size,
 270                           void *delta, unsigned long delta_size)
 271 {
 272         void *result;
 273         unsigned long result_size;
 274
 275         result = patch_delta(base, base_size,
 276                              delta, delta_size,
 277                              &result_size);
 278         if (!result)
 279                 die("failed to apply delta");
 280         free(delta);
 281         write_object(nr, type, result, result_size);
 282 }
 283
 284 /*
 285  * We now know the contents of an object (which is nr-th in the pack);
 286  * resolve all the deltified objects that are based on it.
 287  */
 288 static void added_object(unsigned nr, enum object_type type,
 289                          void *data, unsigned long size)
 290 {
 291         struct delta_info **p = &delta_list;
 292         struct delta_info *info;
 293
 294         while ((info = *p) != NULL) {
 295                 if (!hashcmp(info->base_sha1, obj_list[nr].sha1) ||
 296                     info->base_offset == obj_list[nr].offset) {
 297                         *p = info->next;
 298                         p = &delta_list;
 299                         resolve_delta(info->nr, type, data, size,
 300                                       info->delta, info->size);
 301                         free(info);
 302                         continue;
 303                 }
 304                 p = &info->next;
 305         }
 306 }
 307
 308 static void unpack_non_delta_entry(enum object_type type, unsigned long size,
 309                                    unsigned nr)
 310 {
 311         void *buf = get_data(size);
 312
 313         if (!dry_run && buf)
 314                 write_object(nr, type, buf, size);
 315         else
 316                 free(buf);
 317 }
 318
 319 static int resolve_against_held(unsigned nr, const unsigned char *base,
 320                                 void *delta_data, unsigned long delta_size)
 321 {
 322         struct object *obj;
 323         struct obj_buffer *obj_buffer;
 324         obj = lookup_object(base);
 325         if (!obj)
 326                 return 0;
 327         obj_buffer = lookup_object_buffer(obj);
 328         if (!obj_buffer)
 329                 return 0;
 330         resolve_delta(nr, obj->type, obj_buffer->buffer,
 331                       obj_buffer->size, delta_data, delta_size);
 332         return 1;
 333 }
 334
 335 static void unpack_delta_entry(enum object_type type, unsigned long delta_size,
 336                                unsigned nr)
 337 {
 338         void *delta_data, *base;
 339         unsigned long base_size;
 340         unsigned char base_sha1[20];
 341
 342         if (type == OBJ_REF_DELTA) {
 343                 hashcpy(base_sha1, fill(20));
 344                 use(20);
 345                 delta_data = get_data(delta_size);
 346                 if (dry_run || !delta_data) {
 347                         free(delta_data);
 348                         return;
 349                 }
 350                 if (has_sha1_file(base_sha1))
 351                         ; /* Ok we have this one */
 352                 else if (resolve_against_held(nr, base_sha1,
 353                                               delta_data, delta_size))
 354                         return; /* we are done */
 355                 else {
 356                         /* cannot resolve yet --- queue it */
 357                         hashcpy(obj_list[nr].sha1, null_sha1);
 358                         add_delta_to_list(nr, base_sha1, 0, delta_data, delta_size);
 359                         return;
 360                 }
 361         } else {
 362                 unsigned base_found = 0;
 363                 unsigned char *pack, c;
 364                 off_t base_offset;
 365                 unsigned lo, mid, hi;
 366
 367                 pack = fill(1);
 368                 c = *pack;
 369                 use(1);
 370                 base_offset = c & 127;
 371                 while (c & 128) {
 372                         base_offset += 1;
 373                         if (!base_offset || MSB(base_offset, 7))
 374                                 die("offset value overflow for delta base object");
 375                         pack = fill(1);
 376                         c = *pack;
 377                         use(1);
 378                         base_offset = (base_offset << 7) + (c & 127);
 379                 }
 380                 base_offset = obj_list[nr].offset - base_offset;
 381                 if (base_offset <= 0 || base_offset >= obj_list[nr].offset)
 382                         die("offset value out of bound for delta base object");
 383
 384                 delta_data = get_data(delta_size);
 385                 if (dry_run || !delta_data) {
 386                         free(delta_data);
 387                         return;
 388                 }
 389                 lo = 0;
 390                 hi = nr;
 391                 while (lo < hi) {
 392                         mid = (lo + hi)/2;
 393                         if (base_offset < obj_list[mid].offset) {
 394                                 hi = mid;
 395                         } else if (base_offset > obj_list[mid].offset) {
 396                                 lo = mid + 1;
 397                         } else {
 398                                 hashcpy(base_sha1, obj_list[mid].sha1);
 399                                 base_found = !is_null_sha1(base_sha1);
 400                                 break;
 401                         }
 402                 }
 403                 if (!base_found) {
 404                         /*
 405                          * The delta base object is itself a delta that
 406                          * has not been resolved yet.
 407                          */
 408                         hashcpy(obj_list[nr].sha1, null_sha1);
 409                         add_delta_to_list(nr, null_sha1, base_offset, delta_data, delta_size);
 410                         return;
 411                 }
 412         }
 413
 414         if (resolve_against_held(nr, base_sha1, delta_data, delta_size))
 415                 return;
 416
 417         base = read_sha1_file(base_sha1, &type, &base_size);
 418         if (!base) {
 419                 error("failed to read delta-pack base object %s",
 420                       sha1_to_hex(base_sha1));
 421                 if (!recover)
 422                         exit(1);
 423                 has_errors = 1;
 424                 return;
 425         }
 426         resolve_delta(nr, type, base, base_size, delta_data, delta_size);
 427         free(base);
 428 }
 429
 430 static void unpack_one(unsigned nr)
 431 {
 432         unsigned shift;
 433         unsigned char *pack;
 434         unsigned long size, c;
 435         enum object_type type;
 436
 437         obj_list[nr].offset = consumed_bytes;
 438
 439         pack = fill(1);
 440         c = *pack;
 441         use(1);
 442         type = (c >> 4) & 7;
 443         size = (c & 15);
 444         shift = 4;
 445         while (c & 0x80) {
 446                 pack = fill(1);
 447                 c = *pack;
 448                 use(1);
 449                 size += (c & 0x7f) << shift;
 450                 shift += 7;
 451         }
 452
 453         switch (type) {
 454         case OBJ_COMMIT:
 455         case OBJ_TREE:
 456         case OBJ_BLOB:
 457         case OBJ_TAG:
 458                 unpack_non_delta_entry(type, size, nr);
 459                 return;
 460         case OBJ_REF_DELTA:
 461         case OBJ_OFS_DELTA:
 462                 unpack_delta_entry(type, size, nr);
 463                 return;
 464         default:
 465                 error("bad object type %d", type);
 466                 has_errors = 1;
 467                 if (recover)
 468                         return;
 469                 exit(1);
 470         }
 471 }
 472
 473 static void unpack_all(void)
 474 {
 475         int i;
 476         struct progress *progress = NULL;
 477         struct pack_header *hdr = fill(sizeof(struct pack_header));
 478
 479         nr_objects = ntohl(hdr->hdr_entries);
 480
 481         if (ntohl(hdr->hdr_signature) != PACK_SIGNATURE)
 482                 die("bad pack file");
 483         if (!pack_version_ok(hdr->hdr_version))
 484                 die("unknown pack file version %"PRIu32,
 485                         ntohl(hdr->hdr_version));
 486         use(sizeof(struct pack_header));
 487
 488         if (!quiet)
 489                 progress = start_progress(_("Unpacking objects"), nr_objects);
 490         obj_list = xcalloc(nr_objects, sizeof(*obj_list));
 491         for (i = 0; i < nr_objects; i++) {
 492                 unpack_one(i);
 493                 display_progress(progress, i + 1);
 494         }
 495         stop_progress(&progress);
 496
 497         if (delta_list)
 498                 die("unresolved deltas left after unpacking");
 499 }
 500
 501 int cmd_unpack_objects(int argc, const char **argv, const char *prefix)
 502 {
 503         int i;
 504         unsigned char sha1[20];
 505
 506         check_replace_refs = 0;
 507
 508         git_config(git_default_config, NULL);
 509
 510         quiet = !isatty(2);
 511
 512         for (i = 1 ; i < argc; i++) {
 513                 const char *arg = argv[i];
 514
 515                 if (*arg == '-') {
 516                         if (!strcmp(arg, "-n")) {
 517                                 dry_run = 1;
 518                                 continue;
 519                         }
 520                         if (!strcmp(arg, "-q")) {
 521                                 quiet = 1;
 522                                 continue;
 523                         }
 524                         if (!strcmp(arg, "-r")) {
 525                                 recover = 1;
 526                                 continue;
 527                         }
 528                         if (!strcmp(arg, "--strict")) {
 529                                 strict = 1;
 530                                 continue;
 531                         }
 532                         if (starts_with(arg, "--pack_header=")) {
 533                                 struct pack_header *hdr;
 534                                 char *c;
 535
 536                                 hdr = (struct pack_header *)buffer;
 537                                 hdr->hdr_signature = htonl(PACK_SIGNATURE);
 538                                 hdr->hdr_version = htonl(strtoul(arg + 14, &c, 10));
 539                                 if (*c != ',')
 540                                         die("bad %s", arg);
 541                                 hdr->hdr_entries = htonl(strtoul(c + 1, &c, 10));
 542                                 if (*c)
 543                                         die("bad %s", arg);
 544                                 len = sizeof(*hdr);
 545                                 continue;
 546                         }
 547                         usage(unpack_usage);
 548                 }
 549
 550                 /* We don't take any non-flag arguments now.. Maybe some day */
 551                 usage(unpack_usage);
 552         }
 553         git_SHA1_Init(&ctx);
 554         unpack_all();
 555         git_SHA1_Update(&ctx, buffer, offset);
 556         git_SHA1_Final(sha1, &ctx);
 557         if (strict)
 558                 write_rest();
 559         if (hashcmp(fill(20), sha1))
 560                 die("final sha1 did not match");
 561         use(20);
 562
 563         /* Write the last part of the buffer to stdout */
 564         while (len) {
 565                 int ret = xwrite(1, buffer + offset, len);
 566                 if (ret <= 0)
 567                         break;
 568                 len -= ret;
 569                 offset += ret;
 570         }
 571
 572         /* All done */
 573         return has_errors;
 574 }