Merge branch 'cj/p4merge'
[git.git] / builtin / fetch-pack.c
blob85aff029b225c023f09fda635f16cc00a22ed7ca
1 #include "builtin.h"
2 #include "refs.h"
3 #include "pkt-line.h"
4 #include "commit.h"
5 #include "tag.h"
6 #include "exec_cmd.h"
7 #include "pack.h"
8 #include "sideband.h"
9 #include "fetch-pack.h"
10 #include "remote.h"
11 #include "run-command.h"
12 #include "transport.h"
14 static int transfer_unpack_limit = -1;
15 static int fetch_unpack_limit = -1;
16 static int unpack_limit = 100;
17 static int prefer_ofs_delta = 1;
18 static int no_done = 0;
19 static struct fetch_pack_args args = {
20 /* .uploadpack = */ "git-upload-pack",
23 static const char fetch_pack_usage[] =
24 "git fetch-pack [--all] [--quiet|-q] [--keep|-k] [--thin] [--include-tag] [--upload-pack=<git-upload-pack>] [--depth=<n>] [--no-progress] [-v] [<host>:]<directory> [<refs>...]";
26 #define COMPLETE (1U << 0)
27 #define COMMON (1U << 1)
28 #define COMMON_REF (1U << 2)
29 #define SEEN (1U << 3)
30 #define POPPED (1U << 4)
32 static int marked;
35 * After sending this many "have"s if we do not get any new ACK , we
36 * give up traversing our history.
38 #define MAX_IN_VAIN 256
40 static struct commit_list *rev_list;
41 static int non_common_revs, multi_ack, use_sideband;
43 static void rev_list_push(struct commit *commit, int mark)
45 if (!(commit->object.flags & mark)) {
46 commit->object.flags |= mark;
48 if (!(commit->object.parsed))
49 if (parse_commit(commit))
50 return;
52 commit_list_insert_by_date(commit, &rev_list);
54 if (!(commit->object.flags & COMMON))
55 non_common_revs++;
59 static int rev_list_insert_ref(const char *path, const unsigned char *sha1, int flag, void *cb_data)
61 struct object *o = deref_tag(parse_object(sha1), path, 0);
63 if (o && o->type == OBJ_COMMIT)
64 rev_list_push((struct commit *)o, SEEN);
66 return 0;
69 static int clear_marks(const char *path, const unsigned char *sha1, int flag, void *cb_data)
71 struct object *o = deref_tag(parse_object(sha1), path, 0);
73 if (o && o->type == OBJ_COMMIT)
74 clear_commit_marks((struct commit *)o,
75 COMMON | COMMON_REF | SEEN | POPPED);
76 return 0;
80 This function marks a rev and its ancestors as common.
81 In some cases, it is desirable to mark only the ancestors (for example
82 when only the server does not yet know that they are common).
85 static void mark_common(struct commit *commit,
86 int ancestors_only, int dont_parse)
88 if (commit != NULL && !(commit->object.flags & COMMON)) {
89 struct object *o = (struct object *)commit;
91 if (!ancestors_only)
92 o->flags |= COMMON;
94 if (!(o->flags & SEEN))
95 rev_list_push(commit, SEEN);
96 else {
97 struct commit_list *parents;
99 if (!ancestors_only && !(o->flags & POPPED))
100 non_common_revs--;
101 if (!o->parsed && !dont_parse)
102 if (parse_commit(commit))
103 return;
105 for (parents = commit->parents;
106 parents;
107 parents = parents->next)
108 mark_common(parents->item, 0, dont_parse);
114 Get the next rev to send, ignoring the common.
117 static const unsigned char *get_rev(void)
119 struct commit *commit = NULL;
121 while (commit == NULL) {
122 unsigned int mark;
123 struct commit_list *parents;
125 if (rev_list == NULL || non_common_revs == 0)
126 return NULL;
128 commit = rev_list->item;
129 if (!commit->object.parsed)
130 parse_commit(commit);
131 parents = commit->parents;
133 commit->object.flags |= POPPED;
134 if (!(commit->object.flags & COMMON))
135 non_common_revs--;
137 if (commit->object.flags & COMMON) {
138 /* do not send "have", and ignore ancestors */
139 commit = NULL;
140 mark = COMMON | SEEN;
141 } else if (commit->object.flags & COMMON_REF)
142 /* send "have", and ignore ancestors */
143 mark = COMMON | SEEN;
144 else
145 /* send "have", also for its ancestors */
146 mark = SEEN;
148 while (parents) {
149 if (!(parents->item->object.flags & SEEN))
150 rev_list_push(parents->item, mark);
151 if (mark & COMMON)
152 mark_common(parents->item, 1, 0);
153 parents = parents->next;
156 rev_list = rev_list->next;
159 return commit->object.sha1;
162 enum ack_type {
163 NAK = 0,
164 ACK,
165 ACK_continue,
166 ACK_common,
167 ACK_ready
170 static void consume_shallow_list(int fd)
172 if (args.stateless_rpc && args.depth > 0) {
173 /* If we sent a depth we will get back "duplicate"
174 * shallow and unshallow commands every time there
175 * is a block of have lines exchanged.
177 char line[1000];
178 while (packet_read_line(fd, line, sizeof(line))) {
179 if (!prefixcmp(line, "shallow "))
180 continue;
181 if (!prefixcmp(line, "unshallow "))
182 continue;
183 die("git fetch-pack: expected shallow list");
188 static enum ack_type get_ack(int fd, unsigned char *result_sha1)
190 static char line[1000];
191 int len = packet_read_line(fd, line, sizeof(line));
193 if (!len)
194 die("git fetch-pack: expected ACK/NAK, got EOF");
195 if (line[len-1] == '\n')
196 line[--len] = 0;
197 if (!strcmp(line, "NAK"))
198 return NAK;
199 if (!prefixcmp(line, "ACK ")) {
200 if (!get_sha1_hex(line+4, result_sha1)) {
201 if (strstr(line+45, "continue"))
202 return ACK_continue;
203 if (strstr(line+45, "common"))
204 return ACK_common;
205 if (strstr(line+45, "ready"))
206 return ACK_ready;
207 return ACK;
210 die("git fetch_pack: expected ACK/NAK, got '%s'", line);
213 static void send_request(int fd, struct strbuf *buf)
215 if (args.stateless_rpc) {
216 send_sideband(fd, -1, buf->buf, buf->len, LARGE_PACKET_MAX);
217 packet_flush(fd);
218 } else
219 safe_write(fd, buf->buf, buf->len);
222 static void insert_one_alternate_ref(const struct ref *ref, void *unused)
224 rev_list_insert_ref(NULL, ref->old_sha1, 0, NULL);
227 static void insert_alternate_refs(void)
229 foreach_alt_odb(refs_from_alternate_cb, insert_one_alternate_ref);
232 #define INITIAL_FLUSH 16
233 #define PIPESAFE_FLUSH 32
234 #define LARGE_FLUSH 1024
236 static int next_flush(int count)
238 int flush_limit = args.stateless_rpc ? LARGE_FLUSH : PIPESAFE_FLUSH;
240 if (count < flush_limit)
241 count <<= 1;
242 else
243 count += flush_limit;
244 return count;
247 static int find_common(int fd[2], unsigned char *result_sha1,
248 struct ref *refs)
250 int fetching;
251 int count = 0, flushes = 0, flush_at = INITIAL_FLUSH, retval;
252 const unsigned char *sha1;
253 unsigned in_vain = 0;
254 int got_continue = 0;
255 int got_ready = 0;
256 struct strbuf req_buf = STRBUF_INIT;
257 size_t state_len = 0;
259 if (args.stateless_rpc && multi_ack == 1)
260 die("--stateless-rpc requires multi_ack_detailed");
261 if (marked)
262 for_each_ref(clear_marks, NULL);
263 marked = 1;
265 for_each_ref(rev_list_insert_ref, NULL);
266 insert_alternate_refs();
268 fetching = 0;
269 for ( ; refs ; refs = refs->next) {
270 unsigned char *remote = refs->old_sha1;
271 const char *remote_hex;
272 struct object *o;
275 * If that object is complete (i.e. it is an ancestor of a
276 * local ref), we tell them we have it but do not have to
277 * tell them about its ancestors, which they already know
278 * about.
280 * We use lookup_object here because we are only
281 * interested in the case we *know* the object is
282 * reachable and we have already scanned it.
284 if (((o = lookup_object(remote)) != NULL) &&
285 (o->flags & COMPLETE)) {
286 continue;
289 remote_hex = sha1_to_hex(remote);
290 if (!fetching) {
291 struct strbuf c = STRBUF_INIT;
292 if (multi_ack == 2) strbuf_addstr(&c, " multi_ack_detailed");
293 if (multi_ack == 1) strbuf_addstr(&c, " multi_ack");
294 if (no_done) strbuf_addstr(&c, " no-done");
295 if (use_sideband == 2) strbuf_addstr(&c, " side-band-64k");
296 if (use_sideband == 1) strbuf_addstr(&c, " side-band");
297 if (args.use_thin_pack) strbuf_addstr(&c, " thin-pack");
298 if (args.no_progress) strbuf_addstr(&c, " no-progress");
299 if (args.include_tag) strbuf_addstr(&c, " include-tag");
300 if (prefer_ofs_delta) strbuf_addstr(&c, " ofs-delta");
301 packet_buf_write(&req_buf, "want %s%s\n", remote_hex, c.buf);
302 strbuf_release(&c);
303 } else
304 packet_buf_write(&req_buf, "want %s\n", remote_hex);
305 fetching++;
308 if (!fetching) {
309 strbuf_release(&req_buf);
310 packet_flush(fd[1]);
311 return 1;
314 if (is_repository_shallow())
315 write_shallow_commits(&req_buf, 1);
316 if (args.depth > 0)
317 packet_buf_write(&req_buf, "deepen %d", args.depth);
318 packet_buf_flush(&req_buf);
319 state_len = req_buf.len;
321 if (args.depth > 0) {
322 char line[1024];
323 unsigned char sha1[20];
325 send_request(fd[1], &req_buf);
326 while (packet_read_line(fd[0], line, sizeof(line))) {
327 if (!prefixcmp(line, "shallow ")) {
328 if (get_sha1_hex(line + 8, sha1))
329 die("invalid shallow line: %s", line);
330 register_shallow(sha1);
331 continue;
333 if (!prefixcmp(line, "unshallow ")) {
334 if (get_sha1_hex(line + 10, sha1))
335 die("invalid unshallow line: %s", line);
336 if (!lookup_object(sha1))
337 die("object not found: %s", line);
338 /* make sure that it is parsed as shallow */
339 if (!parse_object(sha1))
340 die("error in object: %s", line);
341 if (unregister_shallow(sha1))
342 die("no shallow found: %s", line);
343 continue;
345 die("expected shallow/unshallow, got %s", line);
347 } else if (!args.stateless_rpc)
348 send_request(fd[1], &req_buf);
350 if (!args.stateless_rpc) {
351 /* If we aren't using the stateless-rpc interface
352 * we don't need to retain the headers.
354 strbuf_setlen(&req_buf, 0);
355 state_len = 0;
358 flushes = 0;
359 retval = -1;
360 while ((sha1 = get_rev())) {
361 packet_buf_write(&req_buf, "have %s\n", sha1_to_hex(sha1));
362 if (args.verbose)
363 fprintf(stderr, "have %s\n", sha1_to_hex(sha1));
364 in_vain++;
365 if (flush_at <= ++count) {
366 int ack;
368 packet_buf_flush(&req_buf);
369 send_request(fd[1], &req_buf);
370 strbuf_setlen(&req_buf, state_len);
371 flushes++;
372 flush_at = next_flush(count);
375 * We keep one window "ahead" of the other side, and
376 * will wait for an ACK only on the next one
378 if (!args.stateless_rpc && count == INITIAL_FLUSH)
379 continue;
381 consume_shallow_list(fd[0]);
382 do {
383 ack = get_ack(fd[0], result_sha1);
384 if (args.verbose && ack)
385 fprintf(stderr, "got ack %d %s\n", ack,
386 sha1_to_hex(result_sha1));
387 switch (ack) {
388 case ACK:
389 flushes = 0;
390 multi_ack = 0;
391 retval = 0;
392 goto done;
393 case ACK_common:
394 case ACK_ready:
395 case ACK_continue: {
396 struct commit *commit =
397 lookup_commit(result_sha1);
398 if (args.stateless_rpc
399 && ack == ACK_common
400 && !(commit->object.flags & COMMON)) {
401 /* We need to replay the have for this object
402 * on the next RPC request so the peer knows
403 * it is in common with us.
405 const char *hex = sha1_to_hex(result_sha1);
406 packet_buf_write(&req_buf, "have %s\n", hex);
407 state_len = req_buf.len;
409 mark_common(commit, 0, 1);
410 retval = 0;
411 in_vain = 0;
412 got_continue = 1;
413 if (ack == ACK_ready) {
414 rev_list = NULL;
415 got_ready = 1;
417 break;
420 } while (ack);
421 flushes--;
422 if (got_continue && MAX_IN_VAIN < in_vain) {
423 if (args.verbose)
424 fprintf(stderr, "giving up\n");
425 break; /* give up */
429 done:
430 if (!got_ready || !no_done) {
431 packet_buf_write(&req_buf, "done\n");
432 send_request(fd[1], &req_buf);
434 if (args.verbose)
435 fprintf(stderr, "done\n");
436 if (retval != 0) {
437 multi_ack = 0;
438 flushes++;
440 strbuf_release(&req_buf);
442 consume_shallow_list(fd[0]);
443 while (flushes || multi_ack) {
444 int ack = get_ack(fd[0], result_sha1);
445 if (ack) {
446 if (args.verbose)
447 fprintf(stderr, "got ack (%d) %s\n", ack,
448 sha1_to_hex(result_sha1));
449 if (ack == ACK)
450 return 0;
451 multi_ack = 1;
452 continue;
454 flushes--;
456 /* it is no error to fetch into a completely empty repo */
457 return count ? retval : 0;
460 static struct commit_list *complete;
462 static int mark_complete(const char *path, const unsigned char *sha1, int flag, void *cb_data)
464 struct object *o = parse_object(sha1);
466 while (o && o->type == OBJ_TAG) {
467 struct tag *t = (struct tag *) o;
468 if (!t->tagged)
469 break; /* broken repository */
470 o->flags |= COMPLETE;
471 o = parse_object(t->tagged->sha1);
473 if (o && o->type == OBJ_COMMIT) {
474 struct commit *commit = (struct commit *)o;
475 commit->object.flags |= COMPLETE;
476 commit_list_insert_by_date(commit, &complete);
478 return 0;
481 static void mark_recent_complete_commits(unsigned long cutoff)
483 while (complete && cutoff <= complete->item->date) {
484 if (args.verbose)
485 fprintf(stderr, "Marking %s as complete\n",
486 sha1_to_hex(complete->item->object.sha1));
487 pop_most_recent_commit(&complete, COMPLETE);
491 static void filter_refs(struct ref **refs, int nr_match, char **match)
493 struct ref **return_refs;
494 struct ref *newlist = NULL;
495 struct ref **newtail = &newlist;
496 struct ref *ref, *next;
497 struct ref *fastarray[32];
499 if (nr_match && !args.fetch_all) {
500 if (ARRAY_SIZE(fastarray) < nr_match)
501 return_refs = xcalloc(nr_match, sizeof(struct ref *));
502 else {
503 return_refs = fastarray;
504 memset(return_refs, 0, sizeof(struct ref *) * nr_match);
507 else
508 return_refs = NULL;
510 for (ref = *refs; ref; ref = next) {
511 next = ref->next;
512 if (!memcmp(ref->name, "refs/", 5) &&
513 check_ref_format(ref->name + 5))
514 ; /* trash */
515 else if (args.fetch_all &&
516 (!args.depth || prefixcmp(ref->name, "refs/tags/") )) {
517 *newtail = ref;
518 ref->next = NULL;
519 newtail = &ref->next;
520 continue;
522 else {
523 int order = path_match(ref->name, nr_match, match);
524 if (order) {
525 return_refs[order-1] = ref;
526 continue; /* we will link it later */
529 free(ref);
532 if (!args.fetch_all) {
533 int i;
534 for (i = 0; i < nr_match; i++) {
535 ref = return_refs[i];
536 if (ref) {
537 *newtail = ref;
538 ref->next = NULL;
539 newtail = &ref->next;
542 if (return_refs != fastarray)
543 free(return_refs);
545 *refs = newlist;
548 static int everything_local(struct ref **refs, int nr_match, char **match)
550 struct ref *ref;
551 int retval;
552 unsigned long cutoff = 0;
554 save_commit_buffer = 0;
556 for (ref = *refs; ref; ref = ref->next) {
557 struct object *o;
559 o = parse_object(ref->old_sha1);
560 if (!o)
561 continue;
563 /* We already have it -- which may mean that we were
564 * in sync with the other side at some time after
565 * that (it is OK if we guess wrong here).
567 if (o->type == OBJ_COMMIT) {
568 struct commit *commit = (struct commit *)o;
569 if (!cutoff || cutoff < commit->date)
570 cutoff = commit->date;
574 if (!args.depth) {
575 for_each_ref(mark_complete, NULL);
576 if (cutoff)
577 mark_recent_complete_commits(cutoff);
581 * Mark all complete remote refs as common refs.
582 * Don't mark them common yet; the server has to be told so first.
584 for (ref = *refs; ref; ref = ref->next) {
585 struct object *o = deref_tag(lookup_object(ref->old_sha1),
586 NULL, 0);
588 if (!o || o->type != OBJ_COMMIT || !(o->flags & COMPLETE))
589 continue;
591 if (!(o->flags & SEEN)) {
592 rev_list_push((struct commit *)o, COMMON_REF | SEEN);
594 mark_common((struct commit *)o, 1, 1);
598 filter_refs(refs, nr_match, match);
600 for (retval = 1, ref = *refs; ref ; ref = ref->next) {
601 const unsigned char *remote = ref->old_sha1;
602 unsigned char local[20];
603 struct object *o;
605 o = lookup_object(remote);
606 if (!o || !(o->flags & COMPLETE)) {
607 retval = 0;
608 if (!args.verbose)
609 continue;
610 fprintf(stderr,
611 "want %s (%s)\n", sha1_to_hex(remote),
612 ref->name);
613 continue;
616 hashcpy(ref->new_sha1, local);
617 if (!args.verbose)
618 continue;
619 fprintf(stderr,
620 "already have %s (%s)\n", sha1_to_hex(remote),
621 ref->name);
623 return retval;
626 static int sideband_demux(int in, int out, void *data)
628 int *xd = data;
630 int ret = recv_sideband("fetch-pack", xd[0], out);
631 close(out);
632 return ret;
635 static int get_pack(int xd[2], char **pack_lockfile)
637 struct async demux;
638 const char *argv[20];
639 char keep_arg[256];
640 char hdr_arg[256];
641 const char **av;
642 int do_keep = args.keep_pack;
643 struct child_process cmd;
645 memset(&demux, 0, sizeof(demux));
646 if (use_sideband) {
647 /* xd[] is talking with upload-pack; subprocess reads from
648 * xd[0], spits out band#2 to stderr, and feeds us band#1
649 * through demux->out.
651 demux.proc = sideband_demux;
652 demux.data = xd;
653 demux.out = -1;
654 if (start_async(&demux))
655 die("fetch-pack: unable to fork off sideband"
656 " demultiplexer");
658 else
659 demux.out = xd[0];
661 memset(&cmd, 0, sizeof(cmd));
662 cmd.argv = argv;
663 av = argv;
664 *hdr_arg = 0;
665 if (!args.keep_pack && unpack_limit) {
666 struct pack_header header;
668 if (read_pack_header(demux.out, &header))
669 die("protocol error: bad pack header");
670 snprintf(hdr_arg, sizeof(hdr_arg),
671 "--pack_header=%"PRIu32",%"PRIu32,
672 ntohl(header.hdr_version), ntohl(header.hdr_entries));
673 if (ntohl(header.hdr_entries) < unpack_limit)
674 do_keep = 0;
675 else
676 do_keep = 1;
679 if (do_keep) {
680 if (pack_lockfile)
681 cmd.out = -1;
682 *av++ = "index-pack";
683 *av++ = "--stdin";
684 if (!args.quiet && !args.no_progress)
685 *av++ = "-v";
686 if (args.use_thin_pack)
687 *av++ = "--fix-thin";
688 if (args.lock_pack || unpack_limit) {
689 int s = sprintf(keep_arg,
690 "--keep=fetch-pack %"PRIuMAX " on ", (uintmax_t) getpid());
691 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
692 strcpy(keep_arg + s, "localhost");
693 *av++ = keep_arg;
696 else {
697 *av++ = "unpack-objects";
698 if (args.quiet)
699 *av++ = "-q";
701 if (*hdr_arg)
702 *av++ = hdr_arg;
703 *av++ = NULL;
705 cmd.in = demux.out;
706 cmd.git_cmd = 1;
707 if (start_command(&cmd))
708 die("fetch-pack: unable to fork off %s", argv[0]);
709 if (do_keep && pack_lockfile) {
710 *pack_lockfile = index_pack_lockfile(cmd.out);
711 close(cmd.out);
714 if (finish_command(&cmd))
715 die("%s failed", argv[0]);
716 if (use_sideband && finish_async(&demux))
717 die("error in sideband demultiplexer");
718 return 0;
721 static struct ref *do_fetch_pack(int fd[2],
722 const struct ref *orig_ref,
723 int nr_match,
724 char **match,
725 char **pack_lockfile)
727 struct ref *ref = copy_ref_list(orig_ref);
728 unsigned char sha1[20];
730 if (is_repository_shallow() && !server_supports("shallow"))
731 die("Server does not support shallow clients");
732 if (server_supports("multi_ack_detailed")) {
733 if (args.verbose)
734 fprintf(stderr, "Server supports multi_ack_detailed\n");
735 multi_ack = 2;
736 if (server_supports("no-done")) {
737 if (args.verbose)
738 fprintf(stderr, "Server supports no-done\n");
739 if (args.stateless_rpc)
740 no_done = 1;
743 else if (server_supports("multi_ack")) {
744 if (args.verbose)
745 fprintf(stderr, "Server supports multi_ack\n");
746 multi_ack = 1;
748 if (server_supports("side-band-64k")) {
749 if (args.verbose)
750 fprintf(stderr, "Server supports side-band-64k\n");
751 use_sideband = 2;
753 else if (server_supports("side-band")) {
754 if (args.verbose)
755 fprintf(stderr, "Server supports side-band\n");
756 use_sideband = 1;
758 if (server_supports("ofs-delta")) {
759 if (args.verbose)
760 fprintf(stderr, "Server supports ofs-delta\n");
761 } else
762 prefer_ofs_delta = 0;
763 if (everything_local(&ref, nr_match, match)) {
764 packet_flush(fd[1]);
765 goto all_done;
767 if (find_common(fd, sha1, ref) < 0)
768 if (!args.keep_pack)
769 /* When cloning, it is not unusual to have
770 * no common commit.
772 warning("no common commits");
774 if (args.stateless_rpc)
775 packet_flush(fd[1]);
776 if (get_pack(fd, pack_lockfile))
777 die("git fetch-pack: fetch failed.");
779 all_done:
780 return ref;
783 static int remove_duplicates(int nr_heads, char **heads)
785 int src, dst;
787 for (src = dst = 0; src < nr_heads; src++) {
788 /* If heads[src] is different from any of
789 * heads[0..dst], push it in.
791 int i;
792 for (i = 0; i < dst; i++) {
793 if (!strcmp(heads[i], heads[src]))
794 break;
796 if (i < dst)
797 continue;
798 if (src != dst)
799 heads[dst] = heads[src];
800 dst++;
802 return dst;
805 static int fetch_pack_config(const char *var, const char *value, void *cb)
807 if (strcmp(var, "fetch.unpacklimit") == 0) {
808 fetch_unpack_limit = git_config_int(var, value);
809 return 0;
812 if (strcmp(var, "transfer.unpacklimit") == 0) {
813 transfer_unpack_limit = git_config_int(var, value);
814 return 0;
817 if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
818 prefer_ofs_delta = git_config_bool(var, value);
819 return 0;
822 return git_default_config(var, value, cb);
825 static struct lock_file lock;
827 static void fetch_pack_setup(void)
829 static int did_setup;
830 if (did_setup)
831 return;
832 git_config(fetch_pack_config, NULL);
833 if (0 <= transfer_unpack_limit)
834 unpack_limit = transfer_unpack_limit;
835 else if (0 <= fetch_unpack_limit)
836 unpack_limit = fetch_unpack_limit;
837 did_setup = 1;
840 int cmd_fetch_pack(int argc, const char **argv, const char *prefix)
842 int i, ret, nr_heads;
843 struct ref *ref = NULL;
844 char *dest = NULL, **heads;
845 int fd[2];
846 char *pack_lockfile = NULL;
847 char **pack_lockfile_ptr = NULL;
848 struct child_process *conn;
850 packet_trace_identity("fetch-pack");
852 nr_heads = 0;
853 heads = NULL;
854 for (i = 1; i < argc; i++) {
855 const char *arg = argv[i];
857 if (*arg == '-') {
858 if (!prefixcmp(arg, "--upload-pack=")) {
859 args.uploadpack = arg + 14;
860 continue;
862 if (!prefixcmp(arg, "--exec=")) {
863 args.uploadpack = arg + 7;
864 continue;
866 if (!strcmp("--quiet", arg) || !strcmp("-q", arg)) {
867 args.quiet = 1;
868 continue;
870 if (!strcmp("--keep", arg) || !strcmp("-k", arg)) {
871 args.lock_pack = args.keep_pack;
872 args.keep_pack = 1;
873 continue;
875 if (!strcmp("--thin", arg)) {
876 args.use_thin_pack = 1;
877 continue;
879 if (!strcmp("--include-tag", arg)) {
880 args.include_tag = 1;
881 continue;
883 if (!strcmp("--all", arg)) {
884 args.fetch_all = 1;
885 continue;
887 if (!strcmp("-v", arg)) {
888 args.verbose = 1;
889 continue;
891 if (!prefixcmp(arg, "--depth=")) {
892 args.depth = strtol(arg + 8, NULL, 0);
893 continue;
895 if (!strcmp("--no-progress", arg)) {
896 args.no_progress = 1;
897 continue;
899 if (!strcmp("--stateless-rpc", arg)) {
900 args.stateless_rpc = 1;
901 continue;
903 if (!strcmp("--lock-pack", arg)) {
904 args.lock_pack = 1;
905 pack_lockfile_ptr = &pack_lockfile;
906 continue;
908 usage(fetch_pack_usage);
910 dest = (char *)arg;
911 heads = (char **)(argv + i + 1);
912 nr_heads = argc - i - 1;
913 break;
915 if (!dest)
916 usage(fetch_pack_usage);
918 if (args.stateless_rpc) {
919 conn = NULL;
920 fd[0] = 0;
921 fd[1] = 1;
922 } else {
923 conn = git_connect(fd, (char *)dest, args.uploadpack,
924 args.verbose ? CONNECT_VERBOSE : 0);
927 get_remote_heads(fd[0], &ref, 0, NULL, 0, NULL);
929 ref = fetch_pack(&args, fd, conn, ref, dest,
930 nr_heads, heads, pack_lockfile_ptr);
931 if (pack_lockfile) {
932 printf("lock %s\n", pack_lockfile);
933 fflush(stdout);
935 close(fd[0]);
936 close(fd[1]);
937 if (finish_connect(conn))
938 ref = NULL;
939 ret = !ref;
941 if (!ret && nr_heads) {
942 /* If the heads to pull were given, we should have
943 * consumed all of them by matching the remote.
944 * Otherwise, 'git fetch remote no-such-ref' would
945 * silently succeed without issuing an error.
947 for (i = 0; i < nr_heads; i++)
948 if (heads[i] && heads[i][0]) {
949 error("no such remote ref %s", heads[i]);
950 ret = 1;
953 while (ref) {
954 printf("%s %s\n",
955 sha1_to_hex(ref->old_sha1), ref->name);
956 ref = ref->next;
959 return ret;
962 struct ref *fetch_pack(struct fetch_pack_args *my_args,
963 int fd[], struct child_process *conn,
964 const struct ref *ref,
965 const char *dest,
966 int nr_heads,
967 char **heads,
968 char **pack_lockfile)
970 struct stat st;
971 struct ref *ref_cpy;
973 fetch_pack_setup();
974 if (&args != my_args)
975 memcpy(&args, my_args, sizeof(args));
976 if (args.depth > 0) {
977 if (stat(git_path("shallow"), &st))
978 st.st_mtime = 0;
981 if (heads && nr_heads)
982 nr_heads = remove_duplicates(nr_heads, heads);
983 if (!ref) {
984 packet_flush(fd[1]);
985 die("no matching remote head");
987 ref_cpy = do_fetch_pack(fd, ref, nr_heads, heads, pack_lockfile);
989 if (args.depth > 0) {
990 struct cache_time mtime;
991 struct strbuf sb = STRBUF_INIT;
992 char *shallow = git_path("shallow");
993 int fd;
995 mtime.sec = st.st_mtime;
996 mtime.nsec = ST_MTIME_NSEC(st);
997 if (stat(shallow, &st)) {
998 if (mtime.sec)
999 die("shallow file was removed during fetch");
1000 } else if (st.st_mtime != mtime.sec
1001 #ifdef USE_NSEC
1002 || ST_MTIME_NSEC(st) != mtime.nsec
1003 #endif
1005 die("shallow file was changed during fetch");
1007 fd = hold_lock_file_for_update(&lock, shallow,
1008 LOCK_DIE_ON_ERROR);
1009 if (!write_shallow_commits(&sb, 0)
1010 || write_in_full(fd, sb.buf, sb.len) != sb.len) {
1011 unlink_or_warn(shallow);
1012 rollback_lock_file(&lock);
1013 } else {
1014 commit_lock_file(&lock);
1016 strbuf_release(&sb);
1019 reprepare_packed_git();
1020 return ref_cpy;