bundle.c

   1 #include "cache.h"
   2 #include "lockfile.h"
   3 #include "bundle.h"
   4 #include "object-store.h"
   5 #include "repository.h"
   6 #include "object.h"
   7 #include "commit.h"
   8 #include "diff.h"
   9 #include "revision.h"
  10 #include "list-objects.h"
  11 #include "run-command.h"
  12 #include "refs.h"
  13 #include "strvec.h"
  14 #include "list-objects-filter-options.h"
  15 #include "connected.h"
  16
  17 static const char v2_bundle_signature[] = "# v2 git bundle\n";
  18 static const char v3_bundle_signature[] = "# v3 git bundle\n";
  19 static struct {
  20         int version;
  21         const char *signature;
  22 } bundle_sigs[] = {
  23         { 2, v2_bundle_signature },
  24         { 3, v3_bundle_signature },
  25 };
  26
  27 void bundle_header_init(struct bundle_header *header)
  28 {
  29         struct bundle_header blank = BUNDLE_HEADER_INIT;
  30         memcpy(header, &blank, sizeof(*header));
  31 }
  32
  33 void bundle_header_release(struct bundle_header *header)
  34 {
  35         string_list_clear(&header->prerequisites, 1);
  36         string_list_clear(&header->references, 1);
  37         list_objects_filter_release(&header->filter);
  38 }
  39
  40 static int parse_capability(struct bundle_header *header, const char *capability)
  41 {
  42         const char *arg;
  43         if (skip_prefix(capability, "object-format=", &arg)) {
  44                 int algo = hash_algo_by_name(arg);
  45                 if (algo == GIT_HASH_UNKNOWN)
  46                         return error(_("unrecognized bundle hash algorithm: %s"), arg);
  47                 header->hash_algo = &hash_algos[algo];
  48                 return 0;
  49         }
  50         if (skip_prefix(capability, "filter=", &arg)) {
  51                 parse_list_objects_filter(&header->filter, arg);
  52                 return 0;
  53         }
  54         return error(_("unknown capability '%s'"), capability);
  55 }
  56
  57 static int parse_bundle_signature(struct bundle_header *header, const char *line)
  58 {
  59         int i;
  60
  61         for (i = 0; i < ARRAY_SIZE(bundle_sigs); i++) {
  62                 if (!strcmp(line, bundle_sigs[i].signature)) {
  63                         header->version = bundle_sigs[i].version;
  64                         return 0;
  65                 }
  66         }
  67         return -1;
  68 }
  69
  70 int read_bundle_header_fd(int fd, struct bundle_header *header,
  71                           const char *report_path)
  72 {
  73         struct strbuf buf = STRBUF_INIT;
  74         int status = 0;
  75
  76         /* The bundle header begins with the signature */
  77         if (strbuf_getwholeline_fd(&buf, fd, '\n') ||
  78             parse_bundle_signature(header, buf.buf)) {
  79                 if (report_path)
  80                         error(_("'%s' does not look like a v2 or v3 bundle file"),
  81                               report_path);
  82                 status = -1;
  83                 goto abort;
  84         }
  85
  86         header->hash_algo = the_hash_algo;
  87
  88         /* The bundle header ends with an empty line */
  89         while (!strbuf_getwholeline_fd(&buf, fd, '\n') &&
  90                buf.len && buf.buf[0] != '\n') {
  91                 struct object_id oid;
  92                 int is_prereq = 0;
  93                 const char *p;
  94
  95                 strbuf_rtrim(&buf);
  96
  97                 if (header->version == 3 && *buf.buf == '@') {
  98                         if (parse_capability(header, buf.buf + 1)) {
  99                                 status = -1;
 100                                 break;
 101                         }
 102                         continue;
 103                 }
 104
 105                 if (*buf.buf == '-') {
 106                         is_prereq = 1;
 107                         strbuf_remove(&buf, 0, 1);
 108                 }
 109
 110                 /*
 111                  * Tip lines have object name, SP, and refname.
 112                  * Prerequisites have object name that is optionally
 113                  * followed by SP and subject line.
 114                  */
 115                 if (parse_oid_hex_algop(buf.buf, &oid, &p, header->hash_algo) ||
 116                     (*p && !isspace(*p)) ||
 117                     (!is_prereq && !*p)) {
 118                         if (report_path)
 119                                 error(_("unrecognized header: %s%s (%d)"),
 120                                       (is_prereq ? "-" : ""), buf.buf, (int)buf.len);
 121                         status = -1;
 122                         break;
 123                 } else {
 124                         struct object_id *dup = oiddup(&oid);
 125                         if (is_prereq)
 126                                 string_list_append(&header->prerequisites, "")->util = dup;
 127                         else
 128                                 string_list_append(&header->references, p + 1)->util = dup;
 129                 }
 130         }
 131
 132  abort:
 133         if (status) {
 134                 close(fd);
 135                 fd = -1;
 136         }
 137         strbuf_release(&buf);
 138         return fd;
 139 }
 140
 141 int read_bundle_header(const char *path, struct bundle_header *header)
 142 {
 143         int fd = open(path, O_RDONLY);
 144
 145         if (fd < 0)
 146                 return error(_("could not open '%s'"), path);
 147         return read_bundle_header_fd(fd, header, path);
 148 }
 149
 150 int is_bundle(const char *path, int quiet)
 151 {
 152         struct bundle_header header = BUNDLE_HEADER_INIT;
 153         int fd = open(path, O_RDONLY);
 154
 155         if (fd < 0)
 156                 return 0;
 157         fd = read_bundle_header_fd(fd, &header, quiet ? NULL : path);
 158         if (fd >= 0)
 159                 close(fd);
 160         bundle_header_release(&header);
 161         return (fd >= 0);
 162 }
 163
 164 static int list_refs(struct string_list *r, int argc, const char **argv)
 165 {
 166         int i;
 167
 168         for (i = 0; i < r->nr; i++) {
 169                 struct object_id *oid;
 170                 const char *name;
 171
 172                 if (argc > 1) {
 173                         int j;
 174                         for (j = 1; j < argc; j++)
 175                                 if (!strcmp(r->items[i].string, argv[j]))
 176                                         break;
 177                         if (j == argc)
 178                                 continue;
 179                 }
 180
 181                 oid = r->items[i].util;
 182                 name = r->items[i].string;
 183                 printf("%s %s\n", oid_to_hex(oid), name);
 184         }
 185         return 0;
 186 }
 187
 188 /* Remember to update object flag allocation in object.h */
 189 #define PREREQ_MARK (1u<<16)
 190
 191 struct string_list_iterator {
 192         struct string_list *list;
 193         size_t cur;
 194 };
 195
 196 static const struct object_id *iterate_ref_map(void *cb_data)
 197 {
 198         struct string_list_iterator *iter = cb_data;
 199
 200         if (iter->cur >= iter->list->nr)
 201                 return NULL;
 202
 203         return iter->list->items[iter->cur++].util;
 204 }
 205
 206 int verify_bundle(struct repository *r,
 207                   struct bundle_header *header,
 208                   enum verify_bundle_flags flags)
 209 {
 210         /*
 211          * Do fast check, then if any prereqs are missing then go line by line
 212          * to be verbose about the errors
 213          */
 214         struct string_list *p = &header->prerequisites;
 215         int i, ret = 0;
 216         const char *message = _("Repository lacks these prerequisite commits:");
 217         struct string_list_iterator iter = {
 218                 .list = p,
 219         };
 220         struct check_connected_options opts = {
 221                 .quiet = 1,
 222         };
 223
 224         if (!r || !r->objects || !r->objects->odb)
 225                 return error(_("need a repository to verify a bundle"));
 226
 227         for (i = 0; i < p->nr; i++) {
 228                 struct string_list_item *e = p->items + i;
 229                 const char *name = e->string;
 230                 struct object_id *oid = e->util;
 231                 struct object *o = parse_object(r, oid);
 232                 if (o)
 233                         continue;
 234                 ret++;
 235                 if (flags & VERIFY_BUNDLE_QUIET)
 236                         continue;
 237                 if (ret == 1)
 238                         error("%s", message);
 239                 error("%s %s", oid_to_hex(oid), name);
 240         }
 241         if (ret)
 242                 goto cleanup;
 243
 244         if ((ret = check_connected(iterate_ref_map, &iter, &opts)))
 245                 error(_("some prerequisite commits exist in the object store, "
 246                         "but are not connected to the repository's history"));
 247
 248         /* TODO: preserve this verbose language. */
 249         if (flags & VERIFY_BUNDLE_VERBOSE) {
 250                 struct string_list *r;
 251
 252                 r = &header->references;
 253                 printf_ln(Q_("The bundle contains this ref:",
 254                              "The bundle contains these %"PRIuMAX" refs:",
 255                              r->nr),
 256                           (uintmax_t)r->nr);
 257                 list_refs(r, 0, NULL);
 258
 259                 r = &header->prerequisites;
 260                 if (!r->nr) {
 261                         printf_ln(_("The bundle records a complete history."));
 262                 } else {
 263                         printf_ln(Q_("The bundle requires this ref:",
 264                                      "The bundle requires these %"PRIuMAX" refs:",
 265                                      r->nr),
 266                                   (uintmax_t)r->nr);
 267                         list_refs(r, 0, NULL);
 268                 }
 269
 270                 printf_ln("The bundle uses this hash algorithm: %s",
 271                           header->hash_algo->name);
 272                 if (header->filter.choice)
 273                         printf_ln("The bundle uses this filter: %s",
 274                                   list_objects_filter_spec(&header->filter));
 275         }
 276 cleanup:
 277         return ret;
 278 }
 279
 280 int list_bundle_refs(struct bundle_header *header, int argc, const char **argv)
 281 {
 282         return list_refs(&header->references, argc, argv);
 283 }
 284
 285 static int is_tag_in_date_range(struct object *tag, struct rev_info *revs)
 286 {
 287         unsigned long size;
 288         enum object_type type;
 289         char *buf = NULL, *line, *lineend;
 290         timestamp_t date;
 291         int result = 1;
 292
 293         if (revs->max_age == -1 && revs->min_age == -1)
 294                 goto out;
 295
 296         buf = read_object_file(&tag->oid, &type, &size);
 297         if (!buf)
 298                 goto out;
 299         line = memmem(buf, size, "\ntagger ", 8);
 300         if (!line++)
 301                 goto out;
 302         lineend = memchr(line, '\n', buf + size - line);
 303         line = memchr(line, '>', lineend ? lineend - line : buf + size - line);
 304         if (!line++)
 305                 goto out;
 306         date = parse_timestamp(line, NULL, 10);
 307         result = (revs->max_age == -1 || revs->max_age < date) &&
 308                 (revs->min_age == -1 || revs->min_age > date);
 309 out:
 310         free(buf);
 311         return result;
 312 }
 313
 314
 315 /* Write the pack data to bundle_fd */
 316 static int write_pack_data(int bundle_fd, struct rev_info *revs, struct strvec *pack_options)
 317 {
 318         struct child_process pack_objects = CHILD_PROCESS_INIT;
 319         int i;
 320
 321         strvec_pushl(&pack_objects.args,
 322                      "pack-objects",
 323                      "--stdout", "--thin", "--delta-base-offset",
 324                      NULL);
 325         strvec_pushv(&pack_objects.args, pack_options->v);
 326         if (revs->filter.choice)
 327                 strvec_pushf(&pack_objects.args, "--filter=%s",
 328                              list_objects_filter_spec(&revs->filter));
 329         pack_objects.in = -1;
 330         pack_objects.out = bundle_fd;
 331         pack_objects.git_cmd = 1;
 332
 333         /*
 334          * start_command() will close our descriptor if it's >1. Duplicate it
 335          * to avoid surprising the caller.
 336          */
 337         if (pack_objects.out > 1) {
 338                 pack_objects.out = dup(pack_objects.out);
 339                 if (pack_objects.out < 0) {
 340                         error_errno(_("unable to dup bundle descriptor"));
 341                         child_process_clear(&pack_objects);
 342                         return -1;
 343                 }
 344         }
 345
 346         if (start_command(&pack_objects))
 347                 return error(_("Could not spawn pack-objects"));
 348
 349         for (i = 0; i < revs->pending.nr; i++) {
 350                 struct object *object = revs->pending.objects[i].item;
 351                 if (object->flags & UNINTERESTING)
 352                         write_or_die(pack_objects.in, "^", 1);
 353                 write_or_die(pack_objects.in, oid_to_hex(&object->oid), the_hash_algo->hexsz);
 354                 write_or_die(pack_objects.in, "\n", 1);
 355         }
 356         close(pack_objects.in);
 357         if (finish_command(&pack_objects))
 358                 return error(_("pack-objects died"));
 359         return 0;
 360 }
 361
 362 /*
 363  * Write out bundle refs based on the tips already
 364  * parsed into revs.pending. As a side effect, may
 365  * manipulate revs.pending to include additional
 366  * necessary objects (like tags).
 367  *
 368  * Returns the number of refs written, or negative
 369  * on error.
 370  */
 371 static int write_bundle_refs(int bundle_fd, struct rev_info *revs)
 372 {
 373         int i;
 374         int ref_count = 0;
 375
 376         for (i = 0; i < revs->pending.nr; i++) {
 377                 struct object_array_entry *e = revs->pending.objects + i;
 378                 struct object_id oid;
 379                 char *ref;
 380                 const char *display_ref;
 381                 int flag;
 382
 383                 if (e->item->flags & UNINTERESTING)
 384                         continue;
 385                 if (dwim_ref(e->name, strlen(e->name), &oid, &ref, 0) != 1)
 386                         goto skip_write_ref;
 387                 if (read_ref_full(e->name, RESOLVE_REF_READING, &oid, &flag))
 388                         flag = 0;
 389                 display_ref = (flag & REF_ISSYMREF) ? e->name : ref;
 390
 391                 if (e->item->type == OBJ_TAG &&
 392                                 !is_tag_in_date_range(e->item, revs)) {
 393                         e->item->flags |= UNINTERESTING;
 394                         goto skip_write_ref;
 395                 }
 396
 397                 /*
 398                  * Make sure the refs we wrote out is correct; --max-count and
 399                  * other limiting options could have prevented all the tips
 400                  * from getting output.
 401                  *
 402                  * Non commit objects such as tags and blobs do not have
 403                  * this issue as they are not affected by those extra
 404                  * constraints.
 405                  */
 406                 if (!(e->item->flags & SHOWN) && e->item->type == OBJ_COMMIT) {
 407                         warning(_("ref '%s' is excluded by the rev-list options"),
 408                                 e->name);
 409                         goto skip_write_ref;
 410                 }
 411                 /*
 412                  * If you run "git bundle create bndl v1.0..v2.0", the
 413                  * name of the positive ref is "v2.0" but that is the
 414                  * commit that is referenced by the tag, and not the tag
 415                  * itself.
 416                  */
 417                 if (!oideq(&oid, &e->item->oid)) {
 418                         /*
 419                          * Is this the positive end of a range expressed
 420                          * in terms of a tag (e.g. v2.0 from the range
 421                          * "v1.0..v2.0")?
 422                          */
 423                         struct commit *one = lookup_commit_reference(revs->repo, &oid);
 424                         struct object *obj;
 425
 426                         if (e->item == &(one->object)) {
 427                                 /*
 428                                  * Need to include e->name as an
 429                                  * independent ref to the pack-objects
 430                                  * input, so that the tag is included
 431                                  * in the output; otherwise we would
 432                                  * end up triggering "empty bundle"
 433                                  * error.
 434                                  */
 435                                 obj = parse_object_or_die(&oid, e->name);
 436                                 obj->flags |= SHOWN;
 437                                 add_pending_object(revs, obj, e->name);
 438                         }
 439                         goto skip_write_ref;
 440                 }
 441
 442                 ref_count++;
 443                 write_or_die(bundle_fd, oid_to_hex(&e->item->oid), the_hash_algo->hexsz);
 444                 write_or_die(bundle_fd, " ", 1);
 445                 write_or_die(bundle_fd, display_ref, strlen(display_ref));
 446                 write_or_die(bundle_fd, "\n", 1);
 447  skip_write_ref:
 448                 free(ref);
 449         }
 450
 451         /* end header */
 452         write_or_die(bundle_fd, "\n", 1);
 453         return ref_count;
 454 }
 455
 456 struct bundle_prerequisites_info {
 457         struct object_array *pending;
 458         int fd;
 459 };
 460
 461 static void write_bundle_prerequisites(struct commit *commit, void *data)
 462 {
 463         struct bundle_prerequisites_info *bpi = data;
 464         struct object *object;
 465         struct pretty_print_context ctx = { 0 };
 466         struct strbuf buf = STRBUF_INIT;
 467
 468         if (!(commit->object.flags & BOUNDARY))
 469                 return;
 470         strbuf_addf(&buf, "-%s ", oid_to_hex(&commit->object.oid));
 471         write_or_die(bpi->fd, buf.buf, buf.len);
 472
 473         ctx.fmt = CMIT_FMT_ONELINE;
 474         ctx.output_encoding = get_log_output_encoding();
 475         strbuf_reset(&buf);
 476         pretty_print_commit(&ctx, commit, &buf);
 477         strbuf_trim(&buf);
 478
 479         object = (struct object *)commit;
 480         object->flags |= UNINTERESTING;
 481         add_object_array_with_path(object, buf.buf, bpi->pending, S_IFINVALID,
 482                                    NULL);
 483         strbuf_addch(&buf, '\n');
 484         write_or_die(bpi->fd, buf.buf, buf.len);
 485         strbuf_release(&buf);
 486 }
 487
 488 int create_bundle(struct repository *r, const char *path,
 489                   int argc, const char **argv, struct strvec *pack_options, int version)
 490 {
 491         struct lock_file lock = LOCK_INIT;
 492         int bundle_fd = -1;
 493         int bundle_to_stdout;
 494         int ref_count = 0;
 495         struct rev_info revs, revs_copy;
 496         int min_version = 2;
 497         struct bundle_prerequisites_info bpi;
 498         int i;
 499
 500         /* init revs to list objects for pack-objects later */
 501         save_commit_buffer = 0;
 502         repo_init_revisions(r, &revs, NULL);
 503
 504         /*
 505          * Pre-initialize the '--objects' flag so we can parse a
 506          * --filter option successfully.
 507          */
 508         revs.tree_objects = revs.blob_objects = 1;
 509
 510         argc = setup_revisions(argc, argv, &revs, NULL);
 511
 512         /*
 513          * Reasons to require version 3:
 514          *
 515          * 1. @object-format is required because our hash algorithm is not
 516          *    SHA1.
 517          * 2. @filter is required because we parsed an object filter.
 518          */
 519         if (the_hash_algo != &hash_algos[GIT_HASH_SHA1] || revs.filter.choice)
 520                 min_version = 3;
 521
 522         if (argc > 1) {
 523                 error(_("unrecognized argument: %s"), argv[1]);
 524                 goto err;
 525         }
 526
 527         bundle_to_stdout = !strcmp(path, "-");
 528         if (bundle_to_stdout)
 529                 bundle_fd = 1;
 530         else
 531                 bundle_fd = hold_lock_file_for_update(&lock, path,
 532                                                       LOCK_DIE_ON_ERROR);
 533
 534         if (version == -1)
 535                 version = min_version;
 536
 537         if (version < 2 || version > 3) {
 538                 die(_("unsupported bundle version %d"), version);
 539         } else if (version < min_version) {
 540                 die(_("cannot write bundle version %d with algorithm %s"), version, the_hash_algo->name);
 541         } else if (version == 2) {
 542                 write_or_die(bundle_fd, v2_bundle_signature, strlen(v2_bundle_signature));
 543         } else {
 544                 const char *capability = "@object-format=";
 545                 write_or_die(bundle_fd, v3_bundle_signature, strlen(v3_bundle_signature));
 546                 write_or_die(bundle_fd, capability, strlen(capability));
 547                 write_or_die(bundle_fd, the_hash_algo->name, strlen(the_hash_algo->name));
 548                 write_or_die(bundle_fd, "\n", 1);
 549
 550                 if (revs.filter.choice) {
 551                         const char *value = expand_list_objects_filter_spec(&revs.filter);
 552                         capability = "@filter=";
 553                         write_or_die(bundle_fd, capability, strlen(capability));
 554                         write_or_die(bundle_fd, value, strlen(value));
 555                         write_or_die(bundle_fd, "\n", 1);
 556                 }
 557         }
 558
 559         /* save revs.pending in revs_copy for later use */
 560         memcpy(&revs_copy, &revs, sizeof(revs));
 561         revs_copy.pending.nr = 0;
 562         revs_copy.pending.alloc = 0;
 563         revs_copy.pending.objects = NULL;
 564         for (i = 0; i < revs.pending.nr; i++) {
 565                 struct object_array_entry *e = revs.pending.objects + i;
 566                 if (e)
 567                         add_object_array_with_path(e->item, e->name,
 568                                                    &revs_copy.pending,
 569                                                    e->mode, e->path);
 570         }
 571
 572         /* write prerequisites */
 573         revs.boundary = 1;
 574         if (prepare_revision_walk(&revs))
 575                 die("revision walk setup failed");
 576         bpi.fd = bundle_fd;
 577         bpi.pending = &revs_copy.pending;
 578
 579         /*
 580          * Remove any object walking here. We only care about commits and
 581          * tags here. The revs_copy has the right instances of these values.
 582          */
 583         revs.blob_objects = revs.tree_objects = 0;
 584         traverse_commit_list(&revs, write_bundle_prerequisites, NULL, &bpi);
 585         object_array_remove_duplicates(&revs_copy.pending);
 586
 587         /* write bundle refs */
 588         ref_count = write_bundle_refs(bundle_fd, &revs_copy);
 589         if (!ref_count)
 590                 die(_("Refusing to create empty bundle."));
 591         else if (ref_count < 0)
 592                 goto err;
 593
 594         /* write pack */
 595         if (write_pack_data(bundle_fd, &revs_copy, pack_options))
 596                 goto err;
 597
 598         if (!bundle_to_stdout) {
 599                 if (commit_lock_file(&lock))
 600                         die_errno(_("cannot create '%s'"), path);
 601         }
 602         return 0;
 603 err:
 604         rollback_lock_file(&lock);
 605         return -1;
 606 }
 607
 608 int unbundle(struct repository *r, struct bundle_header *header,
 609              int bundle_fd, struct strvec *extra_index_pack_args,
 610              enum verify_bundle_flags flags)
 611 {
 612         struct child_process ip = CHILD_PROCESS_INIT;
 613
 614         if (verify_bundle(r, header, flags))
 615                 return -1;
 616
 617         strvec_pushl(&ip.args, "index-pack", "--fix-thin", "--stdin", NULL);
 618
 619         /* If there is a filter, then we need to create the promisor pack. */
 620         if (header->filter.choice)
 621                 strvec_push(&ip.args, "--promisor=from-bundle");
 622
 623         if (extra_index_pack_args) {
 624                 strvec_pushv(&ip.args, extra_index_pack_args->v);
 625                 strvec_clear(extra_index_pack_args);
 626         }
 627
 628         ip.in = bundle_fd;
 629         ip.no_stdout = 1;
 630         ip.git_cmd = 1;
 631         if (run_command(&ip))
 632                 return error(_("index-pack died"));
 633         return 0;
 634 }