14 static const char fetch_pack_usage[] =
15 "git-fetch-pack [--all] [-q] [-v] [-k] [--thin] [--exec=upload-pack] [host:]directory <refs>...";
16 static const char *exec = "git-upload-pack";
18 #define COMPLETE (1U << 0)
19 #define COMMON (1U << 1)
20 #define COMMON_REF (1U << 2)
21 #define SEEN (1U << 3)
22 #define POPPED (1U << 4)
25 * After sending this many "have"s if we do not get any new ACK , we
26 * give up traversing our history.
28 #define MAX_IN_VAIN 256
30 static struct commit_list *rev_list;
31 static int non_common_revs, multi_ack, use_thin_pack, use_sideband;
33 static void rev_list_push(struct commit *commit, int mark)
35 if (!(commit->object.flags & mark)) {
36 commit->object.flags |= mark;
38 if (!(commit->object.parsed))
41 insert_by_date(commit, &rev_list);
43 if (!(commit->object.flags & COMMON))
48 static int rev_list_insert_ref(const char *path, const unsigned char *sha1, int flag, void *cb_data)
50 struct object *o = deref_tag(parse_object(sha1), path, 0);
52 if (o && o->type == OBJ_COMMIT)
53 rev_list_push((struct commit *)o, SEEN);
59 This function marks a rev and its ancestors as common.
60 In some cases, it is desirable to mark only the ancestors (for example
61 when only the server does not yet know that they are common).
64 static void mark_common(struct commit *commit,
65 int ancestors_only, int dont_parse)
67 if (commit != NULL && !(commit->object.flags & COMMON)) {
68 struct object *o = (struct object *)commit;
73 if (!(o->flags & SEEN))
74 rev_list_push(commit, SEEN);
76 struct commit_list *parents;
78 if (!ancestors_only && !(o->flags & POPPED))
80 if (!o->parsed && !dont_parse)
83 for (parents = commit->parents;
85 parents = parents->next)
86 mark_common(parents->item, 0, dont_parse);
92 Get the next rev to send, ignoring the common.
95 static const unsigned char* get_rev(void)
97 struct commit *commit = NULL;
99 while (commit == NULL) {
101 struct commit_list* parents;
103 if (rev_list == NULL || non_common_revs == 0)
106 commit = rev_list->item;
107 if (!(commit->object.parsed))
108 parse_commit(commit);
109 commit->object.flags |= POPPED;
110 if (!(commit->object.flags & COMMON))
113 parents = commit->parents;
115 if (commit->object.flags & COMMON) {
116 /* do not send "have", and ignore ancestors */
118 mark = COMMON | SEEN;
119 } else if (commit->object.flags & COMMON_REF)
120 /* send "have", and ignore ancestors */
121 mark = COMMON | SEEN;
123 /* send "have", also for its ancestors */
127 if (!(parents->item->object.flags & SEEN))
128 rev_list_push(parents->item, mark);
130 mark_common(parents->item, 1, 0);
131 parents = parents->next;
134 rev_list = rev_list->next;
137 return commit->object.sha1;
140 static int find_common(int fd[2], unsigned char *result_sha1,
144 int count = 0, flushes = 0, retval;
145 const unsigned char *sha1;
146 unsigned in_vain = 0;
147 int got_continue = 0;
149 for_each_ref(rev_list_insert_ref, NULL);
152 for ( ; refs ; refs = refs->next) {
153 unsigned char *remote = refs->old_sha1;
157 * If that object is complete (i.e. it is an ancestor of a
158 * local ref), we tell them we have it but do not have to
159 * tell them about its ancestors, which they already know
162 * We use lookup_object here because we are only
163 * interested in the case we *know* the object is
164 * reachable and we have already scanned it.
166 if (((o = lookup_object(remote)) != NULL) &&
167 (o->flags & COMPLETE)) {
172 packet_write(fd[1], "want %s%s%s%s%s%s\n",
174 (multi_ack ? " multi_ack" : ""),
175 (use_sideband == 2 ? " side-band-64k" : ""),
176 (use_sideband == 1 ? " side-band" : ""),
177 (use_thin_pack ? " thin-pack" : ""),
180 packet_write(fd[1], "want %s\n", sha1_to_hex(remote));
183 if (is_repository_shallow())
184 write_shallow_commits(fd[1], 1);
191 while ((sha1 = get_rev())) {
192 packet_write(fd[1], "have %s\n", sha1_to_hex(sha1));
194 fprintf(stderr, "have %s\n", sha1_to_hex(sha1));
196 if (!(31 & ++count)) {
203 * We keep one window "ahead" of the other side, and
204 * will wait for an ACK only on the next one
210 ack = get_ack(fd[0], result_sha1);
212 fprintf(stderr, "got ack %d %s\n", ack,
213 sha1_to_hex(result_sha1));
219 } else if (ack == 2) {
220 struct commit *commit =
221 lookup_commit(result_sha1);
222 mark_common(commit, 0, 1);
229 if (got_continue && MAX_IN_VAIN < in_vain) {
231 fprintf(stderr, "giving up\n");
237 packet_write(fd[1], "done\n");
239 fprintf(stderr, "done\n");
244 while (flushes || multi_ack) {
245 int ack = get_ack(fd[0], result_sha1);
248 fprintf(stderr, "got ack (%d) %s\n", ack,
249 sha1_to_hex(result_sha1));
260 static struct commit_list *complete;
262 static int mark_complete(const char *path, const unsigned char *sha1, int flag, void *cb_data)
264 struct object *o = parse_object(sha1);
266 while (o && o->type == OBJ_TAG) {
267 struct tag *t = (struct tag *) o;
269 break; /* broken repository */
270 o->flags |= COMPLETE;
271 o = parse_object(t->tagged->sha1);
273 if (o && o->type == OBJ_COMMIT) {
274 struct commit *commit = (struct commit *)o;
275 commit->object.flags |= COMPLETE;
276 insert_by_date(commit, &complete);
281 static void mark_recent_complete_commits(unsigned long cutoff)
283 while (complete && cutoff <= complete->item->date) {
285 fprintf(stderr, "Marking %s as complete\n",
286 sha1_to_hex(complete->item->object.sha1));
287 pop_most_recent_commit(&complete, COMPLETE);
291 static void filter_refs(struct ref **refs, int nr_match, char **match)
293 struct ref **return_refs;
294 struct ref *newlist = NULL;
295 struct ref **newtail = &newlist;
296 struct ref *ref, *next;
297 struct ref *fastarray[32];
299 if (nr_match && !fetch_all) {
300 if (ARRAY_SIZE(fastarray) < nr_match)
301 return_refs = xcalloc(nr_match, sizeof(struct ref *));
303 return_refs = fastarray;
304 memset(return_refs, 0, sizeof(struct ref *) * nr_match);
310 for (ref = *refs; ref; ref = next) {
312 if (!memcmp(ref->name, "refs/", 5) &&
313 check_ref_format(ref->name + 5))
315 else if (fetch_all) {
318 newtail = &ref->next;
322 int order = path_match(ref->name, nr_match, match);
324 return_refs[order-1] = ref;
325 continue; /* we will link it later */
333 for (i = 0; i < nr_match; i++) {
334 ref = return_refs[i];
338 newtail = &ref->next;
341 if (return_refs != fastarray)
347 static int everything_local(struct ref **refs, int nr_match, char **match)
351 unsigned long cutoff = 0;
353 track_object_refs = 0;
354 save_commit_buffer = 0;
356 for (ref = *refs; ref; ref = ref->next) {
359 o = parse_object(ref->old_sha1);
363 /* We already have it -- which may mean that we were
364 * in sync with the other side at some time after
365 * that (it is OK if we guess wrong here).
367 if (o->type == OBJ_COMMIT) {
368 struct commit *commit = (struct commit *)o;
369 if (!cutoff || cutoff < commit->date)
370 cutoff = commit->date;
374 for_each_ref(mark_complete, NULL);
376 mark_recent_complete_commits(cutoff);
379 * Mark all complete remote refs as common refs.
380 * Don't mark them common yet; the server has to be told so first.
382 for (ref = *refs; ref; ref = ref->next) {
383 struct object *o = deref_tag(lookup_object(ref->old_sha1),
386 if (!o || o->type != OBJ_COMMIT || !(o->flags & COMPLETE))
389 if (!(o->flags & SEEN)) {
390 rev_list_push((struct commit *)o, COMMON_REF | SEEN);
392 mark_common((struct commit *)o, 1, 1);
396 filter_refs(refs, nr_match, match);
398 for (retval = 1, ref = *refs; ref ; ref = ref->next) {
399 const unsigned char *remote = ref->old_sha1;
400 unsigned char local[20];
403 o = lookup_object(remote);
404 if (!o || !(o->flags & COMPLETE)) {
409 "want %s (%s)\n", sha1_to_hex(remote),
414 hashcpy(ref->new_sha1, local);
418 "already have %s (%s)\n", sha1_to_hex(remote),
424 static pid_t setup_sideband(int fd[2], int xd[2])
433 /* xd[] is talking with upload-pack; subprocess reads from
434 * xd[0], spits out band#2 to stderr, and feeds us band#1
438 die("fetch-pack: unable to set up pipe");
441 die("fetch-pack: unable to fork off sideband demultiplexer");
447 if (recv_sideband("fetch-pack", xd[0], fd[1], 2))
457 static int get_pack(int xd[2], const char **argv)
463 side_pid = setup_sideband(fd, xd);
466 die("fetch-pack: unable to fork off %s", argv[0]);
472 die("%s exec failed", argv[0]);
476 while (waitpid(pid, &status, 0) < 0) {
478 die("waiting for %s: %s", argv[0], strerror(errno));
480 if (WIFEXITED(status)) {
481 int code = WEXITSTATUS(status);
483 die("%s died with error code %d", argv[0], code);
486 if (WIFSIGNALED(status)) {
487 int sig = WTERMSIG(status);
488 die("%s died of signal %d", argv[0], sig);
490 die("%s died of unnatural causes %d", argv[0], status);
493 static int explode_rx_pack(int xd[2])
495 const char *argv[3] = { "unpack-objects", quiet ? "-q" : NULL, NULL };
496 return get_pack(xd, argv);
499 static int keep_rx_pack(int xd[2])
505 argv[n++] = "index-pack";
506 argv[n++] = "--stdin";
510 argv[n++] = "--fix-thin";
512 int s = sprintf(keep_arg, "--keep=fetch-pack %i on ", getpid());
513 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
514 strcpy(keep_arg + s, "localhost");
515 argv[n++] = keep_arg;
518 return get_pack(xd, argv);
521 static int fetch_pack(int fd[2], int nr_match, char **match)
524 unsigned char sha1[20];
527 get_remote_heads(fd[0], &ref, 0, NULL, 0);
528 if (is_repository_shallow() && !server_supports("shallow"))
529 die("Server does not support shallow clients");
530 if (server_supports("multi_ack")) {
532 fprintf(stderr, "Server supports multi_ack\n");
535 if (server_supports("side-band-64k")) {
537 fprintf(stderr, "Server supports side-band-64k\n");
540 else if (server_supports("side-band")) {
542 fprintf(stderr, "Server supports side-band\n");
547 die("no matching remote head");
549 if (everything_local(&ref, nr_match, match)) {
553 if (find_common(fd, sha1, ref) < 0)
555 /* When cloning, it is not unusual to have
558 fprintf(stderr, "warning: no common commits\n");
560 status = (keep_pack) ? keep_rx_pack(fd) : explode_rx_pack(fd);
562 die("git-fetch-pack: fetch failed.");
567 sha1_to_hex(ref->old_sha1), ref->name);
573 int main(int argc, char **argv)
575 int i, ret, nr_heads;
576 char *dest = NULL, **heads;
580 setup_git_directory();
584 for (i = 1; i < argc; i++) {
588 if (!strncmp("--exec=", arg, 7)) {
592 if (!strcmp("--quiet", arg) || !strcmp("-q", arg)) {
596 if (!strcmp("--keep", arg) || !strcmp("-k", arg)) {
600 if (!strcmp("--thin", arg)) {
604 if (!strcmp("--all", arg)) {
608 if (!strcmp("-v", arg)) {
612 usage(fetch_pack_usage);
615 heads = argv + i + 1;
616 nr_heads = argc - i - 1;
620 usage(fetch_pack_usage);
621 pid = git_connect(fd, dest, exec);
624 ret = fetch_pack(fd, nr_heads, heads);
627 ret |= finish_connect(pid);
629 if (!ret && nr_heads) {
630 /* If the heads to pull were given, we should have
631 * consumed all of them by matching the remote.
632 * Otherwise, 'git-fetch remote no-such-ref' would
633 * silently succeed without issuing an error.
635 for (i = 0; i < nr_heads; i++)
636 if (heads[i] && heads[i][0]) {
637 error("no such remote ref %s", heads[i]);