Merge branch 'tf/gitweb-ss-tweak'
[git/gitweb.git] / fetch-pack.c
blob094267fd80cdb09feec75c89aa2f4931f11e583d
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 struct write_shallow_data {
189 struct strbuf *out;
190 int use_pack_protocol;
191 int count;
194 static int write_one_shallow(const struct commit_graft *graft, void *cb_data)
196 struct write_shallow_data *data = cb_data;
197 const char *hex = sha1_to_hex(graft->sha1);
198 data->count++;
199 if (data->use_pack_protocol)
200 packet_buf_write(data->out, "shallow %s", hex);
201 else {
202 strbuf_addstr(data->out, hex);
203 strbuf_addch(data->out, '\n');
205 return 0;
208 static int write_shallow_commits(struct strbuf *out, int use_pack_protocol)
210 struct write_shallow_data data;
211 data.out = out;
212 data.use_pack_protocol = use_pack_protocol;
213 data.count = 0;
214 for_each_commit_graft(write_one_shallow, &data);
215 return data.count;
218 static enum ack_type get_ack(int fd, unsigned char *result_sha1)
220 int len;
221 char *line = packet_read_line(fd, &len);
223 if (!len)
224 die("git fetch-pack: expected ACK/NAK, got EOF");
225 if (!strcmp(line, "NAK"))
226 return NAK;
227 if (!prefixcmp(line, "ACK ")) {
228 if (!get_sha1_hex(line+4, result_sha1)) {
229 if (len < 45)
230 return ACK;
231 if (strstr(line+45, "continue"))
232 return ACK_continue;
233 if (strstr(line+45, "common"))
234 return ACK_common;
235 if (strstr(line+45, "ready"))
236 return ACK_ready;
237 return ACK;
240 die("git fetch_pack: expected ACK/NAK, got '%s'", line);
243 static void send_request(struct fetch_pack_args *args,
244 int fd, struct strbuf *buf)
246 if (args->stateless_rpc) {
247 send_sideband(fd, -1, buf->buf, buf->len, LARGE_PACKET_MAX);
248 packet_flush(fd);
249 } else
250 write_or_die(fd, buf->buf, buf->len);
253 static void insert_one_alternate_ref(const struct ref *ref, void *unused)
255 rev_list_insert_ref(NULL, ref->old_sha1, 0, NULL);
258 #define INITIAL_FLUSH 16
259 #define PIPESAFE_FLUSH 32
260 #define LARGE_FLUSH 1024
262 static int next_flush(struct fetch_pack_args *args, int count)
264 int flush_limit = args->stateless_rpc ? LARGE_FLUSH : PIPESAFE_FLUSH;
266 if (count < flush_limit)
267 count <<= 1;
268 else
269 count += flush_limit;
270 return count;
273 static int find_common(struct fetch_pack_args *args,
274 int fd[2], unsigned char *result_sha1,
275 struct ref *refs)
277 int fetching;
278 int count = 0, flushes = 0, flush_at = INITIAL_FLUSH, retval;
279 const unsigned char *sha1;
280 unsigned in_vain = 0;
281 int got_continue = 0;
282 int got_ready = 0;
283 struct strbuf req_buf = STRBUF_INIT;
284 size_t state_len = 0;
286 if (args->stateless_rpc && multi_ack == 1)
287 die("--stateless-rpc requires multi_ack_detailed");
288 if (marked)
289 for_each_ref(clear_marks, NULL);
290 marked = 1;
292 for_each_ref(rev_list_insert_ref, NULL);
293 for_each_alternate_ref(insert_one_alternate_ref, NULL);
295 fetching = 0;
296 for ( ; refs ; refs = refs->next) {
297 unsigned char *remote = refs->old_sha1;
298 const char *remote_hex;
299 struct object *o;
302 * If that object is complete (i.e. it is an ancestor of a
303 * local ref), we tell them we have it but do not have to
304 * tell them about its ancestors, which they already know
305 * about.
307 * We use lookup_object here because we are only
308 * interested in the case we *know* the object is
309 * reachable and we have already scanned it.
311 if (((o = lookup_object(remote)) != NULL) &&
312 (o->flags & COMPLETE)) {
313 continue;
316 remote_hex = sha1_to_hex(remote);
317 if (!fetching) {
318 struct strbuf c = STRBUF_INIT;
319 if (multi_ack == 2) strbuf_addstr(&c, " multi_ack_detailed");
320 if (multi_ack == 1) strbuf_addstr(&c, " multi_ack");
321 if (no_done) strbuf_addstr(&c, " no-done");
322 if (use_sideband == 2) strbuf_addstr(&c, " side-band-64k");
323 if (use_sideband == 1) strbuf_addstr(&c, " side-band");
324 if (args->use_thin_pack) strbuf_addstr(&c, " thin-pack");
325 if (args->no_progress) strbuf_addstr(&c, " no-progress");
326 if (args->include_tag) strbuf_addstr(&c, " include-tag");
327 if (prefer_ofs_delta) strbuf_addstr(&c, " ofs-delta");
328 if (agent_supported) strbuf_addf(&c, " agent=%s",
329 git_user_agent_sanitized());
330 packet_buf_write(&req_buf, "want %s%s\n", remote_hex, c.buf);
331 strbuf_release(&c);
332 } else
333 packet_buf_write(&req_buf, "want %s\n", remote_hex);
334 fetching++;
337 if (!fetching) {
338 strbuf_release(&req_buf);
339 packet_flush(fd[1]);
340 return 1;
343 if (is_repository_shallow())
344 write_shallow_commits(&req_buf, 1);
345 if (args->depth > 0)
346 packet_buf_write(&req_buf, "deepen %d", args->depth);
347 packet_buf_flush(&req_buf);
348 state_len = req_buf.len;
350 if (args->depth > 0) {
351 char *line;
352 unsigned char sha1[20];
354 send_request(args, fd[1], &req_buf);
355 while ((line = packet_read_line(fd[0], NULL))) {
356 if (!prefixcmp(line, "shallow ")) {
357 if (get_sha1_hex(line + 8, sha1))
358 die("invalid shallow line: %s", line);
359 register_shallow(sha1);
360 continue;
362 if (!prefixcmp(line, "unshallow ")) {
363 if (get_sha1_hex(line + 10, sha1))
364 die("invalid unshallow line: %s", line);
365 if (!lookup_object(sha1))
366 die("object not found: %s", line);
367 /* make sure that it is parsed as shallow */
368 if (!parse_object(sha1))
369 die("error in object: %s", line);
370 if (unregister_shallow(sha1))
371 die("no shallow found: %s", line);
372 continue;
374 die("expected shallow/unshallow, got %s", line);
376 } else if (!args->stateless_rpc)
377 send_request(args, fd[1], &req_buf);
379 if (!args->stateless_rpc) {
380 /* If we aren't using the stateless-rpc interface
381 * we don't need to retain the headers.
383 strbuf_setlen(&req_buf, 0);
384 state_len = 0;
387 flushes = 0;
388 retval = -1;
389 while ((sha1 = get_rev())) {
390 packet_buf_write(&req_buf, "have %s\n", sha1_to_hex(sha1));
391 if (args->verbose)
392 fprintf(stderr, "have %s\n", sha1_to_hex(sha1));
393 in_vain++;
394 if (flush_at <= ++count) {
395 int ack;
397 packet_buf_flush(&req_buf);
398 send_request(args, fd[1], &req_buf);
399 strbuf_setlen(&req_buf, state_len);
400 flushes++;
401 flush_at = next_flush(args, count);
404 * We keep one window "ahead" of the other side, and
405 * will wait for an ACK only on the next one
407 if (!args->stateless_rpc && count == INITIAL_FLUSH)
408 continue;
410 consume_shallow_list(args, fd[0]);
411 do {
412 ack = get_ack(fd[0], result_sha1);
413 if (args->verbose && ack)
414 fprintf(stderr, "got ack %d %s\n", ack,
415 sha1_to_hex(result_sha1));
416 switch (ack) {
417 case ACK:
418 flushes = 0;
419 multi_ack = 0;
420 retval = 0;
421 goto done;
422 case ACK_common:
423 case ACK_ready:
424 case ACK_continue: {
425 struct commit *commit =
426 lookup_commit(result_sha1);
427 if (!commit)
428 die("invalid commit %s", sha1_to_hex(result_sha1));
429 if (args->stateless_rpc
430 && ack == ACK_common
431 && !(commit->object.flags & COMMON)) {
432 /* We need to replay the have for this object
433 * on the next RPC request so the peer knows
434 * it is in common with us.
436 const char *hex = sha1_to_hex(result_sha1);
437 packet_buf_write(&req_buf, "have %s\n", hex);
438 state_len = req_buf.len;
440 mark_common(commit, 0, 1);
441 retval = 0;
442 in_vain = 0;
443 got_continue = 1;
444 if (ack == ACK_ready) {
445 clear_prio_queue(&rev_list);
446 got_ready = 1;
448 break;
451 } while (ack);
452 flushes--;
453 if (got_continue && MAX_IN_VAIN < in_vain) {
454 if (args->verbose)
455 fprintf(stderr, "giving up\n");
456 break; /* give up */
460 done:
461 if (!got_ready || !no_done) {
462 packet_buf_write(&req_buf, "done\n");
463 send_request(args, fd[1], &req_buf);
465 if (args->verbose)
466 fprintf(stderr, "done\n");
467 if (retval != 0) {
468 multi_ack = 0;
469 flushes++;
471 strbuf_release(&req_buf);
473 consume_shallow_list(args, fd[0]);
474 while (flushes || multi_ack) {
475 int ack = get_ack(fd[0], result_sha1);
476 if (ack) {
477 if (args->verbose)
478 fprintf(stderr, "got ack (%d) %s\n", ack,
479 sha1_to_hex(result_sha1));
480 if (ack == ACK)
481 return 0;
482 multi_ack = 1;
483 continue;
485 flushes--;
487 /* it is no error to fetch into a completely empty repo */
488 return count ? retval : 0;
491 static struct commit_list *complete;
493 static int mark_complete(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
495 struct object *o = parse_object(sha1);
497 while (o && o->type == OBJ_TAG) {
498 struct tag *t = (struct tag *) o;
499 if (!t->tagged)
500 break; /* broken repository */
501 o->flags |= COMPLETE;
502 o = parse_object(t->tagged->sha1);
504 if (o && o->type == OBJ_COMMIT) {
505 struct commit *commit = (struct commit *)o;
506 if (!(commit->object.flags & COMPLETE)) {
507 commit->object.flags |= COMPLETE;
508 commit_list_insert(commit, &complete);
511 return 0;
514 static void mark_recent_complete_commits(struct fetch_pack_args *args,
515 unsigned long cutoff)
517 while (complete && cutoff <= complete->item->date) {
518 if (args->verbose)
519 fprintf(stderr, "Marking %s as complete\n",
520 sha1_to_hex(complete->item->object.sha1));
521 pop_most_recent_commit(&complete, COMPLETE);
525 static void filter_refs(struct fetch_pack_args *args,
526 struct ref **refs,
527 struct ref **sought, int nr_sought)
529 struct ref *newlist = NULL;
530 struct ref **newtail = &newlist;
531 struct ref *ref, *next;
532 int i;
534 i = 0;
535 for (ref = *refs; ref; ref = next) {
536 int keep = 0;
537 next = ref->next;
539 if (!memcmp(ref->name, "refs/", 5) &&
540 check_refname_format(ref->name + 5, 0))
541 ; /* trash */
542 else {
543 while (i < nr_sought) {
544 int cmp = strcmp(ref->name, sought[i]->name);
545 if (cmp < 0)
546 break; /* definitely do not have it */
547 else if (cmp == 0) {
548 keep = 1; /* definitely have it */
549 sought[i]->matched = 1;
551 i++;
555 if (!keep && args->fetch_all &&
556 (!args->depth || prefixcmp(ref->name, "refs/tags/")))
557 keep = 1;
559 if (keep) {
560 *newtail = ref;
561 ref->next = NULL;
562 newtail = &ref->next;
563 } else {
564 free(ref);
568 /* Append unmatched requests to the list */
569 if (allow_tip_sha1_in_want) {
570 for (i = 0; i < nr_sought; i++) {
571 ref = sought[i];
572 if (ref->matched)
573 continue;
574 if (get_sha1_hex(ref->name, ref->old_sha1))
575 continue;
577 ref->matched = 1;
578 *newtail = ref;
579 ref->next = NULL;
580 newtail = &ref->next;
583 *refs = newlist;
586 static void mark_alternate_complete(const struct ref *ref, void *unused)
588 mark_complete(NULL, ref->old_sha1, 0, NULL);
591 static int everything_local(struct fetch_pack_args *args,
592 struct ref **refs,
593 struct ref **sought, int nr_sought)
595 struct ref *ref;
596 int retval;
597 unsigned long cutoff = 0;
599 save_commit_buffer = 0;
601 for (ref = *refs; ref; ref = ref->next) {
602 struct object *o;
604 if (!has_sha1_file(ref->old_sha1))
605 continue;
607 o = parse_object(ref->old_sha1);
608 if (!o)
609 continue;
611 /* We already have it -- which may mean that we were
612 * in sync with the other side at some time after
613 * that (it is OK if we guess wrong here).
615 if (o->type == OBJ_COMMIT) {
616 struct commit *commit = (struct commit *)o;
617 if (!cutoff || cutoff < commit->date)
618 cutoff = commit->date;
622 if (!args->depth) {
623 for_each_ref(mark_complete, NULL);
624 for_each_alternate_ref(mark_alternate_complete, NULL);
625 commit_list_sort_by_date(&complete);
626 if (cutoff)
627 mark_recent_complete_commits(args, cutoff);
631 * Mark all complete remote refs as common refs.
632 * Don't mark them common yet; the server has to be told so first.
634 for (ref = *refs; ref; ref = ref->next) {
635 struct object *o = deref_tag(lookup_object(ref->old_sha1),
636 NULL, 0);
638 if (!o || o->type != OBJ_COMMIT || !(o->flags & COMPLETE))
639 continue;
641 if (!(o->flags & SEEN)) {
642 rev_list_push((struct commit *)o, COMMON_REF | SEEN);
644 mark_common((struct commit *)o, 1, 1);
648 filter_refs(args, refs, sought, nr_sought);
650 for (retval = 1, ref = *refs; ref ; ref = ref->next) {
651 const unsigned char *remote = ref->old_sha1;
652 unsigned char local[20];
653 struct object *o;
655 o = lookup_object(remote);
656 if (!o || !(o->flags & COMPLETE)) {
657 retval = 0;
658 if (!args->verbose)
659 continue;
660 fprintf(stderr,
661 "want %s (%s)\n", sha1_to_hex(remote),
662 ref->name);
663 continue;
666 hashcpy(ref->new_sha1, local);
667 if (!args->verbose)
668 continue;
669 fprintf(stderr,
670 "already have %s (%s)\n", sha1_to_hex(remote),
671 ref->name);
673 return retval;
676 static int sideband_demux(int in, int out, void *data)
678 int *xd = data;
680 int ret = recv_sideband("fetch-pack", xd[0], out);
681 close(out);
682 return ret;
685 static int get_pack(struct fetch_pack_args *args,
686 int xd[2], char **pack_lockfile)
688 struct async demux;
689 const char *argv[22];
690 char keep_arg[256];
691 char hdr_arg[256];
692 const char **av;
693 int do_keep = args->keep_pack;
694 struct child_process cmd;
695 int ret;
697 memset(&demux, 0, sizeof(demux));
698 if (use_sideband) {
699 /* xd[] is talking with upload-pack; subprocess reads from
700 * xd[0], spits out band#2 to stderr, and feeds us band#1
701 * through demux->out.
703 demux.proc = sideband_demux;
704 demux.data = xd;
705 demux.out = -1;
706 if (start_async(&demux))
707 die("fetch-pack: unable to fork off sideband"
708 " demultiplexer");
710 else
711 demux.out = xd[0];
713 memset(&cmd, 0, sizeof(cmd));
714 cmd.argv = argv;
715 av = argv;
716 *hdr_arg = 0;
717 if (!args->keep_pack && unpack_limit) {
718 struct pack_header header;
720 if (read_pack_header(demux.out, &header))
721 die("protocol error: bad pack header");
722 snprintf(hdr_arg, sizeof(hdr_arg),
723 "--pack_header=%"PRIu32",%"PRIu32,
724 ntohl(header.hdr_version), ntohl(header.hdr_entries));
725 if (ntohl(header.hdr_entries) < unpack_limit)
726 do_keep = 0;
727 else
728 do_keep = 1;
731 if (alternate_shallow_file) {
732 *av++ = "--shallow-file";
733 *av++ = alternate_shallow_file;
736 if (do_keep) {
737 if (pack_lockfile)
738 cmd.out = -1;
739 *av++ = "index-pack";
740 *av++ = "--stdin";
741 if (!args->quiet && !args->no_progress)
742 *av++ = "-v";
743 if (args->use_thin_pack)
744 *av++ = "--fix-thin";
745 if (args->lock_pack || unpack_limit) {
746 int s = sprintf(keep_arg,
747 "--keep=fetch-pack %"PRIuMAX " on ", (uintmax_t) getpid());
748 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
749 strcpy(keep_arg + s, "localhost");
750 *av++ = keep_arg;
752 if (args->check_self_contained_and_connected)
753 *av++ = "--check-self-contained-and-connected";
755 else {
756 *av++ = "unpack-objects";
757 if (args->quiet || args->no_progress)
758 *av++ = "-q";
759 args->check_self_contained_and_connected = 0;
761 if (*hdr_arg)
762 *av++ = hdr_arg;
763 if (fetch_fsck_objects >= 0
764 ? fetch_fsck_objects
765 : transfer_fsck_objects >= 0
766 ? transfer_fsck_objects
767 : 0)
768 *av++ = "--strict";
769 *av++ = NULL;
771 cmd.in = demux.out;
772 cmd.git_cmd = 1;
773 if (start_command(&cmd))
774 die("fetch-pack: unable to fork off %s", argv[0]);
775 if (do_keep && pack_lockfile) {
776 *pack_lockfile = index_pack_lockfile(cmd.out);
777 close(cmd.out);
780 ret = finish_command(&cmd);
781 if (!ret || (args->check_self_contained_and_connected && ret == 1))
782 args->self_contained_and_connected =
783 args->check_self_contained_and_connected &&
784 ret == 0;
785 else
786 die("%s failed", argv[0]);
787 if (use_sideband && finish_async(&demux))
788 die("error in sideband demultiplexer");
789 return 0;
792 static int cmp_ref_by_name(const void *a_, const void *b_)
794 const struct ref *a = *((const struct ref **)a_);
795 const struct ref *b = *((const struct ref **)b_);
796 return strcmp(a->name, b->name);
799 static void setup_alternate_shallow(void)
801 struct strbuf sb = STRBUF_INIT;
802 int fd;
804 check_shallow_file_for_update();
805 fd = hold_lock_file_for_update(&shallow_lock, git_path("shallow"),
806 LOCK_DIE_ON_ERROR);
807 if (write_shallow_commits(&sb, 0)) {
808 if (write_in_full(fd, sb.buf, sb.len) != sb.len)
809 die_errno("failed to write to %s", shallow_lock.filename);
810 alternate_shallow_file = shallow_lock.filename;
811 } else
813 * is_repository_shallow() sees empty string as "no
814 * shallow file".
816 alternate_shallow_file = "";
817 strbuf_release(&sb);
820 static struct ref *do_fetch_pack(struct fetch_pack_args *args,
821 int fd[2],
822 const struct ref *orig_ref,
823 struct ref **sought, int nr_sought,
824 char **pack_lockfile)
826 struct ref *ref = copy_ref_list(orig_ref);
827 unsigned char sha1[20];
828 const char *agent_feature;
829 int agent_len;
831 sort_ref_list(&ref, ref_compare_name);
832 qsort(sought, nr_sought, sizeof(*sought), cmp_ref_by_name);
834 if (is_repository_shallow() && !server_supports("shallow"))
835 die("Server does not support shallow clients");
836 if (server_supports("multi_ack_detailed")) {
837 if (args->verbose)
838 fprintf(stderr, "Server supports multi_ack_detailed\n");
839 multi_ack = 2;
840 if (server_supports("no-done")) {
841 if (args->verbose)
842 fprintf(stderr, "Server supports no-done\n");
843 if (args->stateless_rpc)
844 no_done = 1;
847 else if (server_supports("multi_ack")) {
848 if (args->verbose)
849 fprintf(stderr, "Server supports multi_ack\n");
850 multi_ack = 1;
852 if (server_supports("side-band-64k")) {
853 if (args->verbose)
854 fprintf(stderr, "Server supports side-band-64k\n");
855 use_sideband = 2;
857 else if (server_supports("side-band")) {
858 if (args->verbose)
859 fprintf(stderr, "Server supports side-band\n");
860 use_sideband = 1;
862 if (server_supports("allow-tip-sha1-in-want")) {
863 if (args->verbose)
864 fprintf(stderr, "Server supports allow-tip-sha1-in-want\n");
865 allow_tip_sha1_in_want = 1;
867 if (!server_supports("thin-pack"))
868 args->use_thin_pack = 0;
869 if (!server_supports("no-progress"))
870 args->no_progress = 0;
871 if (!server_supports("include-tag"))
872 args->include_tag = 0;
873 if (server_supports("ofs-delta")) {
874 if (args->verbose)
875 fprintf(stderr, "Server supports ofs-delta\n");
876 } else
877 prefer_ofs_delta = 0;
879 if ((agent_feature = server_feature_value("agent", &agent_len))) {
880 agent_supported = 1;
881 if (args->verbose && agent_len)
882 fprintf(stderr, "Server version is %.*s\n",
883 agent_len, agent_feature);
886 if (everything_local(args, &ref, sought, nr_sought)) {
887 packet_flush(fd[1]);
888 goto all_done;
890 if (find_common(args, fd, sha1, ref) < 0)
891 if (!args->keep_pack)
892 /* When cloning, it is not unusual to have
893 * no common commit.
895 warning("no common commits");
897 if (args->stateless_rpc)
898 packet_flush(fd[1]);
899 if (args->depth > 0)
900 setup_alternate_shallow();
901 else
902 alternate_shallow_file = NULL;
903 if (get_pack(args, fd, pack_lockfile))
904 die("git fetch-pack: fetch failed.");
906 all_done:
907 return ref;
910 static int fetch_pack_config(const char *var, const char *value, void *cb)
912 if (strcmp(var, "fetch.unpacklimit") == 0) {
913 fetch_unpack_limit = git_config_int(var, value);
914 return 0;
917 if (strcmp(var, "transfer.unpacklimit") == 0) {
918 transfer_unpack_limit = git_config_int(var, value);
919 return 0;
922 if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
923 prefer_ofs_delta = git_config_bool(var, value);
924 return 0;
927 if (!strcmp(var, "fetch.fsckobjects")) {
928 fetch_fsck_objects = git_config_bool(var, value);
929 return 0;
932 if (!strcmp(var, "transfer.fsckobjects")) {
933 transfer_fsck_objects = git_config_bool(var, value);
934 return 0;
937 return git_default_config(var, value, cb);
940 static void fetch_pack_setup(void)
942 static int did_setup;
943 if (did_setup)
944 return;
945 git_config(fetch_pack_config, NULL);
946 if (0 <= transfer_unpack_limit)
947 unpack_limit = transfer_unpack_limit;
948 else if (0 <= fetch_unpack_limit)
949 unpack_limit = fetch_unpack_limit;
950 did_setup = 1;
953 static int remove_duplicates_in_refs(struct ref **ref, int nr)
955 struct string_list names = STRING_LIST_INIT_NODUP;
956 int src, dst;
958 for (src = dst = 0; src < nr; src++) {
959 struct string_list_item *item;
960 item = string_list_insert(&names, ref[src]->name);
961 if (item->util)
962 continue; /* already have it */
963 item->util = ref[src];
964 if (src != dst)
965 ref[dst] = ref[src];
966 dst++;
968 for (src = dst; src < nr; src++)
969 ref[src] = NULL;
970 string_list_clear(&names, 0);
971 return dst;
974 struct ref *fetch_pack(struct fetch_pack_args *args,
975 int fd[], struct child_process *conn,
976 const struct ref *ref,
977 const char *dest,
978 struct ref **sought, int nr_sought,
979 char **pack_lockfile)
981 struct ref *ref_cpy;
983 fetch_pack_setup();
984 if (nr_sought)
985 nr_sought = remove_duplicates_in_refs(sought, nr_sought);
987 if (!ref) {
988 packet_flush(fd[1]);
989 die("no matching remote head");
991 ref_cpy = do_fetch_pack(args, fd, ref, sought, nr_sought, pack_lockfile);
993 if (args->depth > 0 && alternate_shallow_file) {
994 if (*alternate_shallow_file == '\0') { /* --unshallow */
995 unlink_or_warn(git_path("shallow"));
996 rollback_lock_file(&shallow_lock);
997 } else
998 commit_lock_file(&shallow_lock);
1001 reprepare_packed_git();
1002 return ref_cpy;