8 #include "list-objects.h"
9 #include "run-command.h"
11 #include "argv-array.h"
13 static const char bundle_signature
[] = "# v2 git bundle\n";
15 static void add_to_ref_list(const unsigned char *sha1
, const char *name
,
16 struct ref_list
*list
)
18 ALLOC_GROW(list
->list
, list
->nr
+ 1, list
->alloc
);
19 hashcpy(list
->list
[list
->nr
].sha1
, sha1
);
20 list
->list
[list
->nr
].name
= xstrdup(name
);
24 static int parse_bundle_header(int fd
, struct bundle_header
*header
,
25 const char *report_path
)
27 struct strbuf buf
= STRBUF_INIT
;
30 /* The bundle header begins with the signature */
31 if (strbuf_getwholeline_fd(&buf
, fd
, '\n') ||
32 strcmp(buf
.buf
, bundle_signature
)) {
34 error(_("'%s' does not look like a v2 bundle file"),
40 /* The bundle header ends with an empty line */
41 while (!strbuf_getwholeline_fd(&buf
, fd
, '\n') &&
42 buf
.len
&& buf
.buf
[0] != '\n') {
43 unsigned char sha1
[20];
46 if (*buf
.buf
== '-') {
48 strbuf_remove(&buf
, 0, 1);
53 * Tip lines have object name, SP, and refname.
54 * Prerequisites have object name that is optionally
55 * followed by SP and subject line.
57 if (get_sha1_hex(buf
.buf
, sha1
) ||
58 (buf
.len
> 40 && !isspace(buf
.buf
[40])) ||
59 (!is_prereq
&& buf
.len
<= 40)) {
61 error(_("unrecognized header: %s%s (%d)"),
62 (is_prereq
? "-" : ""), buf
.buf
, (int)buf
.len
);
67 add_to_ref_list(sha1
, "", &header
->prerequisites
);
69 add_to_ref_list(sha1
, buf
.buf
+ 41, &header
->references
);
82 int read_bundle_header(const char *path
, struct bundle_header
*header
)
84 int fd
= open(path
, O_RDONLY
);
87 return error(_("could not open '%s'"), path
);
88 return parse_bundle_header(fd
, header
, path
);
91 int is_bundle(const char *path
, int quiet
)
93 struct bundle_header header
;
94 int fd
= open(path
, O_RDONLY
);
98 memset(&header
, 0, sizeof(header
));
99 fd
= parse_bundle_header(fd
, &header
, quiet
? NULL
: path
);
105 static int list_refs(struct ref_list
*r
, int argc
, const char **argv
)
109 for (i
= 0; i
< r
->nr
; i
++) {
112 for (j
= 1; j
< argc
; j
++)
113 if (!strcmp(r
->list
[i
].name
, argv
[j
]))
118 printf("%s %s\n", sha1_to_hex(r
->list
[i
].sha1
),
124 /* Remember to update object flag allocation in object.h */
125 #define PREREQ_MARK (1u<<16)
127 int verify_bundle(struct bundle_header
*header
, int verbose
)
130 * Do fast check, then if any prereqs are missing then go line by line
131 * to be verbose about the errors
133 struct ref_list
*p
= &header
->prerequisites
;
134 struct rev_info revs
;
135 const char *argv
[] = {NULL
, "--all", NULL
};
136 struct object_array refs
;
137 struct commit
*commit
;
138 int i
, ret
= 0, req_nr
;
139 const char *message
= _("Repository lacks these prerequisite commits:");
141 init_revisions(&revs
, NULL
);
142 for (i
= 0; i
< p
->nr
; i
++) {
143 struct ref_list_entry
*e
= p
->list
+ i
;
144 struct object
*o
= parse_object(e
->sha1
);
146 o
->flags
|= PREREQ_MARK
;
147 add_pending_object(&revs
, o
, e
->name
);
151 error("%s", message
);
152 error("%s %s", sha1_to_hex(e
->sha1
), e
->name
);
154 if (revs
.pending
.nr
!= p
->nr
)
156 req_nr
= revs
.pending
.nr
;
157 setup_revisions(2, argv
, &revs
, NULL
);
160 revs
.leak_pending
= 1;
162 if (prepare_revision_walk(&revs
))
163 die(_("revision walk setup failed"));
166 while (i
&& (commit
= get_revision(&revs
)))
167 if (commit
->object
.flags
& PREREQ_MARK
)
170 for (i
= 0; i
< req_nr
; i
++)
171 if (!(refs
.objects
[i
].item
->flags
& SHOWN
)) {
173 error("%s", message
);
174 error("%s %s", sha1_to_hex(refs
.objects
[i
].item
->sha1
),
175 refs
.objects
[i
].name
);
178 clear_commit_marks_for_object_array(&refs
, ALL_REV_FLAGS
);
184 r
= &header
->references
;
185 printf_ln(Q_("The bundle contains this ref:",
186 "The bundle contains these %d refs:",
189 list_refs(r
, 0, NULL
);
190 r
= &header
->prerequisites
;
192 printf_ln(_("The bundle records a complete history."));
194 printf_ln(Q_("The bundle requires this ref:",
195 "The bundle requires these %d refs:",
198 list_refs(r
, 0, NULL
);
204 int list_bundle_refs(struct bundle_header
*header
, int argc
, const char **argv
)
206 return list_refs(&header
->references
, argc
, argv
);
209 static int is_tag_in_date_range(struct object
*tag
, struct rev_info
*revs
)
212 enum object_type type
;
213 char *buf
= NULL
, *line
, *lineend
;
217 if (revs
->max_age
== -1 && revs
->min_age
== -1)
220 buf
= read_sha1_file(tag
->sha1
, &type
, &size
);
223 line
= memmem(buf
, size
, "\ntagger ", 8);
226 lineend
= memchr(line
, '\n', buf
+ size
- line
);
227 line
= memchr(line
, '>', lineend
? lineend
- line
: buf
+ size
- line
);
230 date
= strtoul(line
, NULL
, 10);
231 result
= (revs
->max_age
== -1 || revs
->max_age
< date
) &&
232 (revs
->min_age
== -1 || revs
->min_age
> date
);
239 /* Write the pack data to bundle_fd, then close it if it is > 1. */
240 static int write_pack_data(int bundle_fd
, struct rev_info
*revs
)
242 struct child_process pack_objects
= CHILD_PROCESS_INIT
;
245 argv_array_pushl(&pack_objects
.args
,
246 "pack-objects", "--all-progress-implied",
247 "--stdout", "--thin", "--delta-base-offset",
249 pack_objects
.in
= -1;
250 pack_objects
.out
= bundle_fd
;
251 pack_objects
.git_cmd
= 1;
252 if (start_command(&pack_objects
))
253 return error(_("Could not spawn pack-objects"));
255 for (i
= 0; i
< revs
->pending
.nr
; i
++) {
256 struct object
*object
= revs
->pending
.objects
[i
].item
;
257 if (object
->flags
& UNINTERESTING
)
258 write_or_die(pack_objects
.in
, "^", 1);
259 write_or_die(pack_objects
.in
, sha1_to_hex(object
->sha1
), 40);
260 write_or_die(pack_objects
.in
, "\n", 1);
262 close(pack_objects
.in
);
263 if (finish_command(&pack_objects
))
264 return error(_("pack-objects died"));
268 static int compute_and_write_prerequisites(int bundle_fd
,
269 struct rev_info
*revs
,
270 int argc
, const char **argv
)
272 struct child_process rls
= CHILD_PROCESS_INIT
;
273 struct strbuf buf
= STRBUF_INIT
;
277 argv_array_pushl(&rls
.args
,
278 "rev-list", "--boundary", "--pretty=oneline",
280 for (i
= 1; i
< argc
; i
++)
281 argv_array_push(&rls
.args
, argv
[i
]);
284 if (start_command(&rls
))
286 rls_fout
= xfdopen(rls
.out
, "r");
287 while (strbuf_getwholeline(&buf
, rls_fout
, '\n') != EOF
) {
288 unsigned char sha1
[20];
289 if (buf
.len
> 0 && buf
.buf
[0] == '-') {
290 write_or_die(bundle_fd
, buf
.buf
, buf
.len
);
291 if (!get_sha1_hex(buf
.buf
+ 1, sha1
)) {
292 struct object
*object
= parse_object_or_die(sha1
, buf
.buf
);
293 object
->flags
|= UNINTERESTING
;
294 add_pending_object(revs
, object
, buf
.buf
);
296 } else if (!get_sha1_hex(buf
.buf
, sha1
)) {
297 struct object
*object
= parse_object_or_die(sha1
, buf
.buf
);
298 object
->flags
|= SHOWN
;
301 strbuf_release(&buf
);
303 if (finish_command(&rls
))
304 return error(_("rev-list died"));
309 * Write out bundle refs based on the tips already
310 * parsed into revs.pending. As a side effect, may
311 * manipulate revs.pending to include additional
312 * necessary objects (like tags).
314 * Returns the number of refs written, or negative
317 static int write_bundle_refs(int bundle_fd
, struct rev_info
*revs
)
322 for (i
= 0; i
< revs
->pending
.nr
; i
++) {
323 struct object_array_entry
*e
= revs
->pending
.objects
+ i
;
324 unsigned char sha1
[20];
326 const char *display_ref
;
329 if (e
->item
->flags
& UNINTERESTING
)
331 if (dwim_ref(e
->name
, strlen(e
->name
), sha1
, &ref
) != 1)
333 if (read_ref_full(e
->name
, RESOLVE_REF_READING
, sha1
, &flag
))
335 display_ref
= (flag
& REF_ISSYMREF
) ? e
->name
: ref
;
337 if (e
->item
->type
== OBJ_TAG
&&
338 !is_tag_in_date_range(e
->item
, revs
)) {
339 e
->item
->flags
|= UNINTERESTING
;
344 * Make sure the refs we wrote out is correct; --max-count and
345 * other limiting options could have prevented all the tips
346 * from getting output.
348 * Non commit objects such as tags and blobs do not have
349 * this issue as they are not affected by those extra
352 if (!(e
->item
->flags
& SHOWN
) && e
->item
->type
== OBJ_COMMIT
) {
353 warning(_("ref '%s' is excluded by the rev-list options"),
358 * If you run "git bundle create bndl v1.0..v2.0", the
359 * name of the positive ref is "v2.0" but that is the
360 * commit that is referenced by the tag, and not the tag
363 if (hashcmp(sha1
, e
->item
->sha1
)) {
365 * Is this the positive end of a range expressed
366 * in terms of a tag (e.g. v2.0 from the range
369 struct commit
*one
= lookup_commit_reference(sha1
);
372 if (e
->item
== &(one
->object
)) {
374 * Need to include e->name as an
375 * independent ref to the pack-objects
376 * input, so that the tag is included
377 * in the output; otherwise we would
378 * end up triggering "empty bundle"
381 obj
= parse_object_or_die(sha1
, e
->name
);
383 add_pending_object(revs
, obj
, e
->name
);
389 write_or_die(bundle_fd
, sha1_to_hex(e
->item
->sha1
), 40);
390 write_or_die(bundle_fd
, " ", 1);
391 write_or_die(bundle_fd
, display_ref
, strlen(display_ref
));
392 write_or_die(bundle_fd
, "\n", 1);
398 write_or_die(bundle_fd
, "\n", 1);
402 int create_bundle(struct bundle_header
*header
, const char *path
,
403 int argc
, const char **argv
)
405 static struct lock_file lock
;
407 int bundle_to_stdout
;
409 struct rev_info revs
;
411 bundle_to_stdout
= !strcmp(path
, "-");
412 if (bundle_to_stdout
)
415 bundle_fd
= hold_lock_file_for_update(&lock
, path
,
419 * write_pack_data() will close the fd passed to it,
420 * but commit_lock_file() will also try to close the
421 * lockfile's fd. So make a copy of the file
422 * descriptor to avoid trying to close it twice.
424 bundle_fd
= dup(bundle_fd
);
426 die_errno("unable to dup file descriptor");
429 /* write signature */
430 write_or_die(bundle_fd
, bundle_signature
, strlen(bundle_signature
));
432 /* init revs to list objects for pack-objects later */
433 save_commit_buffer
= 0;
434 init_revisions(&revs
, NULL
);
436 /* write prerequisites */
437 if (compute_and_write_prerequisites(bundle_fd
, &revs
, argc
, argv
))
440 argc
= setup_revisions(argc
, argv
, &revs
, NULL
);
443 return error(_("unrecognized argument: %s"), argv
[1]);
445 object_array_remove_duplicates(&revs
.pending
);
447 ref_count
= write_bundle_refs(bundle_fd
, &revs
);
449 die(_("Refusing to create empty bundle."));
450 else if (ref_count
< 0)
454 if (write_pack_data(bundle_fd
, &revs
))
457 if (!bundle_to_stdout
) {
458 if (commit_lock_file(&lock
))
459 die_errno(_("cannot create '%s'"), path
);
464 int unbundle(struct bundle_header
*header
, int bundle_fd
, int flags
)
466 const char *argv_index_pack
[] = {"index-pack",
467 "--fix-thin", "--stdin", NULL
, NULL
};
468 struct child_process ip
= CHILD_PROCESS_INIT
;
470 if (flags
& BUNDLE_VERBOSE
)
471 argv_index_pack
[3] = "-v";
473 if (verify_bundle(header
, 0))
475 ip
.argv
= argv_index_pack
;
479 if (run_command(&ip
))
480 return error(_("index-pack died"));