repack: introduce repack.writeBitmaps config option
[git.git] / fetch-pack.c
bloba0e0350ae6bdf338b3c11c21fc050edb60c88569
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"
12 #include "connect.h"
13 #include "transport.h"
14 #include "version.h"
15 #include "prio-queue.h"
17 static int transfer_unpack_limit = -1;
18 static int fetch_unpack_limit = -1;
19 static int unpack_limit = 100;
20 static int prefer_ofs_delta = 1;
21 static int no_done;
22 static int fetch_fsck_objects = -1;
23 static int transfer_fsck_objects = -1;
24 static int agent_supported;
25 static struct lock_file shallow_lock;
26 static const char *alternate_shallow_file;
28 #define COMPLETE (1U << 0)
29 #define COMMON (1U << 1)
30 #define COMMON_REF (1U << 2)
31 #define SEEN (1U << 3)
32 #define POPPED (1U << 4)
34 static int marked;
37 * After sending this many "have"s if we do not get any new ACK , we
38 * give up traversing our history.
40 #define MAX_IN_VAIN 256
42 static struct prio_queue rev_list = { compare_commits_by_commit_date };
43 static int non_common_revs, multi_ack, use_sideband, allow_tip_sha1_in_want;
45 static void rev_list_push(struct commit *commit, int mark)
47 if (!(commit->object.flags & mark)) {
48 commit->object.flags |= mark;
50 if (!(commit->object.parsed))
51 if (parse_commit(commit))
52 return;
54 prio_queue_put(&rev_list, commit);
56 if (!(commit->object.flags & COMMON))
57 non_common_revs++;
61 static int rev_list_insert_ref(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
63 struct object *o = deref_tag(parse_object(sha1), refname, 0);
65 if (o && o->type == OBJ_COMMIT)
66 rev_list_push((struct commit *)o, SEEN);
68 return 0;
71 static int clear_marks(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
73 struct object *o = deref_tag(parse_object(sha1), refname, 0);
75 if (o && o->type == OBJ_COMMIT)
76 clear_commit_marks((struct commit *)o,
77 COMMON | COMMON_REF | SEEN | POPPED);
78 return 0;
82 This function marks a rev and its ancestors as common.
83 In some cases, it is desirable to mark only the ancestors (for example
84 when only the server does not yet know that they are common).
87 static void mark_common(struct commit *commit,
88 int ancestors_only, int dont_parse)
90 if (commit != NULL && !(commit->object.flags & COMMON)) {
91 struct object *o = (struct object *)commit;
93 if (!ancestors_only)
94 o->flags |= COMMON;
96 if (!(o->flags & SEEN))
97 rev_list_push(commit, SEEN);
98 else {
99 struct commit_list *parents;
101 if (!ancestors_only && !(o->flags & POPPED))
102 non_common_revs--;
103 if (!o->parsed && !dont_parse)
104 if (parse_commit(commit))
105 return;
107 for (parents = commit->parents;
108 parents;
109 parents = parents->next)
110 mark_common(parents->item, 0, dont_parse);
116 Get the next rev to send, ignoring the common.
119 static const unsigned char *get_rev(void)
121 struct commit *commit = NULL;
123 while (commit == NULL) {
124 unsigned int mark;
125 struct commit_list *parents;
127 if (rev_list.nr == 0 || non_common_revs == 0)
128 return NULL;
130 commit = prio_queue_get(&rev_list);
131 if (!commit->object.parsed)
132 parse_commit(commit);
133 parents = commit->parents;
135 commit->object.flags |= POPPED;
136 if (!(commit->object.flags & COMMON))
137 non_common_revs--;
139 if (commit->object.flags & COMMON) {
140 /* do not send "have", and ignore ancestors */
141 commit = NULL;
142 mark = COMMON | SEEN;
143 } else if (commit->object.flags & COMMON_REF)
144 /* send "have", and ignore ancestors */
145 mark = COMMON | SEEN;
146 else
147 /* send "have", also for its ancestors */
148 mark = SEEN;
150 while (parents) {
151 if (!(parents->item->object.flags & SEEN))
152 rev_list_push(parents->item, mark);
153 if (mark & COMMON)
154 mark_common(parents->item, 1, 0);
155 parents = parents->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(struct fetch_pack_args *args, 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;
178 while ((line = packet_read_line(fd, NULL))) {
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 int len;
191 char *line = packet_read_line(fd, &len);
193 if (!len)
194 die("git fetch-pack: expected ACK/NAK, got EOF");
195 if (!strcmp(line, "NAK"))
196 return NAK;
197 if (!prefixcmp(line, "ACK ")) {
198 if (!get_sha1_hex(line+4, result_sha1)) {
199 if (len < 45)
200 return ACK;
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(struct fetch_pack_args *args,
214 int fd, struct strbuf *buf)
216 if (args->stateless_rpc) {
217 send_sideband(fd, -1, buf->buf, buf->len, LARGE_PACKET_MAX);
218 packet_flush(fd);
219 } else
220 write_or_die(fd, buf->buf, buf->len);
223 static void insert_one_alternate_ref(const struct ref *ref, void *unused)
225 rev_list_insert_ref(NULL, ref->old_sha1, 0, NULL);
228 #define INITIAL_FLUSH 16
229 #define PIPESAFE_FLUSH 32
230 #define LARGE_FLUSH 1024
232 static int next_flush(struct fetch_pack_args *args, int count)
234 int flush_limit = args->stateless_rpc ? LARGE_FLUSH : PIPESAFE_FLUSH;
236 if (count < flush_limit)
237 count <<= 1;
238 else
239 count += flush_limit;
240 return count;
243 static int find_common(struct fetch_pack_args *args,
244 int fd[2], unsigned char *result_sha1,
245 struct ref *refs)
247 int fetching;
248 int count = 0, flushes = 0, flush_at = INITIAL_FLUSH, retval;
249 const unsigned char *sha1;
250 unsigned in_vain = 0;
251 int got_continue = 0;
252 int got_ready = 0;
253 struct strbuf req_buf = STRBUF_INIT;
254 size_t state_len = 0;
256 if (args->stateless_rpc && multi_ack == 1)
257 die("--stateless-rpc requires multi_ack_detailed");
258 if (marked)
259 for_each_ref(clear_marks, NULL);
260 marked = 1;
262 for_each_ref(rev_list_insert_ref, NULL);
263 for_each_alternate_ref(insert_one_alternate_ref, NULL);
265 fetching = 0;
266 for ( ; refs ; refs = refs->next) {
267 unsigned char *remote = refs->old_sha1;
268 const char *remote_hex;
269 struct object *o;
272 * If that object is complete (i.e. it is an ancestor of a
273 * local ref), we tell them we have it but do not have to
274 * tell them about its ancestors, which they already know
275 * about.
277 * We use lookup_object here because we are only
278 * interested in the case we *know* the object is
279 * reachable and we have already scanned it.
281 if (((o = lookup_object(remote)) != NULL) &&
282 (o->flags & COMPLETE)) {
283 continue;
286 remote_hex = sha1_to_hex(remote);
287 if (!fetching) {
288 struct strbuf c = STRBUF_INIT;
289 if (multi_ack == 2) strbuf_addstr(&c, " multi_ack_detailed");
290 if (multi_ack == 1) strbuf_addstr(&c, " multi_ack");
291 if (no_done) strbuf_addstr(&c, " no-done");
292 if (use_sideband == 2) strbuf_addstr(&c, " side-band-64k");
293 if (use_sideband == 1) strbuf_addstr(&c, " side-band");
294 if (args->use_thin_pack) strbuf_addstr(&c, " thin-pack");
295 if (args->no_progress) strbuf_addstr(&c, " no-progress");
296 if (args->include_tag) strbuf_addstr(&c, " include-tag");
297 if (prefer_ofs_delta) strbuf_addstr(&c, " ofs-delta");
298 if (agent_supported) strbuf_addf(&c, " agent=%s",
299 git_user_agent_sanitized());
300 packet_buf_write(&req_buf, "want %s%s\n", remote_hex, c.buf);
301 strbuf_release(&c);
302 } else
303 packet_buf_write(&req_buf, "want %s\n", remote_hex);
304 fetching++;
307 if (!fetching) {
308 strbuf_release(&req_buf);
309 packet_flush(fd[1]);
310 return 1;
313 if (is_repository_shallow())
314 write_shallow_commits(&req_buf, 1);
315 if (args->depth > 0)
316 packet_buf_write(&req_buf, "deepen %d", args->depth);
317 packet_buf_flush(&req_buf);
318 state_len = req_buf.len;
320 if (args->depth > 0) {
321 char *line;
322 unsigned char sha1[20];
324 send_request(args, fd[1], &req_buf);
325 while ((line = packet_read_line(fd[0], NULL))) {
326 if (!prefixcmp(line, "shallow ")) {
327 if (get_sha1_hex(line + 8, sha1))
328 die("invalid shallow line: %s", line);
329 register_shallow(sha1);
330 continue;
332 if (!prefixcmp(line, "unshallow ")) {
333 if (get_sha1_hex(line + 10, sha1))
334 die("invalid unshallow line: %s", line);
335 if (!lookup_object(sha1))
336 die("object not found: %s", line);
337 /* make sure that it is parsed as shallow */
338 if (!parse_object(sha1))
339 die("error in object: %s", line);
340 if (unregister_shallow(sha1))
341 die("no shallow found: %s", line);
342 continue;
344 die("expected shallow/unshallow, got %s", line);
346 } else if (!args->stateless_rpc)
347 send_request(args, fd[1], &req_buf);
349 if (!args->stateless_rpc) {
350 /* If we aren't using the stateless-rpc interface
351 * we don't need to retain the headers.
353 strbuf_setlen(&req_buf, 0);
354 state_len = 0;
357 flushes = 0;
358 retval = -1;
359 while ((sha1 = get_rev())) {
360 packet_buf_write(&req_buf, "have %s\n", sha1_to_hex(sha1));
361 if (args->verbose)
362 fprintf(stderr, "have %s\n", sha1_to_hex(sha1));
363 in_vain++;
364 if (flush_at <= ++count) {
365 int ack;
367 packet_buf_flush(&req_buf);
368 send_request(args, fd[1], &req_buf);
369 strbuf_setlen(&req_buf, state_len);
370 flushes++;
371 flush_at = next_flush(args, count);
374 * We keep one window "ahead" of the other side, and
375 * will wait for an ACK only on the next one
377 if (!args->stateless_rpc && count == INITIAL_FLUSH)
378 continue;
380 consume_shallow_list(args, fd[0]);
381 do {
382 ack = get_ack(fd[0], result_sha1);
383 if (args->verbose && ack)
384 fprintf(stderr, "got ack %d %s\n", ack,
385 sha1_to_hex(result_sha1));
386 switch (ack) {
387 case ACK:
388 flushes = 0;
389 multi_ack = 0;
390 retval = 0;
391 goto done;
392 case ACK_common:
393 case ACK_ready:
394 case ACK_continue: {
395 struct commit *commit =
396 lookup_commit(result_sha1);
397 if (!commit)
398 die("invalid commit %s", sha1_to_hex(result_sha1));
399 if (args->stateless_rpc
400 && ack == ACK_common
401 && !(commit->object.flags & COMMON)) {
402 /* We need to replay the have for this object
403 * on the next RPC request so the peer knows
404 * it is in common with us.
406 const char *hex = sha1_to_hex(result_sha1);
407 packet_buf_write(&req_buf, "have %s\n", hex);
408 state_len = req_buf.len;
410 mark_common(commit, 0, 1);
411 retval = 0;
412 in_vain = 0;
413 got_continue = 1;
414 if (ack == ACK_ready) {
415 clear_prio_queue(&rev_list);
416 got_ready = 1;
418 break;
421 } while (ack);
422 flushes--;
423 if (got_continue && MAX_IN_VAIN < in_vain) {
424 if (args->verbose)
425 fprintf(stderr, "giving up\n");
426 break; /* give up */
430 done:
431 if (!got_ready || !no_done) {
432 packet_buf_write(&req_buf, "done\n");
433 send_request(args, fd[1], &req_buf);
435 if (args->verbose)
436 fprintf(stderr, "done\n");
437 if (retval != 0) {
438 multi_ack = 0;
439 flushes++;
441 strbuf_release(&req_buf);
443 consume_shallow_list(args, fd[0]);
444 while (flushes || multi_ack) {
445 int ack = get_ack(fd[0], result_sha1);
446 if (ack) {
447 if (args->verbose)
448 fprintf(stderr, "got ack (%d) %s\n", ack,
449 sha1_to_hex(result_sha1));
450 if (ack == ACK)
451 return 0;
452 multi_ack = 1;
453 continue;
455 flushes--;
457 /* it is no error to fetch into a completely empty repo */
458 return count ? retval : 0;
461 static struct commit_list *complete;
463 static int mark_complete(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
465 struct object *o = parse_object(sha1);
467 while (o && o->type == OBJ_TAG) {
468 struct tag *t = (struct tag *) o;
469 if (!t->tagged)
470 break; /* broken repository */
471 o->flags |= COMPLETE;
472 o = parse_object(t->tagged->sha1);
474 if (o && o->type == OBJ_COMMIT) {
475 struct commit *commit = (struct commit *)o;
476 if (!(commit->object.flags & COMPLETE)) {
477 commit->object.flags |= COMPLETE;
478 commit_list_insert(commit, &complete);
481 return 0;
484 static void mark_recent_complete_commits(struct fetch_pack_args *args,
485 unsigned long cutoff)
487 while (complete && cutoff <= complete->item->date) {
488 if (args->verbose)
489 fprintf(stderr, "Marking %s as complete\n",
490 sha1_to_hex(complete->item->object.sha1));
491 pop_most_recent_commit(&complete, COMPLETE);
495 static void filter_refs(struct fetch_pack_args *args,
496 struct ref **refs,
497 struct ref **sought, int nr_sought)
499 struct ref *newlist = NULL;
500 struct ref **newtail = &newlist;
501 struct ref *ref, *next;
502 int i;
504 i = 0;
505 for (ref = *refs; ref; ref = next) {
506 int keep = 0;
507 next = ref->next;
509 if (!memcmp(ref->name, "refs/", 5) &&
510 check_refname_format(ref->name + 5, 0))
511 ; /* trash */
512 else {
513 while (i < nr_sought) {
514 int cmp = strcmp(ref->name, sought[i]->name);
515 if (cmp < 0)
516 break; /* definitely do not have it */
517 else if (cmp == 0) {
518 keep = 1; /* definitely have it */
519 sought[i]->matched = 1;
521 i++;
525 if (!keep && args->fetch_all &&
526 (!args->depth || prefixcmp(ref->name, "refs/tags/")))
527 keep = 1;
529 if (keep) {
530 *newtail = ref;
531 ref->next = NULL;
532 newtail = &ref->next;
533 } else {
534 free(ref);
538 /* Append unmatched requests to the list */
539 if (allow_tip_sha1_in_want) {
540 for (i = 0; i < nr_sought; i++) {
541 ref = sought[i];
542 if (ref->matched)
543 continue;
544 if (get_sha1_hex(ref->name, ref->old_sha1))
545 continue;
547 ref->matched = 1;
548 *newtail = ref;
549 ref->next = NULL;
550 newtail = &ref->next;
553 *refs = newlist;
556 static void mark_alternate_complete(const struct ref *ref, void *unused)
558 mark_complete(NULL, ref->old_sha1, 0, NULL);
561 static int everything_local(struct fetch_pack_args *args,
562 struct ref **refs,
563 struct ref **sought, int nr_sought)
565 struct ref *ref;
566 int retval;
567 unsigned long cutoff = 0;
569 save_commit_buffer = 0;
571 for (ref = *refs; ref; ref = ref->next) {
572 struct object *o;
574 if (!has_sha1_file(ref->old_sha1))
575 continue;
577 o = parse_object(ref->old_sha1);
578 if (!o)
579 continue;
581 /* We already have it -- which may mean that we were
582 * in sync with the other side at some time after
583 * that (it is OK if we guess wrong here).
585 if (o->type == OBJ_COMMIT) {
586 struct commit *commit = (struct commit *)o;
587 if (!cutoff || cutoff < commit->date)
588 cutoff = commit->date;
592 if (!args->depth) {
593 for_each_ref(mark_complete, NULL);
594 for_each_alternate_ref(mark_alternate_complete, NULL);
595 commit_list_sort_by_date(&complete);
596 if (cutoff)
597 mark_recent_complete_commits(args, cutoff);
601 * Mark all complete remote refs as common refs.
602 * Don't mark them common yet; the server has to be told so first.
604 for (ref = *refs; ref; ref = ref->next) {
605 struct object *o = deref_tag(lookup_object(ref->old_sha1),
606 NULL, 0);
608 if (!o || o->type != OBJ_COMMIT || !(o->flags & COMPLETE))
609 continue;
611 if (!(o->flags & SEEN)) {
612 rev_list_push((struct commit *)o, COMMON_REF | SEEN);
614 mark_common((struct commit *)o, 1, 1);
618 filter_refs(args, refs, sought, nr_sought);
620 for (retval = 1, ref = *refs; ref ; ref = ref->next) {
621 const unsigned char *remote = ref->old_sha1;
622 unsigned char local[20];
623 struct object *o;
625 o = lookup_object(remote);
626 if (!o || !(o->flags & COMPLETE)) {
627 retval = 0;
628 if (!args->verbose)
629 continue;
630 fprintf(stderr,
631 "want %s (%s)\n", sha1_to_hex(remote),
632 ref->name);
633 continue;
636 hashcpy(ref->new_sha1, local);
637 if (!args->verbose)
638 continue;
639 fprintf(stderr,
640 "already have %s (%s)\n", sha1_to_hex(remote),
641 ref->name);
643 return retval;
646 static int sideband_demux(int in, int out, void *data)
648 int *xd = data;
650 int ret = recv_sideband("fetch-pack", xd[0], out);
651 close(out);
652 return ret;
655 static int get_pack(struct fetch_pack_args *args,
656 int xd[2], char **pack_lockfile)
658 struct async demux;
659 const char *argv[22];
660 char keep_arg[256];
661 char hdr_arg[256];
662 const char **av, *cmd_name;
663 int do_keep = args->keep_pack;
664 struct child_process cmd;
665 int ret;
667 memset(&demux, 0, sizeof(demux));
668 if (use_sideband) {
669 /* xd[] is talking with upload-pack; subprocess reads from
670 * xd[0], spits out band#2 to stderr, and feeds us band#1
671 * through demux->out.
673 demux.proc = sideband_demux;
674 demux.data = xd;
675 demux.out = -1;
676 if (start_async(&demux))
677 die("fetch-pack: unable to fork off sideband"
678 " demultiplexer");
680 else
681 demux.out = xd[0];
683 memset(&cmd, 0, sizeof(cmd));
684 cmd.argv = argv;
685 av = argv;
686 *hdr_arg = 0;
687 if (!args->keep_pack && unpack_limit) {
688 struct pack_header header;
690 if (read_pack_header(demux.out, &header))
691 die("protocol error: bad pack header");
692 snprintf(hdr_arg, sizeof(hdr_arg),
693 "--pack_header=%"PRIu32",%"PRIu32,
694 ntohl(header.hdr_version), ntohl(header.hdr_entries));
695 if (ntohl(header.hdr_entries) < unpack_limit)
696 do_keep = 0;
697 else
698 do_keep = 1;
701 if (alternate_shallow_file) {
702 *av++ = "--shallow-file";
703 *av++ = alternate_shallow_file;
706 if (do_keep) {
707 if (pack_lockfile)
708 cmd.out = -1;
709 *av++ = cmd_name = "index-pack";
710 *av++ = "--stdin";
711 if (!args->quiet && !args->no_progress)
712 *av++ = "-v";
713 if (args->use_thin_pack)
714 *av++ = "--fix-thin";
715 if (args->lock_pack || unpack_limit) {
716 int s = sprintf(keep_arg,
717 "--keep=fetch-pack %"PRIuMAX " on ", (uintmax_t) getpid());
718 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
719 strcpy(keep_arg + s, "localhost");
720 *av++ = keep_arg;
722 if (args->check_self_contained_and_connected)
723 *av++ = "--check-self-contained-and-connected";
725 else {
726 *av++ = cmd_name = "unpack-objects";
727 if (args->quiet || args->no_progress)
728 *av++ = "-q";
729 args->check_self_contained_and_connected = 0;
731 if (*hdr_arg)
732 *av++ = hdr_arg;
733 if (fetch_fsck_objects >= 0
734 ? fetch_fsck_objects
735 : transfer_fsck_objects >= 0
736 ? transfer_fsck_objects
737 : 0)
738 *av++ = "--strict";
739 *av++ = NULL;
741 cmd.in = demux.out;
742 cmd.git_cmd = 1;
743 if (start_command(&cmd))
744 die("fetch-pack: unable to fork off %s", cmd_name);
745 if (do_keep && pack_lockfile) {
746 *pack_lockfile = index_pack_lockfile(cmd.out);
747 close(cmd.out);
750 ret = finish_command(&cmd);
751 if (!ret || (args->check_self_contained_and_connected && ret == 1))
752 args->self_contained_and_connected =
753 args->check_self_contained_and_connected &&
754 ret == 0;
755 else
756 die("%s failed", cmd_name);
757 if (use_sideband && finish_async(&demux))
758 die("error in sideband demultiplexer");
759 return 0;
762 static int cmp_ref_by_name(const void *a_, const void *b_)
764 const struct ref *a = *((const struct ref **)a_);
765 const struct ref *b = *((const struct ref **)b_);
766 return strcmp(a->name, b->name);
769 static struct ref *do_fetch_pack(struct fetch_pack_args *args,
770 int fd[2],
771 const struct ref *orig_ref,
772 struct ref **sought, int nr_sought,
773 char **pack_lockfile)
775 struct ref *ref = copy_ref_list(orig_ref);
776 unsigned char sha1[20];
777 const char *agent_feature;
778 int agent_len;
780 sort_ref_list(&ref, ref_compare_name);
781 qsort(sought, nr_sought, sizeof(*sought), cmp_ref_by_name);
783 if (is_repository_shallow() && !server_supports("shallow"))
784 die("Server does not support shallow clients");
785 if (server_supports("multi_ack_detailed")) {
786 if (args->verbose)
787 fprintf(stderr, "Server supports multi_ack_detailed\n");
788 multi_ack = 2;
789 if (server_supports("no-done")) {
790 if (args->verbose)
791 fprintf(stderr, "Server supports no-done\n");
792 if (args->stateless_rpc)
793 no_done = 1;
796 else if (server_supports("multi_ack")) {
797 if (args->verbose)
798 fprintf(stderr, "Server supports multi_ack\n");
799 multi_ack = 1;
801 if (server_supports("side-band-64k")) {
802 if (args->verbose)
803 fprintf(stderr, "Server supports side-band-64k\n");
804 use_sideband = 2;
806 else if (server_supports("side-band")) {
807 if (args->verbose)
808 fprintf(stderr, "Server supports side-band\n");
809 use_sideband = 1;
811 if (server_supports("allow-tip-sha1-in-want")) {
812 if (args->verbose)
813 fprintf(stderr, "Server supports allow-tip-sha1-in-want\n");
814 allow_tip_sha1_in_want = 1;
816 if (!server_supports("thin-pack"))
817 args->use_thin_pack = 0;
818 if (!server_supports("no-progress"))
819 args->no_progress = 0;
820 if (!server_supports("include-tag"))
821 args->include_tag = 0;
822 if (server_supports("ofs-delta")) {
823 if (args->verbose)
824 fprintf(stderr, "Server supports ofs-delta\n");
825 } else
826 prefer_ofs_delta = 0;
828 if ((agent_feature = server_feature_value("agent", &agent_len))) {
829 agent_supported = 1;
830 if (args->verbose && agent_len)
831 fprintf(stderr, "Server version is %.*s\n",
832 agent_len, agent_feature);
835 if (everything_local(args, &ref, sought, nr_sought)) {
836 packet_flush(fd[1]);
837 goto all_done;
839 if (find_common(args, fd, sha1, ref) < 0)
840 if (!args->keep_pack)
841 /* When cloning, it is not unusual to have
842 * no common commit.
844 warning("no common commits");
846 if (args->stateless_rpc)
847 packet_flush(fd[1]);
848 if (args->depth > 0)
849 setup_alternate_shallow(&shallow_lock, &alternate_shallow_file);
850 else
851 alternate_shallow_file = NULL;
852 if (get_pack(args, fd, pack_lockfile))
853 die("git fetch-pack: fetch failed.");
855 all_done:
856 return ref;
859 static int fetch_pack_config(const char *var, const char *value, void *cb)
861 if (strcmp(var, "fetch.unpacklimit") == 0) {
862 fetch_unpack_limit = git_config_int(var, value);
863 return 0;
866 if (strcmp(var, "transfer.unpacklimit") == 0) {
867 transfer_unpack_limit = git_config_int(var, value);
868 return 0;
871 if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
872 prefer_ofs_delta = git_config_bool(var, value);
873 return 0;
876 if (!strcmp(var, "fetch.fsckobjects")) {
877 fetch_fsck_objects = git_config_bool(var, value);
878 return 0;
881 if (!strcmp(var, "transfer.fsckobjects")) {
882 transfer_fsck_objects = git_config_bool(var, value);
883 return 0;
886 return git_default_config(var, value, cb);
889 static void fetch_pack_setup(void)
891 static int did_setup;
892 if (did_setup)
893 return;
894 git_config(fetch_pack_config, NULL);
895 if (0 <= transfer_unpack_limit)
896 unpack_limit = transfer_unpack_limit;
897 else if (0 <= fetch_unpack_limit)
898 unpack_limit = fetch_unpack_limit;
899 did_setup = 1;
902 static int remove_duplicates_in_refs(struct ref **ref, int nr)
904 struct string_list names = STRING_LIST_INIT_NODUP;
905 int src, dst;
907 for (src = dst = 0; src < nr; src++) {
908 struct string_list_item *item;
909 item = string_list_insert(&names, ref[src]->name);
910 if (item->util)
911 continue; /* already have it */
912 item->util = ref[src];
913 if (src != dst)
914 ref[dst] = ref[src];
915 dst++;
917 for (src = dst; src < nr; src++)
918 ref[src] = NULL;
919 string_list_clear(&names, 0);
920 return dst;
923 struct ref *fetch_pack(struct fetch_pack_args *args,
924 int fd[], struct child_process *conn,
925 const struct ref *ref,
926 const char *dest,
927 struct ref **sought, int nr_sought,
928 char **pack_lockfile)
930 struct ref *ref_cpy;
932 fetch_pack_setup();
933 if (nr_sought)
934 nr_sought = remove_duplicates_in_refs(sought, nr_sought);
936 if (!ref) {
937 packet_flush(fd[1]);
938 die("no matching remote head");
940 ref_cpy = do_fetch_pack(args, fd, ref, sought, nr_sought, pack_lockfile);
942 if (args->depth > 0 && alternate_shallow_file) {
943 if (*alternate_shallow_file == '\0') { /* --unshallow */
944 unlink_or_warn(git_path("shallow"));
945 rollback_lock_file(&shallow_lock);
946 } else
947 commit_lock_file(&shallow_lock);
950 reprepare_packed_git();
951 return ref_cpy;