4 #include "object-store.h"
5 #include "repository.h"
10 #include "list-objects.h"
11 #include "run-command.h"
14 #include "list-objects-filter-options.h"
16 static const char v2_bundle_signature
[] = "# v2 git bundle\n";
17 static const char v3_bundle_signature
[] = "# v3 git bundle\n";
20 const char *signature
;
22 { 2, v2_bundle_signature
},
23 { 3, v3_bundle_signature
},
26 void bundle_header_init(struct bundle_header
*header
)
28 struct bundle_header blank
= BUNDLE_HEADER_INIT
;
29 memcpy(header
, &blank
, sizeof(*header
));
32 void bundle_header_release(struct bundle_header
*header
)
34 string_list_clear(&header
->prerequisites
, 1);
35 string_list_clear(&header
->references
, 1);
36 list_objects_filter_release(&header
->filter
);
39 static int parse_capability(struct bundle_header
*header
, const char *capability
)
42 if (skip_prefix(capability
, "object-format=", &arg
)) {
43 int algo
= hash_algo_by_name(arg
);
44 if (algo
== GIT_HASH_UNKNOWN
)
45 return error(_("unrecognized bundle hash algorithm: %s"), arg
);
46 header
->hash_algo
= &hash_algos
[algo
];
49 if (skip_prefix(capability
, "filter=", &arg
)) {
50 parse_list_objects_filter(&header
->filter
, arg
);
53 return error(_("unknown capability '%s'"), capability
);
56 static int parse_bundle_signature(struct bundle_header
*header
, const char *line
)
60 for (i
= 0; i
< ARRAY_SIZE(bundle_sigs
); i
++) {
61 if (!strcmp(line
, bundle_sigs
[i
].signature
)) {
62 header
->version
= bundle_sigs
[i
].version
;
69 static int parse_bundle_header(int fd
, struct bundle_header
*header
,
70 const char *report_path
)
72 struct strbuf buf
= STRBUF_INIT
;
75 /* The bundle header begins with the signature */
76 if (strbuf_getwholeline_fd(&buf
, fd
, '\n') ||
77 parse_bundle_signature(header
, buf
.buf
)) {
79 error(_("'%s' does not look like a v2 or v3 bundle file"),
85 header
->hash_algo
= the_hash_algo
;
87 /* The bundle header ends with an empty line */
88 while (!strbuf_getwholeline_fd(&buf
, fd
, '\n') &&
89 buf
.len
&& buf
.buf
[0] != '\n') {
96 if (header
->version
== 3 && *buf
.buf
== '@') {
97 if (parse_capability(header
, buf
.buf
+ 1)) {
104 if (*buf
.buf
== '-') {
106 strbuf_remove(&buf
, 0, 1);
110 * Tip lines have object name, SP, and refname.
111 * Prerequisites have object name that is optionally
112 * followed by SP and subject line.
114 if (parse_oid_hex_algop(buf
.buf
, &oid
, &p
, header
->hash_algo
) ||
115 (*p
&& !isspace(*p
)) ||
116 (!is_prereq
&& !*p
)) {
118 error(_("unrecognized header: %s%s (%d)"),
119 (is_prereq
? "-" : ""), buf
.buf
, (int)buf
.len
);
123 struct object_id
*dup
= oiddup(&oid
);
125 string_list_append(&header
->prerequisites
, "")->util
= dup
;
127 string_list_append(&header
->references
, p
+ 1)->util
= dup
;
136 strbuf_release(&buf
);
140 int read_bundle_header(const char *path
, struct bundle_header
*header
)
142 int fd
= open(path
, O_RDONLY
);
145 return error(_("could not open '%s'"), path
);
146 return parse_bundle_header(fd
, header
, path
);
149 int is_bundle(const char *path
, int quiet
)
151 struct bundle_header header
= BUNDLE_HEADER_INIT
;
152 int fd
= open(path
, O_RDONLY
);
156 fd
= parse_bundle_header(fd
, &header
, quiet
? NULL
: path
);
159 bundle_header_release(&header
);
163 static int list_refs(struct string_list
*r
, int argc
, const char **argv
)
167 for (i
= 0; i
< r
->nr
; i
++) {
168 struct object_id
*oid
;
173 for (j
= 1; j
< argc
; j
++)
174 if (!strcmp(r
->items
[i
].string
, argv
[j
]))
180 oid
= r
->items
[i
].util
;
181 name
= r
->items
[i
].string
;
182 printf("%s %s\n", oid_to_hex(oid
), name
);
187 /* Remember to update object flag allocation in object.h */
188 #define PREREQ_MARK (1u<<16)
190 int verify_bundle(struct repository
*r
,
191 struct bundle_header
*header
,
195 * Do fast check, then if any prereqs are missing then go line by line
196 * to be verbose about the errors
198 struct string_list
*p
= &header
->prerequisites
;
199 struct rev_info revs
;
200 const char *argv
[] = {NULL
, "--all", NULL
};
201 struct commit
*commit
;
202 int i
, ret
= 0, req_nr
;
203 const char *message
= _("Repository lacks these prerequisite commits:");
205 if (!r
|| !r
->objects
|| !r
->objects
->odb
)
206 return error(_("need a repository to verify a bundle"));
208 repo_init_revisions(r
, &revs
, NULL
);
209 for (i
= 0; i
< p
->nr
; i
++) {
210 struct string_list_item
*e
= p
->items
+ i
;
211 const char *name
= e
->string
;
212 struct object_id
*oid
= e
->util
;
213 struct object
*o
= parse_object(r
, oid
);
215 o
->flags
|= PREREQ_MARK
;
216 add_pending_object(&revs
, o
, name
);
220 error("%s", message
);
221 error("%s %s", oid_to_hex(oid
), name
);
223 if (revs
.pending
.nr
!= p
->nr
)
225 req_nr
= revs
.pending
.nr
;
226 setup_revisions(2, argv
, &revs
, NULL
);
228 list_objects_filter_copy(&revs
.filter
, &header
->filter
);
230 if (prepare_revision_walk(&revs
))
231 die(_("revision walk setup failed"));
234 while (i
&& (commit
= get_revision(&revs
)))
235 if (commit
->object
.flags
& PREREQ_MARK
)
238 for (i
= 0; i
< p
->nr
; i
++) {
239 struct string_list_item
*e
= p
->items
+ i
;
240 const char *name
= e
->string
;
241 const struct object_id
*oid
= e
->util
;
242 struct object
*o
= parse_object(r
, oid
);
243 assert(o
); /* otherwise we'd have returned early */
244 if (o
->flags
& SHOWN
)
247 error("%s", message
);
248 error("%s %s", oid_to_hex(oid
), name
);
251 /* Clean up objects used, as they will be reused. */
252 for (i
= 0; i
< p
->nr
; i
++) {
253 struct string_list_item
*e
= p
->items
+ i
;
254 struct object_id
*oid
= e
->util
;
255 commit
= lookup_commit_reference_gently(r
, oid
, 1);
257 clear_commit_marks(commit
, ALL_REV_FLAGS
);
261 struct string_list
*r
;
263 r
= &header
->references
;
264 printf_ln(Q_("The bundle contains this ref:",
265 "The bundle contains these %"PRIuMAX
" refs:",
268 list_refs(r
, 0, NULL
);
270 if (header
->filter
.choice
) {
271 printf_ln("The bundle uses this filter: %s",
272 list_objects_filter_spec(&header
->filter
));
275 r
= &header
->prerequisites
;
277 printf_ln(_("The bundle records a complete history."));
279 printf_ln(Q_("The bundle requires this ref:",
280 "The bundle requires these %"PRIuMAX
" refs:",
283 list_refs(r
, 0, NULL
);
289 int list_bundle_refs(struct bundle_header
*header
, int argc
, const char **argv
)
291 return list_refs(&header
->references
, argc
, argv
);
294 static int is_tag_in_date_range(struct object
*tag
, struct rev_info
*revs
)
297 enum object_type type
;
298 char *buf
= NULL
, *line
, *lineend
;
302 if (revs
->max_age
== -1 && revs
->min_age
== -1)
305 buf
= read_object_file(&tag
->oid
, &type
, &size
);
308 line
= memmem(buf
, size
, "\ntagger ", 8);
311 lineend
= memchr(line
, '\n', buf
+ size
- line
);
312 line
= memchr(line
, '>', lineend
? lineend
- line
: buf
+ size
- line
);
315 date
= parse_timestamp(line
, NULL
, 10);
316 result
= (revs
->max_age
== -1 || revs
->max_age
< date
) &&
317 (revs
->min_age
== -1 || revs
->min_age
> date
);
324 /* Write the pack data to bundle_fd */
325 static int write_pack_data(int bundle_fd
, struct rev_info
*revs
, struct strvec
*pack_options
)
327 struct child_process pack_objects
= CHILD_PROCESS_INIT
;
330 strvec_pushl(&pack_objects
.args
,
332 "--stdout", "--thin", "--delta-base-offset",
334 strvec_pushv(&pack_objects
.args
, pack_options
->v
);
335 if (revs
->filter
.choice
)
336 strvec_pushf(&pack_objects
.args
, "--filter=%s",
337 list_objects_filter_spec(&revs
->filter
));
338 pack_objects
.in
= -1;
339 pack_objects
.out
= bundle_fd
;
340 pack_objects
.git_cmd
= 1;
343 * start_command() will close our descriptor if it's >1. Duplicate it
344 * to avoid surprising the caller.
346 if (pack_objects
.out
> 1) {
347 pack_objects
.out
= dup(pack_objects
.out
);
348 if (pack_objects
.out
< 0) {
349 error_errno(_("unable to dup bundle descriptor"));
350 child_process_clear(&pack_objects
);
355 if (start_command(&pack_objects
))
356 return error(_("Could not spawn pack-objects"));
358 for (i
= 0; i
< revs
->pending
.nr
; i
++) {
359 struct object
*object
= revs
->pending
.objects
[i
].item
;
360 if (object
->flags
& UNINTERESTING
)
361 write_or_die(pack_objects
.in
, "^", 1);
362 write_or_die(pack_objects
.in
, oid_to_hex(&object
->oid
), the_hash_algo
->hexsz
);
363 write_or_die(pack_objects
.in
, "\n", 1);
365 close(pack_objects
.in
);
366 if (finish_command(&pack_objects
))
367 return error(_("pack-objects died"));
372 * Write out bundle refs based on the tips already
373 * parsed into revs.pending. As a side effect, may
374 * manipulate revs.pending to include additional
375 * necessary objects (like tags).
377 * Returns the number of refs written, or negative
380 static int write_bundle_refs(int bundle_fd
, struct rev_info
*revs
)
385 for (i
= 0; i
< revs
->pending
.nr
; i
++) {
386 struct object_array_entry
*e
= revs
->pending
.objects
+ i
;
387 struct object_id oid
;
389 const char *display_ref
;
392 if (e
->item
->flags
& UNINTERESTING
)
394 if (dwim_ref(e
->name
, strlen(e
->name
), &oid
, &ref
, 0) != 1)
396 if (read_ref_full(e
->name
, RESOLVE_REF_READING
, &oid
, &flag
))
398 display_ref
= (flag
& REF_ISSYMREF
) ? e
->name
: ref
;
400 if (e
->item
->type
== OBJ_TAG
&&
401 !is_tag_in_date_range(e
->item
, revs
)) {
402 e
->item
->flags
|= UNINTERESTING
;
407 * Make sure the refs we wrote out is correct; --max-count and
408 * other limiting options could have prevented all the tips
409 * from getting output.
411 * Non commit objects such as tags and blobs do not have
412 * this issue as they are not affected by those extra
415 if (!(e
->item
->flags
& SHOWN
) && e
->item
->type
== OBJ_COMMIT
) {
416 warning(_("ref '%s' is excluded by the rev-list options"),
421 * If you run "git bundle create bndl v1.0..v2.0", the
422 * name of the positive ref is "v2.0" but that is the
423 * commit that is referenced by the tag, and not the tag
426 if (!oideq(&oid
, &e
->item
->oid
)) {
428 * Is this the positive end of a range expressed
429 * in terms of a tag (e.g. v2.0 from the range
432 struct commit
*one
= lookup_commit_reference(revs
->repo
, &oid
);
435 if (e
->item
== &(one
->object
)) {
437 * Need to include e->name as an
438 * independent ref to the pack-objects
439 * input, so that the tag is included
440 * in the output; otherwise we would
441 * end up triggering "empty bundle"
444 obj
= parse_object_or_die(&oid
, e
->name
);
446 add_pending_object(revs
, obj
, e
->name
);
452 write_or_die(bundle_fd
, oid_to_hex(&e
->item
->oid
), the_hash_algo
->hexsz
);
453 write_or_die(bundle_fd
, " ", 1);
454 write_or_die(bundle_fd
, display_ref
, strlen(display_ref
));
455 write_or_die(bundle_fd
, "\n", 1);
461 write_or_die(bundle_fd
, "\n", 1);
465 struct bundle_prerequisites_info
{
466 struct object_array
*pending
;
470 static void write_bundle_prerequisites(struct commit
*commit
, void *data
)
472 struct bundle_prerequisites_info
*bpi
= data
;
473 struct object
*object
;
474 struct pretty_print_context ctx
= { 0 };
475 struct strbuf buf
= STRBUF_INIT
;
477 if (!(commit
->object
.flags
& BOUNDARY
))
479 strbuf_addf(&buf
, "-%s ", oid_to_hex(&commit
->object
.oid
));
480 write_or_die(bpi
->fd
, buf
.buf
, buf
.len
);
482 ctx
.fmt
= CMIT_FMT_ONELINE
;
483 ctx
.output_encoding
= get_log_output_encoding();
485 pretty_print_commit(&ctx
, commit
, &buf
);
488 object
= (struct object
*)commit
;
489 object
->flags
|= UNINTERESTING
;
490 add_object_array_with_path(object
, buf
.buf
, bpi
->pending
, S_IFINVALID
,
492 strbuf_addch(&buf
, '\n');
493 write_or_die(bpi
->fd
, buf
.buf
, buf
.len
);
494 strbuf_release(&buf
);
497 int create_bundle(struct repository
*r
, const char *path
,
498 int argc
, const char **argv
, struct strvec
*pack_options
, int version
)
500 struct lock_file lock
= LOCK_INIT
;
502 int bundle_to_stdout
;
504 struct rev_info revs
, revs_copy
;
506 struct bundle_prerequisites_info bpi
;
509 /* init revs to list objects for pack-objects later */
510 save_commit_buffer
= 0;
511 repo_init_revisions(r
, &revs
, NULL
);
514 * Pre-initialize the '--objects' flag so we can parse a
515 * --filter option successfully.
517 revs
.tree_objects
= revs
.blob_objects
= 1;
519 argc
= setup_revisions(argc
, argv
, &revs
, NULL
);
522 * Reasons to require version 3:
524 * 1. @object-format is required because our hash algorithm is not
526 * 2. @filter is required because we parsed an object filter.
528 if (the_hash_algo
!= &hash_algos
[GIT_HASH_SHA1
] || revs
.filter
.choice
)
532 error(_("unrecognized argument: %s"), argv
[1]);
536 bundle_to_stdout
= !strcmp(path
, "-");
537 if (bundle_to_stdout
)
540 bundle_fd
= hold_lock_file_for_update(&lock
, path
,
544 version
= min_version
;
546 if (version
< 2 || version
> 3) {
547 die(_("unsupported bundle version %d"), version
);
548 } else if (version
< min_version
) {
549 die(_("cannot write bundle version %d with algorithm %s"), version
, the_hash_algo
->name
);
550 } else if (version
== 2) {
551 write_or_die(bundle_fd
, v2_bundle_signature
, strlen(v2_bundle_signature
));
553 const char *capability
= "@object-format=";
554 write_or_die(bundle_fd
, v3_bundle_signature
, strlen(v3_bundle_signature
));
555 write_or_die(bundle_fd
, capability
, strlen(capability
));
556 write_or_die(bundle_fd
, the_hash_algo
->name
, strlen(the_hash_algo
->name
));
557 write_or_die(bundle_fd
, "\n", 1);
559 if (revs
.filter
.choice
) {
560 const char *value
= expand_list_objects_filter_spec(&revs
.filter
);
561 capability
= "@filter=";
562 write_or_die(bundle_fd
, capability
, strlen(capability
));
563 write_or_die(bundle_fd
, value
, strlen(value
));
564 write_or_die(bundle_fd
, "\n", 1);
568 /* save revs.pending in revs_copy for later use */
569 memcpy(&revs_copy
, &revs
, sizeof(revs
));
570 revs_copy
.pending
.nr
= 0;
571 revs_copy
.pending
.alloc
= 0;
572 revs_copy
.pending
.objects
= NULL
;
573 for (i
= 0; i
< revs
.pending
.nr
; i
++) {
574 struct object_array_entry
*e
= revs
.pending
.objects
+ i
;
576 add_object_array_with_path(e
->item
, e
->name
,
581 /* write prerequisites */
583 if (prepare_revision_walk(&revs
))
584 die("revision walk setup failed");
586 bpi
.pending
= &revs_copy
.pending
;
589 * Remove any object walking here. We only care about commits and
590 * tags here. The revs_copy has the right instances of these values.
592 revs
.blob_objects
= revs
.tree_objects
= 0;
593 traverse_commit_list(&revs
, write_bundle_prerequisites
, NULL
, &bpi
);
594 object_array_remove_duplicates(&revs_copy
.pending
);
596 /* write bundle refs */
597 ref_count
= write_bundle_refs(bundle_fd
, &revs_copy
);
599 die(_("Refusing to create empty bundle."));
600 else if (ref_count
< 0)
604 if (write_pack_data(bundle_fd
, &revs_copy
, pack_options
))
607 if (!bundle_to_stdout
) {
608 if (commit_lock_file(&lock
))
609 die_errno(_("cannot create '%s'"), path
);
613 rollback_lock_file(&lock
);
617 int unbundle(struct repository
*r
, struct bundle_header
*header
,
618 int bundle_fd
, struct strvec
*extra_index_pack_args
)
620 struct child_process ip
= CHILD_PROCESS_INIT
;
621 strvec_pushl(&ip
.args
, "index-pack", "--fix-thin", "--stdin", NULL
);
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");
627 if (extra_index_pack_args
) {
628 strvec_pushv(&ip
.args
, extra_index_pack_args
->v
);
629 strvec_clear(extra_index_pack_args
);
632 if (verify_bundle(r
, header
, 0))
637 if (run_command(&ip
))
638 return error(_("index-pack died"));