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