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