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