Windows: boost startup by avoiding a static dependency on shell32.dll
[git/dscho.git] / builtin-fetch-pack.c
blob8ed4a6feaac2868523e6516e02865132dedbc9f5
1 #include "cache.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"
13 static int transfer_unpack_limit = -1;
14 static int fetch_unpack_limit = -1;
15 static int unpack_limit = 100;
16 static int prefer_ofs_delta = 1;
17 static struct fetch_pack_args args = {
18 /* .uploadpack = */ "git-upload-pack",
21 static const char fetch_pack_usage[] =
22 "git fetch-pack [--all] [--quiet|-q] [--keep|-k] [--thin] [--include-tag] [--upload-pack=<git-upload-pack>] [--depth=<n>] [--no-progress] [-v] [<host>:]<directory> [<refs>...]";
24 #define COMPLETE (1U << 0)
25 #define COMMON (1U << 1)
26 #define COMMON_REF (1U << 2)
27 #define SEEN (1U << 3)
28 #define POPPED (1U << 4)
30 static int marked;
33 * After sending this many "have"s if we do not get any new ACK , we
34 * give up traversing our history.
36 #define MAX_IN_VAIN 256
38 static struct commit_list *rev_list;
39 static int non_common_revs, multi_ack, use_sideband;
41 static void rev_list_push(struct commit *commit, int mark)
43 if (!(commit->object.flags & mark)) {
44 commit->object.flags |= mark;
46 if (!(commit->object.parsed))
47 if (parse_commit(commit))
48 return;
50 insert_by_date(commit, &rev_list);
52 if (!(commit->object.flags & COMMON))
53 non_common_revs++;
57 static int rev_list_insert_ref(const char *path, const unsigned char *sha1, int flag, void *cb_data)
59 struct object *o = deref_tag(parse_object(sha1), path, 0);
61 if (o && o->type == OBJ_COMMIT)
62 rev_list_push((struct commit *)o, SEEN);
64 return 0;
67 static int clear_marks(const char *path, const unsigned char *sha1, int flag, void *cb_data)
69 struct object *o = deref_tag(parse_object(sha1), path, 0);
71 if (o && o->type == OBJ_COMMIT)
72 clear_commit_marks((struct commit *)o,
73 COMMON | COMMON_REF | SEEN | POPPED);
74 return 0;
78 This function marks a rev and its ancestors as common.
79 In some cases, it is desirable to mark only the ancestors (for example
80 when only the server does not yet know that they are common).
83 static void mark_common(struct commit *commit,
84 int ancestors_only, int dont_parse)
86 if (commit != NULL && !(commit->object.flags & COMMON)) {
87 struct object *o = (struct object *)commit;
89 if (!ancestors_only)
90 o->flags |= COMMON;
92 if (!(o->flags & SEEN))
93 rev_list_push(commit, SEEN);
94 else {
95 struct commit_list *parents;
97 if (!ancestors_only && !(o->flags & POPPED))
98 non_common_revs--;
99 if (!o->parsed && !dont_parse)
100 if (parse_commit(commit))
101 return;
103 for (parents = commit->parents;
104 parents;
105 parents = parents->next)
106 mark_common(parents->item, 0, dont_parse);
112 Get the next rev to send, ignoring the common.
115 static const unsigned char *get_rev(void)
117 struct commit *commit = NULL;
119 while (commit == NULL) {
120 unsigned int mark;
121 struct commit_list *parents;
123 if (rev_list == NULL || non_common_revs == 0)
124 return NULL;
126 commit = rev_list->item;
127 if (!commit->object.parsed)
128 parse_commit(commit);
129 parents = commit->parents;
131 commit->object.flags |= POPPED;
132 if (!(commit->object.flags & COMMON))
133 non_common_revs--;
135 if (commit->object.flags & COMMON) {
136 /* do not send "have", and ignore ancestors */
137 commit = NULL;
138 mark = COMMON | SEEN;
139 } else if (commit->object.flags & COMMON_REF)
140 /* send "have", and ignore ancestors */
141 mark = COMMON | SEEN;
142 else
143 /* send "have", also for its ancestors */
144 mark = SEEN;
146 while (parents) {
147 if (!(parents->item->object.flags & SEEN))
148 rev_list_push(parents->item, mark);
149 if (mark & COMMON)
150 mark_common(parents->item, 1, 0);
151 parents = parents->next;
154 rev_list = rev_list->next;
157 return commit->object.sha1;
160 enum ack_type {
161 NAK = 0,
162 ACK,
163 ACK_continue,
164 ACK_common,
165 ACK_ready
168 static void consume_shallow_list(int fd)
170 if (args.stateless_rpc && args.depth > 0) {
171 /* If we sent a depth we will get back "duplicate"
172 * shallow and unshallow commands every time there
173 * is a block of have lines exchanged.
175 char line[1000];
176 while (packet_read_line(fd, line, sizeof(line))) {
177 if (!prefixcmp(line, "shallow "))
178 continue;
179 if (!prefixcmp(line, "unshallow "))
180 continue;
181 die("git fetch-pack: expected shallow list");
186 static enum ack_type get_ack(int fd, unsigned char *result_sha1)
188 static char line[1000];
189 int len = packet_read_line(fd, line, sizeof(line));
191 if (!len)
192 die("git fetch-pack: expected ACK/NAK, got EOF");
193 if (line[len-1] == '\n')
194 line[--len] = 0;
195 if (!strcmp(line, "NAK"))
196 return NAK;
197 if (!prefixcmp(line, "ACK ")) {
198 if (!get_sha1_hex(line+4, result_sha1)) {
199 if (strstr(line+45, "continue"))
200 return ACK_continue;
201 if (strstr(line+45, "common"))
202 return ACK_common;
203 if (strstr(line+45, "ready"))
204 return ACK_ready;
205 return ACK;
208 die("git fetch_pack: expected ACK/NAK, got '%s'", line);
211 static void send_request(int fd, struct strbuf *buf)
213 if (args.stateless_rpc) {
214 send_sideband(fd, -1, buf->buf, buf->len, LARGE_PACKET_MAX);
215 packet_flush(fd);
216 } else
217 safe_write(fd, buf->buf, buf->len);
220 static int find_common(int fd[2], unsigned char *result_sha1,
221 struct ref *refs)
223 int fetching;
224 int count = 0, flushes = 0, retval;
225 const unsigned char *sha1;
226 unsigned in_vain = 0;
227 int got_continue = 0;
228 struct strbuf req_buf = STRBUF_INIT;
229 size_t state_len = 0;
231 if (args.stateless_rpc && multi_ack == 1)
232 die("--stateless-rpc requires multi_ack_detailed");
233 if (marked)
234 for_each_ref(clear_marks, NULL);
235 marked = 1;
237 for_each_ref(rev_list_insert_ref, NULL);
239 fetching = 0;
240 for ( ; refs ; refs = refs->next) {
241 unsigned char *remote = refs->old_sha1;
242 const char *remote_hex;
243 struct object *o;
246 * If that object is complete (i.e. it is an ancestor of a
247 * local ref), we tell them we have it but do not have to
248 * tell them about its ancestors, which they already know
249 * about.
251 * We use lookup_object here because we are only
252 * interested in the case we *know* the object is
253 * reachable and we have already scanned it.
255 if (((o = lookup_object(remote)) != NULL) &&
256 (o->flags & COMPLETE)) {
257 continue;
260 remote_hex = sha1_to_hex(remote);
261 if (!fetching) {
262 struct strbuf c = STRBUF_INIT;
263 if (multi_ack == 2) strbuf_addstr(&c, " multi_ack_detailed");
264 if (multi_ack == 1) strbuf_addstr(&c, " multi_ack");
265 if (use_sideband == 2) strbuf_addstr(&c, " side-band-64k");
266 if (use_sideband == 1) strbuf_addstr(&c, " side-band");
267 if (args.use_thin_pack) strbuf_addstr(&c, " thin-pack");
268 if (args.no_progress) strbuf_addstr(&c, " no-progress");
269 if (args.include_tag) strbuf_addstr(&c, " include-tag");
270 if (prefer_ofs_delta) strbuf_addstr(&c, " ofs-delta");
271 packet_buf_write(&req_buf, "want %s%s\n", remote_hex, c.buf);
272 strbuf_release(&c);
273 } else
274 packet_buf_write(&req_buf, "want %s\n", remote_hex);
275 fetching++;
278 if (!fetching) {
279 strbuf_release(&req_buf);
280 packet_flush(fd[1]);
281 return 1;
284 if (is_repository_shallow())
285 write_shallow_commits(&req_buf, 1);
286 if (args.depth > 0)
287 packet_buf_write(&req_buf, "deepen %d", args.depth);
288 packet_buf_flush(&req_buf);
289 state_len = req_buf.len;
291 if (args.depth > 0) {
292 char line[1024];
293 unsigned char sha1[20];
295 send_request(fd[1], &req_buf);
296 while (packet_read_line(fd[0], line, sizeof(line))) {
297 if (!prefixcmp(line, "shallow ")) {
298 if (get_sha1_hex(line + 8, sha1))
299 die("invalid shallow line: %s", line);
300 register_shallow(sha1);
301 continue;
303 if (!prefixcmp(line, "unshallow ")) {
304 if (get_sha1_hex(line + 10, sha1))
305 die("invalid unshallow line: %s", line);
306 if (!lookup_object(sha1))
307 die("object not found: %s", line);
308 /* make sure that it is parsed as shallow */
309 if (!parse_object(sha1))
310 die("error in object: %s", line);
311 if (unregister_shallow(sha1))
312 die("no shallow found: %s", line);
313 continue;
315 die("expected shallow/unshallow, got %s", line);
317 } else if (!args.stateless_rpc)
318 send_request(fd[1], &req_buf);
320 if (!args.stateless_rpc) {
321 /* If we aren't using the stateless-rpc interface
322 * we don't need to retain the headers.
324 strbuf_setlen(&req_buf, 0);
325 state_len = 0;
328 flushes = 0;
329 retval = -1;
330 while ((sha1 = get_rev())) {
331 packet_buf_write(&req_buf, "have %s\n", sha1_to_hex(sha1));
332 if (args.verbose)
333 fprintf(stderr, "have %s\n", sha1_to_hex(sha1));
334 in_vain++;
335 if (!(31 & ++count)) {
336 int ack;
338 packet_buf_flush(&req_buf);
339 send_request(fd[1], &req_buf);
340 strbuf_setlen(&req_buf, state_len);
341 flushes++;
344 * We keep one window "ahead" of the other side, and
345 * will wait for an ACK only on the next one
347 if (!args.stateless_rpc && count == 32)
348 continue;
350 consume_shallow_list(fd[0]);
351 do {
352 ack = get_ack(fd[0], result_sha1);
353 if (args.verbose && ack)
354 fprintf(stderr, "got ack %d %s\n", ack,
355 sha1_to_hex(result_sha1));
356 switch (ack) {
357 case ACK:
358 flushes = 0;
359 multi_ack = 0;
360 retval = 0;
361 goto done;
362 case ACK_common:
363 case ACK_ready:
364 case ACK_continue: {
365 struct commit *commit =
366 lookup_commit(result_sha1);
367 if (args.stateless_rpc
368 && ack == ACK_common
369 && !(commit->object.flags & COMMON)) {
370 /* We need to replay the have for this object
371 * on the next RPC request so the peer knows
372 * it is in common with us.
374 const char *hex = sha1_to_hex(result_sha1);
375 packet_buf_write(&req_buf, "have %s\n", hex);
376 state_len = req_buf.len;
378 mark_common(commit, 0, 1);
379 retval = 0;
380 in_vain = 0;
381 got_continue = 1;
382 break;
385 } while (ack);
386 flushes--;
387 if (got_continue && MAX_IN_VAIN < in_vain) {
388 if (args.verbose)
389 fprintf(stderr, "giving up\n");
390 break; /* give up */
394 done:
395 packet_buf_write(&req_buf, "done\n");
396 send_request(fd[1], &req_buf);
397 if (args.verbose)
398 fprintf(stderr, "done\n");
399 if (retval != 0) {
400 multi_ack = 0;
401 flushes++;
403 strbuf_release(&req_buf);
405 consume_shallow_list(fd[0]);
406 while (flushes || multi_ack) {
407 int ack = get_ack(fd[0], result_sha1);
408 if (ack) {
409 if (args.verbose)
410 fprintf(stderr, "got ack (%d) %s\n", ack,
411 sha1_to_hex(result_sha1));
412 if (ack == ACK)
413 return 0;
414 multi_ack = 1;
415 continue;
417 flushes--;
419 /* it is no error to fetch into a completely empty repo */
420 return count ? retval : 0;
423 static struct commit_list *complete;
425 static int mark_complete(const char *path, const unsigned char *sha1, int flag, void *cb_data)
427 struct object *o = parse_object(sha1);
429 while (o && o->type == OBJ_TAG) {
430 struct tag *t = (struct tag *) o;
431 if (!t->tagged)
432 break; /* broken repository */
433 o->flags |= COMPLETE;
434 o = parse_object(t->tagged->sha1);
436 if (o && o->type == OBJ_COMMIT) {
437 struct commit *commit = (struct commit *)o;
438 commit->object.flags |= COMPLETE;
439 insert_by_date(commit, &complete);
441 return 0;
444 static void mark_recent_complete_commits(unsigned long cutoff)
446 while (complete && cutoff <= complete->item->date) {
447 if (args.verbose)
448 fprintf(stderr, "Marking %s as complete\n",
449 sha1_to_hex(complete->item->object.sha1));
450 pop_most_recent_commit(&complete, COMPLETE);
454 static void filter_refs(struct ref **refs, int nr_match, char **match)
456 struct ref **return_refs;
457 struct ref *newlist = NULL;
458 struct ref **newtail = &newlist;
459 struct ref *ref, *next;
460 struct ref *fastarray[32];
462 if (nr_match && !args.fetch_all) {
463 if (ARRAY_SIZE(fastarray) < nr_match)
464 return_refs = xcalloc(nr_match, sizeof(struct ref *));
465 else {
466 return_refs = fastarray;
467 memset(return_refs, 0, sizeof(struct ref *) * nr_match);
470 else
471 return_refs = NULL;
473 for (ref = *refs; ref; ref = next) {
474 next = ref->next;
475 if (!memcmp(ref->name, "refs/", 5) &&
476 check_ref_format(ref->name + 5))
477 ; /* trash */
478 else if (args.fetch_all &&
479 (!args.depth || prefixcmp(ref->name, "refs/tags/") )) {
480 *newtail = ref;
481 ref->next = NULL;
482 newtail = &ref->next;
483 continue;
485 else {
486 int order = path_match(ref->name, nr_match, match);
487 if (order) {
488 return_refs[order-1] = ref;
489 continue; /* we will link it later */
492 free(ref);
495 if (!args.fetch_all) {
496 int i;
497 for (i = 0; i < nr_match; i++) {
498 ref = return_refs[i];
499 if (ref) {
500 *newtail = ref;
501 ref->next = NULL;
502 newtail = &ref->next;
505 if (return_refs != fastarray)
506 free(return_refs);
508 *refs = newlist;
511 static int everything_local(struct ref **refs, int nr_match, char **match)
513 struct ref *ref;
514 int retval;
515 unsigned long cutoff = 0;
517 save_commit_buffer = 0;
519 for (ref = *refs; ref; ref = ref->next) {
520 struct object *o;
522 o = parse_object(ref->old_sha1);
523 if (!o)
524 continue;
526 /* We already have it -- which may mean that we were
527 * in sync with the other side at some time after
528 * that (it is OK if we guess wrong here).
530 if (o->type == OBJ_COMMIT) {
531 struct commit *commit = (struct commit *)o;
532 if (!cutoff || cutoff < commit->date)
533 cutoff = commit->date;
537 if (!args.depth) {
538 for_each_ref(mark_complete, NULL);
539 if (cutoff)
540 mark_recent_complete_commits(cutoff);
544 * Mark all complete remote refs as common refs.
545 * Don't mark them common yet; the server has to be told so first.
547 for (ref = *refs; ref; ref = ref->next) {
548 struct object *o = deref_tag(lookup_object(ref->old_sha1),
549 NULL, 0);
551 if (!o || o->type != OBJ_COMMIT || !(o->flags & COMPLETE))
552 continue;
554 if (!(o->flags & SEEN)) {
555 rev_list_push((struct commit *)o, COMMON_REF | SEEN);
557 mark_common((struct commit *)o, 1, 1);
561 filter_refs(refs, nr_match, match);
563 for (retval = 1, ref = *refs; ref ; ref = ref->next) {
564 const unsigned char *remote = ref->old_sha1;
565 unsigned char local[20];
566 struct object *o;
568 o = lookup_object(remote);
569 if (!o || !(o->flags & COMPLETE)) {
570 retval = 0;
571 if (!args.verbose)
572 continue;
573 fprintf(stderr,
574 "want %s (%s)\n", sha1_to_hex(remote),
575 ref->name);
576 continue;
579 hashcpy(ref->new_sha1, local);
580 if (!args.verbose)
581 continue;
582 fprintf(stderr,
583 "already have %s (%s)\n", sha1_to_hex(remote),
584 ref->name);
586 return retval;
589 static int sideband_demux(int fd, void *data)
591 int *xd = data;
593 int ret = recv_sideband("fetch-pack", xd[0], fd);
594 close(fd);
595 return ret;
598 static int get_pack(int xd[2], char **pack_lockfile)
600 struct async demux;
601 const char *argv[20];
602 char keep_arg[256];
603 char hdr_arg[256];
604 const char **av;
605 int do_keep = args.keep_pack;
606 struct child_process cmd;
608 memset(&demux, 0, sizeof(demux));
609 if (use_sideband) {
610 /* xd[] is talking with upload-pack; subprocess reads from
611 * xd[0], spits out band#2 to stderr, and feeds us band#1
612 * through demux->out.
614 demux.proc = sideband_demux;
615 demux.data = xd;
616 if (start_async(&demux))
617 die("fetch-pack: unable to fork off sideband"
618 " demultiplexer");
620 else
621 demux.out = xd[0];
623 memset(&cmd, 0, sizeof(cmd));
624 cmd.argv = argv;
625 av = argv;
626 *hdr_arg = 0;
627 if (!args.keep_pack && unpack_limit) {
628 struct pack_header header;
630 if (read_pack_header(demux.out, &header))
631 die("protocol error: bad pack header");
632 snprintf(hdr_arg, sizeof(hdr_arg),
633 "--pack_header=%"PRIu32",%"PRIu32,
634 ntohl(header.hdr_version), ntohl(header.hdr_entries));
635 if (ntohl(header.hdr_entries) < unpack_limit)
636 do_keep = 0;
637 else
638 do_keep = 1;
641 if (do_keep) {
642 if (pack_lockfile)
643 cmd.out = -1;
644 *av++ = "index-pack";
645 *av++ = "--stdin";
646 if (!args.quiet && !args.no_progress)
647 *av++ = "-v";
648 if (args.use_thin_pack)
649 *av++ = "--fix-thin";
650 if (args.lock_pack || unpack_limit) {
651 int s = sprintf(keep_arg,
652 "--keep=fetch-pack %"PRIuMAX " on ", (uintmax_t) getpid());
653 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
654 strcpy(keep_arg + s, "localhost");
655 *av++ = keep_arg;
658 else {
659 *av++ = "unpack-objects";
660 if (args.quiet)
661 *av++ = "-q";
663 if (*hdr_arg)
664 *av++ = hdr_arg;
665 *av++ = NULL;
667 cmd.in = demux.out;
668 cmd.git_cmd = 1;
669 if (start_command(&cmd))
670 die("fetch-pack: unable to fork off %s", argv[0]);
671 if (do_keep && pack_lockfile) {
672 *pack_lockfile = index_pack_lockfile(cmd.out);
673 close(cmd.out);
676 if (finish_command(&cmd))
677 die("%s failed", argv[0]);
678 if (use_sideband && finish_async(&demux))
679 die("error in sideband demultiplexer");
680 return 0;
683 static struct ref *do_fetch_pack(int fd[2],
684 const struct ref *orig_ref,
685 int nr_match,
686 char **match,
687 char **pack_lockfile)
689 struct ref *ref = copy_ref_list(orig_ref);
690 unsigned char sha1[20];
692 if (is_repository_shallow() && !server_supports("shallow"))
693 die("Server does not support shallow clients");
694 if (server_supports("multi_ack_detailed")) {
695 if (args.verbose)
696 fprintf(stderr, "Server supports multi_ack_detailed\n");
697 multi_ack = 2;
699 else if (server_supports("multi_ack")) {
700 if (args.verbose)
701 fprintf(stderr, "Server supports multi_ack\n");
702 multi_ack = 1;
704 if (server_supports("side-band-64k")) {
705 if (args.verbose)
706 fprintf(stderr, "Server supports side-band-64k\n");
707 use_sideband = 2;
709 else if (server_supports("side-band")) {
710 if (args.verbose)
711 fprintf(stderr, "Server supports side-band\n");
712 use_sideband = 1;
714 if (server_supports("ofs-delta")) {
715 if (args.verbose)
716 fprintf(stderr, "Server supports ofs-delta\n");
717 } else
718 prefer_ofs_delta = 0;
719 if (everything_local(&ref, nr_match, match)) {
720 packet_flush(fd[1]);
721 goto all_done;
723 if (find_common(fd, sha1, ref) < 0)
724 if (!args.keep_pack)
725 /* When cloning, it is not unusual to have
726 * no common commit.
728 warning("no common commits");
730 if (args.stateless_rpc)
731 packet_flush(fd[1]);
732 if (get_pack(fd, pack_lockfile))
733 die("git fetch-pack: fetch failed.");
735 all_done:
736 return ref;
739 static int remove_duplicates(int nr_heads, char **heads)
741 int src, dst;
743 for (src = dst = 0; src < nr_heads; src++) {
744 /* If heads[src] is different from any of
745 * heads[0..dst], push it in.
747 int i;
748 for (i = 0; i < dst; i++) {
749 if (!strcmp(heads[i], heads[src]))
750 break;
752 if (i < dst)
753 continue;
754 if (src != dst)
755 heads[dst] = heads[src];
756 dst++;
758 return dst;
761 static int fetch_pack_config(const char *var, const char *value, void *cb)
763 if (strcmp(var, "fetch.unpacklimit") == 0) {
764 fetch_unpack_limit = git_config_int(var, value);
765 return 0;
768 if (strcmp(var, "transfer.unpacklimit") == 0) {
769 transfer_unpack_limit = git_config_int(var, value);
770 return 0;
773 if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
774 prefer_ofs_delta = git_config_bool(var, value);
775 return 0;
778 return git_default_config(var, value, cb);
781 static struct lock_file lock;
783 static void fetch_pack_setup(void)
785 static int did_setup;
786 if (did_setup)
787 return;
788 git_config(fetch_pack_config, NULL);
789 if (0 <= transfer_unpack_limit)
790 unpack_limit = transfer_unpack_limit;
791 else if (0 <= fetch_unpack_limit)
792 unpack_limit = fetch_unpack_limit;
793 did_setup = 1;
796 int cmd_fetch_pack(int argc, const char **argv, const char *prefix)
798 int i, ret, nr_heads;
799 struct ref *ref = NULL;
800 char *dest = NULL, **heads;
801 int fd[2];
802 char *pack_lockfile = NULL;
803 char **pack_lockfile_ptr = NULL;
804 struct child_process *conn;
806 nr_heads = 0;
807 heads = NULL;
808 for (i = 1; i < argc; i++) {
809 const char *arg = argv[i];
811 if (*arg == '-') {
812 if (!prefixcmp(arg, "--upload-pack=")) {
813 args.uploadpack = arg + 14;
814 continue;
816 if (!prefixcmp(arg, "--exec=")) {
817 args.uploadpack = arg + 7;
818 continue;
820 if (!strcmp("--quiet", arg) || !strcmp("-q", arg)) {
821 args.quiet = 1;
822 continue;
824 if (!strcmp("--keep", arg) || !strcmp("-k", arg)) {
825 args.lock_pack = args.keep_pack;
826 args.keep_pack = 1;
827 continue;
829 if (!strcmp("--thin", arg)) {
830 args.use_thin_pack = 1;
831 continue;
833 if (!strcmp("--include-tag", arg)) {
834 args.include_tag = 1;
835 continue;
837 if (!strcmp("--all", arg)) {
838 args.fetch_all = 1;
839 continue;
841 if (!strcmp("-v", arg)) {
842 args.verbose = 1;
843 continue;
845 if (!prefixcmp(arg, "--depth=")) {
846 args.depth = strtol(arg + 8, NULL, 0);
847 continue;
849 if (!strcmp("--no-progress", arg)) {
850 args.no_progress = 1;
851 continue;
853 if (!strcmp("--stateless-rpc", arg)) {
854 args.stateless_rpc = 1;
855 continue;
857 if (!strcmp("--lock-pack", arg)) {
858 args.lock_pack = 1;
859 pack_lockfile_ptr = &pack_lockfile;
860 continue;
862 usage(fetch_pack_usage);
864 dest = (char *)arg;
865 heads = (char **)(argv + i + 1);
866 nr_heads = argc - i - 1;
867 break;
869 if (!dest)
870 usage(fetch_pack_usage);
872 if (args.stateless_rpc) {
873 conn = NULL;
874 fd[0] = 0;
875 fd[1] = 1;
876 } else {
877 conn = git_connect(fd, (char *)dest, args.uploadpack,
878 args.verbose ? CONNECT_VERBOSE : 0);
881 get_remote_heads(fd[0], &ref, 0, NULL, 0, NULL);
883 ref = fetch_pack(&args, fd, conn, ref, dest,
884 nr_heads, heads, pack_lockfile_ptr);
885 if (pack_lockfile) {
886 printf("lock %s\n", pack_lockfile);
887 fflush(stdout);
889 close(fd[0]);
890 close(fd[1]);
891 if (finish_connect(conn))
892 ref = NULL;
893 ret = !ref;
895 if (!ret && nr_heads) {
896 /* If the heads to pull were given, we should have
897 * consumed all of them by matching the remote.
898 * Otherwise, 'git fetch remote no-such-ref' would
899 * silently succeed without issuing an error.
901 for (i = 0; i < nr_heads; i++)
902 if (heads[i] && heads[i][0]) {
903 error("no such remote ref %s", heads[i]);
904 ret = 1;
907 while (ref) {
908 printf("%s %s\n",
909 sha1_to_hex(ref->old_sha1), ref->name);
910 ref = ref->next;
913 return ret;
916 struct ref *fetch_pack(struct fetch_pack_args *my_args,
917 int fd[], struct child_process *conn,
918 const struct ref *ref,
919 const char *dest,
920 int nr_heads,
921 char **heads,
922 char **pack_lockfile)
924 struct stat st;
925 struct ref *ref_cpy;
927 fetch_pack_setup();
928 if (&args != my_args)
929 memcpy(&args, my_args, sizeof(args));
930 if (args.depth > 0) {
931 if (stat(git_path("shallow"), &st))
932 st.st_mtime = 0;
935 if (heads && nr_heads)
936 nr_heads = remove_duplicates(nr_heads, heads);
937 if (!ref) {
938 packet_flush(fd[1]);
939 die("no matching remote head");
941 ref_cpy = do_fetch_pack(fd, ref, nr_heads, heads, pack_lockfile);
943 if (args.depth > 0) {
944 struct cache_time mtime;
945 struct strbuf sb = STRBUF_INIT;
946 char *shallow = git_path("shallow");
947 int fd;
949 mtime.sec = st.st_mtime;
950 mtime.nsec = ST_MTIME_NSEC(st);
951 if (stat(shallow, &st)) {
952 if (mtime.sec)
953 die("shallow file was removed during fetch");
954 } else if (st.st_mtime != mtime.sec
955 #ifdef USE_NSEC
956 || ST_MTIME_NSEC(st) != mtime.nsec
957 #endif
959 die("shallow file was changed during fetch");
961 fd = hold_lock_file_for_update(&lock, shallow,
962 LOCK_DIE_ON_ERROR);
963 if (!write_shallow_commits(&sb, 0)
964 || write_in_full(fd, sb.buf, sb.len) != sb.len) {
965 unlink_or_warn(shallow);
966 rollback_lock_file(&lock);
967 } else {
968 commit_lock_file(&lock);
970 strbuf_release(&sb);
973 reprepare_packed_git();
974 return ref_cpy;