tgupdate: merge girocco base into girocco
[git/gitweb.git] / fetch-pack.c
blob601f0779a1903a2b860412e3404e4ea8e4bce573
1 #include "cache.h"
2 #include "lockfile.h"
3 #include "refs.h"
4 #include "pkt-line.h"
5 #include "commit.h"
6 #include "tag.h"
7 #include "exec_cmd.h"
8 #include "pack.h"
9 #include "sideband.h"
10 #include "fetch-pack.h"
11 #include "remote.h"
12 #include "run-command.h"
13 #include "connect.h"
14 #include "transport.h"
15 #include "version.h"
16 #include "prio-queue.h"
17 #include "sha1-array.h"
19 static int transfer_unpack_limit = -1;
20 static int fetch_unpack_limit = -1;
21 static int unpack_limit = 100;
22 static int prefer_ofs_delta = 1;
23 static int no_done;
24 static int deepen_since_ok;
25 static int deepen_not_ok;
26 static int fetch_fsck_objects = -1;
27 static int transfer_fsck_objects = -1;
28 static int agent_supported;
29 static struct lock_file shallow_lock;
30 static const char *alternate_shallow_file;
32 /* Remember to update object flag allocation in object.h */
33 #define COMPLETE (1U << 0)
34 #define COMMON (1U << 1)
35 #define COMMON_REF (1U << 2)
36 #define SEEN (1U << 3)
37 #define POPPED (1U << 4)
39 static int marked;
42 * After sending this many "have"s if we do not get any new ACK , we
43 * give up traversing our history.
45 #define MAX_IN_VAIN 256
47 static struct prio_queue rev_list = { compare_commits_by_commit_date };
48 static int non_common_revs, multi_ack, use_sideband;
49 /* Allow specifying sha1 if it is a ref tip. */
50 #define ALLOW_TIP_SHA1 01
51 /* Allow request of a sha1 if it is reachable from a ref (possibly hidden ref). */
52 #define ALLOW_REACHABLE_SHA1 02
53 static unsigned int allow_unadvertised_object_request;
55 __attribute__((format (printf, 2, 3)))
56 static inline void print_verbose(const struct fetch_pack_args *args,
57 const char *fmt, ...)
59 va_list params;
61 if (!args->verbose)
62 return;
64 va_start(params, fmt);
65 vfprintf(stderr, fmt, params);
66 va_end(params);
67 fputc('\n', stderr);
70 static void rev_list_push(struct commit *commit, int mark)
72 if (!(commit->object.flags & mark)) {
73 commit->object.flags |= mark;
75 if (parse_commit(commit))
76 return;
78 prio_queue_put(&rev_list, commit);
80 if (!(commit->object.flags & COMMON))
81 non_common_revs++;
85 static int rev_list_insert_ref(const char *refname, const unsigned char *sha1)
87 struct object *o = deref_tag(parse_object(sha1), refname, 0);
89 if (o && o->type == OBJ_COMMIT)
90 rev_list_push((struct commit *)o, SEEN);
92 return 0;
95 static int rev_list_insert_ref_oid(const char *refname, const struct object_id *oid,
96 int flag, void *cb_data)
98 return rev_list_insert_ref(refname, oid->hash);
101 static int clear_marks(const char *refname, const struct object_id *oid,
102 int flag, void *cb_data)
104 struct object *o = deref_tag(parse_object(oid->hash), refname, 0);
106 if (o && o->type == OBJ_COMMIT)
107 clear_commit_marks((struct commit *)o,
108 COMMON | COMMON_REF | SEEN | POPPED);
109 return 0;
113 This function marks a rev and its ancestors as common.
114 In some cases, it is desirable to mark only the ancestors (for example
115 when only the server does not yet know that they are common).
118 static void mark_common(struct commit *commit,
119 int ancestors_only, int dont_parse)
121 if (commit != NULL && !(commit->object.flags & COMMON)) {
122 struct object *o = (struct object *)commit;
124 if (!ancestors_only)
125 o->flags |= COMMON;
127 if (!(o->flags & SEEN))
128 rev_list_push(commit, SEEN);
129 else {
130 struct commit_list *parents;
132 if (!ancestors_only && !(o->flags & POPPED))
133 non_common_revs--;
134 if (!o->parsed && !dont_parse)
135 if (parse_commit(commit))
136 return;
138 for (parents = commit->parents;
139 parents;
140 parents = parents->next)
141 mark_common(parents->item, 0, dont_parse);
147 Get the next rev to send, ignoring the common.
150 static const unsigned char *get_rev(void)
152 struct commit *commit = NULL;
154 while (commit == NULL) {
155 unsigned int mark;
156 struct commit_list *parents;
158 if (rev_list.nr == 0 || non_common_revs == 0)
159 return NULL;
161 commit = prio_queue_get(&rev_list);
162 parse_commit(commit);
163 parents = commit->parents;
165 commit->object.flags |= POPPED;
166 if (!(commit->object.flags & COMMON))
167 non_common_revs--;
169 if (commit->object.flags & COMMON) {
170 /* do not send "have", and ignore ancestors */
171 commit = NULL;
172 mark = COMMON | SEEN;
173 } else if (commit->object.flags & COMMON_REF)
174 /* send "have", and ignore ancestors */
175 mark = COMMON | SEEN;
176 else
177 /* send "have", also for its ancestors */
178 mark = SEEN;
180 while (parents) {
181 if (!(parents->item->object.flags & SEEN))
182 rev_list_push(parents->item, mark);
183 if (mark & COMMON)
184 mark_common(parents->item, 1, 0);
185 parents = parents->next;
189 return commit->object.oid.hash;
192 enum ack_type {
193 NAK = 0,
194 ACK,
195 ACK_continue,
196 ACK_common,
197 ACK_ready
200 static void consume_shallow_list(struct fetch_pack_args *args, int fd)
202 if (args->stateless_rpc && args->deepen) {
203 /* If we sent a depth we will get back "duplicate"
204 * shallow and unshallow commands every time there
205 * is a block of have lines exchanged.
207 char *line;
208 while ((line = packet_read_line(fd, NULL))) {
209 if (starts_with(line, "shallow "))
210 continue;
211 if (starts_with(line, "unshallow "))
212 continue;
213 die(_("git fetch-pack: expected shallow list"));
218 static enum ack_type get_ack(int fd, unsigned char *result_sha1)
220 int len;
221 char *line = packet_read_line(fd, &len);
222 const char *arg;
224 if (!len)
225 die(_("git fetch-pack: expected ACK/NAK, got EOF"));
226 if (!strcmp(line, "NAK"))
227 return NAK;
228 if (skip_prefix(line, "ACK ", &arg)) {
229 if (!get_sha1_hex(arg, result_sha1)) {
230 arg += 40;
231 len -= arg - line;
232 if (len < 1)
233 return ACK;
234 if (strstr(arg, "continue"))
235 return ACK_continue;
236 if (strstr(arg, "common"))
237 return ACK_common;
238 if (strstr(arg, "ready"))
239 return ACK_ready;
240 return ACK;
243 die(_("git fetch-pack: expected ACK/NAK, got '%s'"), line);
246 static void send_request(struct fetch_pack_args *args,
247 int fd, struct strbuf *buf)
249 if (args->stateless_rpc) {
250 send_sideband(fd, -1, buf->buf, buf->len, LARGE_PACKET_MAX);
251 packet_flush(fd);
252 } else
253 write_or_die(fd, buf->buf, buf->len);
256 static void insert_one_alternate_ref(const struct ref *ref, void *unused)
258 rev_list_insert_ref(NULL, ref->old_oid.hash);
261 #define INITIAL_FLUSH 16
262 #define PIPESAFE_FLUSH 32
263 #define LARGE_FLUSH 16384
265 static int next_flush(struct fetch_pack_args *args, int count)
267 if (args->stateless_rpc) {
268 if (count < LARGE_FLUSH)
269 count <<= 1;
270 else
271 count = count * 11 / 10;
272 } else {
273 if (count < PIPESAFE_FLUSH)
274 count <<= 1;
275 else
276 count += PIPESAFE_FLUSH;
278 return count;
281 static int find_common(struct fetch_pack_args *args,
282 int fd[2], unsigned char *result_sha1,
283 struct ref *refs)
285 int fetching;
286 int count = 0, flushes = 0, flush_at = INITIAL_FLUSH, retval;
287 const unsigned char *sha1;
288 unsigned in_vain = 0;
289 int got_continue = 0;
290 int got_ready = 0;
291 struct strbuf req_buf = STRBUF_INIT;
292 size_t state_len = 0;
294 if (args->stateless_rpc && multi_ack == 1)
295 die(_("--stateless-rpc requires multi_ack_detailed"));
296 if (marked)
297 for_each_ref(clear_marks, NULL);
298 marked = 1;
300 for_each_ref(rev_list_insert_ref_oid, NULL);
301 for_each_alternate_ref(insert_one_alternate_ref, NULL);
303 fetching = 0;
304 for ( ; refs ; refs = refs->next) {
305 unsigned char *remote = refs->old_oid.hash;
306 const char *remote_hex;
307 struct object *o;
310 * If that object is complete (i.e. it is an ancestor of a
311 * local ref), we tell them we have it but do not have to
312 * tell them about its ancestors, which they already know
313 * about.
315 * We use lookup_object here because we are only
316 * interested in the case we *know* the object is
317 * reachable and we have already scanned it.
319 if (((o = lookup_object(remote)) != NULL) &&
320 (o->flags & COMPLETE)) {
321 continue;
324 remote_hex = sha1_to_hex(remote);
325 if (!fetching) {
326 struct strbuf c = STRBUF_INIT;
327 if (multi_ack == 2) strbuf_addstr(&c, " multi_ack_detailed");
328 if (multi_ack == 1) strbuf_addstr(&c, " multi_ack");
329 if (no_done) strbuf_addstr(&c, " no-done");
330 if (use_sideband == 2) strbuf_addstr(&c, " side-band-64k");
331 if (use_sideband == 1) strbuf_addstr(&c, " side-band");
332 if (args->deepen_relative) strbuf_addstr(&c, " deepen-relative");
333 if (args->use_thin_pack) strbuf_addstr(&c, " thin-pack");
334 if (args->no_progress) strbuf_addstr(&c, " no-progress");
335 if (args->include_tag) strbuf_addstr(&c, " include-tag");
336 if (prefer_ofs_delta) strbuf_addstr(&c, " ofs-delta");
337 if (deepen_since_ok) strbuf_addstr(&c, " deepen-since");
338 if (deepen_not_ok) strbuf_addstr(&c, " deepen-not");
339 if (agent_supported) strbuf_addf(&c, " agent=%s",
340 git_user_agent_sanitized());
341 packet_buf_write(&req_buf, "want %s%s\n", remote_hex, c.buf);
342 strbuf_release(&c);
343 } else
344 packet_buf_write(&req_buf, "want %s\n", remote_hex);
345 fetching++;
348 if (!fetching) {
349 strbuf_release(&req_buf);
350 packet_flush(fd[1]);
351 return 1;
354 if (is_repository_shallow())
355 write_shallow_commits(&req_buf, 1, NULL);
356 if (args->depth > 0)
357 packet_buf_write(&req_buf, "deepen %d", args->depth);
358 if (args->deepen_since) {
359 unsigned long max_age = approxidate(args->deepen_since);
360 packet_buf_write(&req_buf, "deepen-since %lu", max_age);
362 if (args->deepen_not) {
363 int i;
364 for (i = 0; i < args->deepen_not->nr; i++) {
365 struct string_list_item *s = args->deepen_not->items + i;
366 packet_buf_write(&req_buf, "deepen-not %s", s->string);
369 packet_buf_flush(&req_buf);
370 state_len = req_buf.len;
372 if (args->deepen) {
373 char *line;
374 const char *arg;
375 unsigned char sha1[20];
377 send_request(args, fd[1], &req_buf);
378 while ((line = packet_read_line(fd[0], NULL))) {
379 if (skip_prefix(line, "shallow ", &arg)) {
380 if (get_sha1_hex(arg, sha1))
381 die(_("invalid shallow line: %s"), line);
382 register_shallow(sha1);
383 continue;
385 if (skip_prefix(line, "unshallow ", &arg)) {
386 if (get_sha1_hex(arg, sha1))
387 die(_("invalid unshallow line: %s"), line);
388 if (!lookup_object(sha1))
389 die(_("object not found: %s"), line);
390 /* make sure that it is parsed as shallow */
391 if (!parse_object(sha1))
392 die(_("error in object: %s"), line);
393 if (unregister_shallow(sha1))
394 die(_("no shallow found: %s"), line);
395 continue;
397 die(_("expected shallow/unshallow, got %s"), line);
399 } else if (!args->stateless_rpc)
400 send_request(args, fd[1], &req_buf);
402 if (!args->stateless_rpc) {
403 /* If we aren't using the stateless-rpc interface
404 * we don't need to retain the headers.
406 strbuf_setlen(&req_buf, 0);
407 state_len = 0;
410 flushes = 0;
411 retval = -1;
412 while ((sha1 = get_rev())) {
413 packet_buf_write(&req_buf, "have %s\n", sha1_to_hex(sha1));
414 print_verbose(args, "have %s", sha1_to_hex(sha1));
415 in_vain++;
416 if (flush_at <= ++count) {
417 int ack;
419 packet_buf_flush(&req_buf);
420 send_request(args, fd[1], &req_buf);
421 strbuf_setlen(&req_buf, state_len);
422 flushes++;
423 flush_at = next_flush(args, count);
426 * We keep one window "ahead" of the other side, and
427 * will wait for an ACK only on the next one
429 if (!args->stateless_rpc && count == INITIAL_FLUSH)
430 continue;
432 consume_shallow_list(args, fd[0]);
433 do {
434 ack = get_ack(fd[0], result_sha1);
435 if (ack)
436 print_verbose(args, _("got %s %d %s"), "ack",
437 ack, sha1_to_hex(result_sha1));
438 switch (ack) {
439 case ACK:
440 flushes = 0;
441 multi_ack = 0;
442 retval = 0;
443 goto done;
444 case ACK_common:
445 case ACK_ready:
446 case ACK_continue: {
447 struct commit *commit =
448 lookup_commit(result_sha1);
449 if (!commit)
450 die(_("invalid commit %s"), sha1_to_hex(result_sha1));
451 if (args->stateless_rpc
452 && ack == ACK_common
453 && !(commit->object.flags & COMMON)) {
454 /* We need to replay the have for this object
455 * on the next RPC request so the peer knows
456 * it is in common with us.
458 const char *hex = sha1_to_hex(result_sha1);
459 packet_buf_write(&req_buf, "have %s\n", hex);
460 state_len = req_buf.len;
462 * Reset in_vain because an ack
463 * for this commit has not been
464 * seen.
466 in_vain = 0;
467 } else if (!args->stateless_rpc
468 || ack != ACK_common)
469 in_vain = 0;
470 mark_common(commit, 0, 1);
471 retval = 0;
472 got_continue = 1;
473 if (ack == ACK_ready) {
474 clear_prio_queue(&rev_list);
475 got_ready = 1;
477 break;
480 } while (ack);
481 flushes--;
482 if (got_continue && MAX_IN_VAIN < in_vain) {
483 print_verbose(args, _("giving up"));
484 break; /* give up */
488 done:
489 if (!got_ready || !no_done) {
490 packet_buf_write(&req_buf, "done\n");
491 send_request(args, fd[1], &req_buf);
493 print_verbose(args, _("done"));
494 if (retval != 0) {
495 multi_ack = 0;
496 flushes++;
498 strbuf_release(&req_buf);
500 if (!got_ready || !no_done)
501 consume_shallow_list(args, fd[0]);
502 while (flushes || multi_ack) {
503 int ack = get_ack(fd[0], result_sha1);
504 if (ack) {
505 print_verbose(args, _("got %s (%d) %s"), "ack",
506 ack, sha1_to_hex(result_sha1));
507 if (ack == ACK)
508 return 0;
509 multi_ack = 1;
510 continue;
512 flushes--;
514 /* it is no error to fetch into a completely empty repo */
515 return count ? retval : 0;
518 static struct commit_list *complete;
520 static int mark_complete(const unsigned char *sha1)
522 struct object *o = parse_object(sha1);
524 while (o && o->type == OBJ_TAG) {
525 struct tag *t = (struct tag *) o;
526 if (!t->tagged)
527 break; /* broken repository */
528 o->flags |= COMPLETE;
529 o = parse_object(t->tagged->oid.hash);
531 if (o && o->type == OBJ_COMMIT) {
532 struct commit *commit = (struct commit *)o;
533 if (!(commit->object.flags & COMPLETE)) {
534 commit->object.flags |= COMPLETE;
535 commit_list_insert(commit, &complete);
538 return 0;
541 static int mark_complete_oid(const char *refname, const struct object_id *oid,
542 int flag, void *cb_data)
544 return mark_complete(oid->hash);
547 static void mark_recent_complete_commits(struct fetch_pack_args *args,
548 unsigned long cutoff)
550 while (complete && cutoff <= complete->item->date) {
551 print_verbose(args, _("Marking %s as complete"),
552 oid_to_hex(&complete->item->object.oid));
553 pop_most_recent_commit(&complete, COMPLETE);
557 static void filter_refs(struct fetch_pack_args *args,
558 struct ref **refs,
559 struct ref **sought, int nr_sought)
561 struct ref *newlist = NULL;
562 struct ref **newtail = &newlist;
563 struct ref *ref, *next;
564 int i;
566 i = 0;
567 for (ref = *refs; ref; ref = next) {
568 int keep = 0;
569 next = ref->next;
571 if (starts_with(ref->name, "refs/") &&
572 check_refname_format(ref->name, 0))
573 ; /* trash */
574 else {
575 while (i < nr_sought) {
576 int cmp = strcmp(ref->name, sought[i]->name);
577 if (cmp < 0)
578 break; /* definitely do not have it */
579 else if (cmp == 0) {
580 keep = 1; /* definitely have it */
581 sought[i]->matched = 1;
583 i++;
587 if (!keep && args->fetch_all &&
588 (!args->deepen || !starts_with(ref->name, "refs/tags/")))
589 keep = 1;
591 if (keep) {
592 *newtail = ref;
593 ref->next = NULL;
594 newtail = &ref->next;
595 } else {
596 free(ref);
600 /* Append unmatched requests to the list */
601 if ((allow_unadvertised_object_request &
602 (ALLOW_TIP_SHA1 | ALLOW_REACHABLE_SHA1))) {
603 for (i = 0; i < nr_sought; i++) {
604 unsigned char sha1[20];
606 ref = sought[i];
607 if (ref->matched)
608 continue;
609 if (get_sha1_hex(ref->name, sha1) ||
610 ref->name[40] != '\0' ||
611 hashcmp(sha1, ref->old_oid.hash))
612 continue;
614 ref->matched = 1;
615 *newtail = copy_ref(ref);
616 newtail = &(*newtail)->next;
619 *refs = newlist;
622 static void mark_alternate_complete(const struct ref *ref, void *unused)
624 mark_complete(ref->old_oid.hash);
627 static int everything_local(struct fetch_pack_args *args,
628 struct ref **refs,
629 struct ref **sought, int nr_sought)
631 struct ref *ref;
632 int retval;
633 unsigned long cutoff = 0;
635 save_commit_buffer = 0;
637 for (ref = *refs; ref; ref = ref->next) {
638 struct object *o;
640 if (!has_object_file(&ref->old_oid))
641 continue;
643 o = parse_object(ref->old_oid.hash);
644 if (!o)
645 continue;
647 /* We already have it -- which may mean that we were
648 * in sync with the other side at some time after
649 * that (it is OK if we guess wrong here).
651 if (o->type == OBJ_COMMIT) {
652 struct commit *commit = (struct commit *)o;
653 if (!cutoff || cutoff < commit->date)
654 cutoff = commit->date;
658 if (!args->deepen) {
659 for_each_ref(mark_complete_oid, NULL);
660 for_each_alternate_ref(mark_alternate_complete, NULL);
661 commit_list_sort_by_date(&complete);
662 if (cutoff)
663 mark_recent_complete_commits(args, cutoff);
667 * Mark all complete remote refs as common refs.
668 * Don't mark them common yet; the server has to be told so first.
670 for (ref = *refs; ref; ref = ref->next) {
671 struct object *o = deref_tag(lookup_object(ref->old_oid.hash),
672 NULL, 0);
674 if (!o || o->type != OBJ_COMMIT || !(o->flags & COMPLETE))
675 continue;
677 if (!(o->flags & SEEN)) {
678 rev_list_push((struct commit *)o, COMMON_REF | SEEN);
680 mark_common((struct commit *)o, 1, 1);
684 filter_refs(args, refs, sought, nr_sought);
686 for (retval = 1, ref = *refs; ref ; ref = ref->next) {
687 const unsigned char *remote = ref->old_oid.hash;
688 struct object *o;
690 o = lookup_object(remote);
691 if (!o || !(o->flags & COMPLETE)) {
692 retval = 0;
693 print_verbose(args, "want %s (%s)", sha1_to_hex(remote),
694 ref->name);
695 continue;
697 print_verbose(args, _("already have %s (%s)"), sha1_to_hex(remote),
698 ref->name);
700 return retval;
703 static int sideband_demux(int in, int out, void *data)
705 int *xd = data;
706 int ret;
708 ret = recv_sideband("fetch-pack", xd[0], out);
709 close(out);
710 return ret;
713 static int get_pack(struct fetch_pack_args *args,
714 int xd[2], char **pack_lockfile)
716 struct async demux;
717 int do_keep = args->keep_pack;
718 const char *cmd_name;
719 struct pack_header header;
720 int pass_header = 0;
721 struct child_process cmd = CHILD_PROCESS_INIT;
722 int ret;
724 memset(&demux, 0, sizeof(demux));
725 if (use_sideband) {
726 /* xd[] is talking with upload-pack; subprocess reads from
727 * xd[0], spits out band#2 to stderr, and feeds us band#1
728 * through demux->out.
730 demux.proc = sideband_demux;
731 demux.data = xd;
732 demux.out = -1;
733 demux.isolate_sigpipe = 1;
734 if (start_async(&demux))
735 die(_("fetch-pack: unable to fork off sideband demultiplexer"));
737 else
738 demux.out = xd[0];
740 if (!args->keep_pack && unpack_limit) {
742 if (read_pack_header(demux.out, &header))
743 die(_("protocol error: bad pack header"));
744 pass_header = 1;
745 if (ntohl(header.hdr_entries) < unpack_limit)
746 do_keep = 0;
747 else
748 do_keep = 1;
751 if (alternate_shallow_file) {
752 argv_array_push(&cmd.args, "--shallow-file");
753 argv_array_push(&cmd.args, alternate_shallow_file);
756 if (do_keep) {
757 if (pack_lockfile)
758 cmd.out = -1;
759 cmd_name = "index-pack";
760 argv_array_push(&cmd.args, cmd_name);
761 argv_array_push(&cmd.args, "--stdin");
762 if (!args->quiet && !args->no_progress)
763 argv_array_push(&cmd.args, "-v");
764 if (args->use_thin_pack)
765 argv_array_push(&cmd.args, "--fix-thin");
766 if (args->lock_pack || unpack_limit) {
767 char hostname[256];
768 if (gethostname(hostname, sizeof(hostname)))
769 xsnprintf(hostname, sizeof(hostname), "localhost");
770 argv_array_pushf(&cmd.args,
771 "--keep=fetch-pack %"PRIuMAX " on %s",
772 (uintmax_t)getpid(), hostname);
774 if (args->check_self_contained_and_connected)
775 argv_array_push(&cmd.args, "--check-self-contained-and-connected");
777 else {
778 cmd_name = "unpack-objects";
779 argv_array_push(&cmd.args, cmd_name);
780 if (args->quiet || args->no_progress)
781 argv_array_push(&cmd.args, "-q");
782 args->check_self_contained_and_connected = 0;
785 if (pass_header)
786 argv_array_pushf(&cmd.args, "--pack_header=%"PRIu32",%"PRIu32,
787 ntohl(header.hdr_version),
788 ntohl(header.hdr_entries));
789 if (fetch_fsck_objects >= 0
790 ? fetch_fsck_objects
791 : transfer_fsck_objects >= 0
792 ? transfer_fsck_objects
793 : 0)
794 argv_array_push(&cmd.args, "--strict");
796 cmd.in = demux.out;
797 cmd.git_cmd = 1;
798 if (start_command(&cmd))
799 die(_("fetch-pack: unable to fork off %s"), cmd_name);
800 if (do_keep && pack_lockfile) {
801 *pack_lockfile = index_pack_lockfile(cmd.out);
802 close(cmd.out);
805 if (!use_sideband)
806 /* Closed by start_command() */
807 xd[0] = -1;
809 ret = finish_command(&cmd);
810 if (!ret || (args->check_self_contained_and_connected && ret == 1))
811 args->self_contained_and_connected =
812 args->check_self_contained_and_connected &&
813 ret == 0;
814 else
815 die(_("%s failed"), cmd_name);
816 if (use_sideband && finish_async(&demux))
817 die(_("error in sideband demultiplexer"));
818 return 0;
821 static int cmp_ref_by_name(const void *a_, const void *b_)
823 const struct ref *a = *((const struct ref **)a_);
824 const struct ref *b = *((const struct ref **)b_);
825 return strcmp(a->name, b->name);
828 static struct ref *do_fetch_pack(struct fetch_pack_args *args,
829 int fd[2],
830 const struct ref *orig_ref,
831 struct ref **sought, int nr_sought,
832 struct shallow_info *si,
833 char **pack_lockfile)
835 struct ref *ref = copy_ref_list(orig_ref);
836 unsigned char sha1[20];
837 const char *agent_feature;
838 int agent_len;
840 sort_ref_list(&ref, ref_compare_name);
841 QSORT(sought, nr_sought, cmp_ref_by_name);
843 if ((args->depth > 0 || is_repository_shallow()) && !server_supports("shallow"))
844 die(_("Server does not support shallow clients"));
845 if (args->depth > 0 || args->deepen_since || args->deepen_not)
846 args->deepen = 1;
847 if (server_supports("multi_ack_detailed")) {
848 print_verbose(args, _("Server supports multi_ack_detailed"));
849 multi_ack = 2;
850 if (server_supports("no-done")) {
851 print_verbose(args, _("Server supports no-done"));
852 if (args->stateless_rpc)
853 no_done = 1;
856 else if (server_supports("multi_ack")) {
857 print_verbose(args, _("Server supports multi_ack"));
858 multi_ack = 1;
860 if (server_supports("side-band-64k")) {
861 print_verbose(args, _("Server supports side-band-64k"));
862 use_sideband = 2;
864 else if (server_supports("side-band")) {
865 print_verbose(args, _("Server supports side-band"));
866 use_sideband = 1;
868 if (server_supports("allow-tip-sha1-in-want")) {
869 print_verbose(args, _("Server supports allow-tip-sha1-in-want"));
870 allow_unadvertised_object_request |= ALLOW_TIP_SHA1;
872 if (server_supports("allow-reachable-sha1-in-want")) {
873 print_verbose(args, _("Server supports allow-reachable-sha1-in-want"));
874 allow_unadvertised_object_request |= ALLOW_REACHABLE_SHA1;
876 if (!server_supports("thin-pack"))
877 args->use_thin_pack = 0;
878 if (!server_supports("no-progress"))
879 args->no_progress = 0;
880 if (!server_supports("include-tag"))
881 args->include_tag = 0;
882 if (server_supports("ofs-delta"))
883 print_verbose(args, _("Server supports ofs-delta"));
884 else
885 prefer_ofs_delta = 0;
887 if ((agent_feature = server_feature_value("agent", &agent_len))) {
888 agent_supported = 1;
889 if (agent_len)
890 print_verbose(args, _("Server version is %.*s"),
891 agent_len, agent_feature);
893 if (server_supports("deepen-since"))
894 deepen_since_ok = 1;
895 else if (args->deepen_since)
896 die(_("Server does not support --shallow-since"));
897 if (server_supports("deepen-not"))
898 deepen_not_ok = 1;
899 else if (args->deepen_not)
900 die(_("Server does not support --shallow-exclude"));
901 if (!server_supports("deepen-relative") && args->deepen_relative)
902 die(_("Server does not support --deepen"));
904 if (everything_local(args, &ref, sought, nr_sought)) {
905 packet_flush(fd[1]);
906 goto all_done;
908 if (find_common(args, fd, sha1, ref) < 0)
909 if (!args->keep_pack)
910 /* When cloning, it is not unusual to have
911 * no common commit.
913 warning(_("no common commits"));
915 if (args->stateless_rpc)
916 packet_flush(fd[1]);
917 if (args->deepen)
918 setup_alternate_shallow(&shallow_lock, &alternate_shallow_file,
919 NULL);
920 else if (si->nr_ours || si->nr_theirs)
921 alternate_shallow_file = setup_temporary_shallow(si->shallow);
922 else
923 alternate_shallow_file = NULL;
924 if (get_pack(args, fd, pack_lockfile))
925 die(_("git fetch-pack: fetch failed."));
927 all_done:
928 return ref;
931 static void fetch_pack_config(void)
933 git_config_get_int("fetch.unpacklimit", &fetch_unpack_limit);
934 git_config_get_int("transfer.unpacklimit", &transfer_unpack_limit);
935 git_config_get_bool("repack.usedeltabaseoffset", &prefer_ofs_delta);
936 git_config_get_bool("fetch.fsckobjects", &fetch_fsck_objects);
937 git_config_get_bool("transfer.fsckobjects", &transfer_fsck_objects);
939 git_config(git_default_config, NULL);
942 static void fetch_pack_setup(void)
944 static int did_setup;
945 if (did_setup)
946 return;
947 fetch_pack_config();
948 if (0 <= transfer_unpack_limit)
949 unpack_limit = transfer_unpack_limit;
950 else if (0 <= fetch_unpack_limit)
951 unpack_limit = fetch_unpack_limit;
952 did_setup = 1;
955 static int remove_duplicates_in_refs(struct ref **ref, int nr)
957 struct string_list names = STRING_LIST_INIT_NODUP;
958 int src, dst;
960 for (src = dst = 0; src < nr; src++) {
961 struct string_list_item *item;
962 item = string_list_insert(&names, ref[src]->name);
963 if (item->util)
964 continue; /* already have it */
965 item->util = ref[src];
966 if (src != dst)
967 ref[dst] = ref[src];
968 dst++;
970 for (src = dst; src < nr; src++)
971 ref[src] = NULL;
972 string_list_clear(&names, 0);
973 return dst;
976 static void update_shallow(struct fetch_pack_args *args,
977 struct ref **sought, int nr_sought,
978 struct shallow_info *si)
980 struct sha1_array ref = SHA1_ARRAY_INIT;
981 int *status;
982 int i;
984 if (args->deepen && alternate_shallow_file) {
985 if (*alternate_shallow_file == '\0') { /* --unshallow */
986 unlink_or_warn(git_path_shallow());
987 rollback_lock_file(&shallow_lock);
988 } else
989 commit_lock_file(&shallow_lock);
990 return;
993 if (!si->shallow || !si->shallow->nr)
994 return;
996 if (args->cloning) {
998 * remote is shallow, but this is a clone, there are
999 * no objects in repo to worry about. Accept any
1000 * shallow points that exist in the pack (iow in repo
1001 * after get_pack() and reprepare_packed_git())
1003 struct sha1_array extra = SHA1_ARRAY_INIT;
1004 unsigned char (*sha1)[20] = si->shallow->sha1;
1005 for (i = 0; i < si->shallow->nr; i++)
1006 if (has_sha1_file(sha1[i]))
1007 sha1_array_append(&extra, sha1[i]);
1008 if (extra.nr) {
1009 setup_alternate_shallow(&shallow_lock,
1010 &alternate_shallow_file,
1011 &extra);
1012 commit_lock_file(&shallow_lock);
1014 sha1_array_clear(&extra);
1015 return;
1018 if (!si->nr_ours && !si->nr_theirs)
1019 return;
1021 remove_nonexistent_theirs_shallow(si);
1022 if (!si->nr_ours && !si->nr_theirs)
1023 return;
1024 for (i = 0; i < nr_sought; i++)
1025 sha1_array_append(&ref, sought[i]->old_oid.hash);
1026 si->ref = &ref;
1028 if (args->update_shallow) {
1030 * remote is also shallow, .git/shallow may be updated
1031 * so all refs can be accepted. Make sure we only add
1032 * shallow roots that are actually reachable from new
1033 * refs.
1035 struct sha1_array extra = SHA1_ARRAY_INIT;
1036 unsigned char (*sha1)[20] = si->shallow->sha1;
1037 assign_shallow_commits_to_refs(si, NULL, NULL);
1038 if (!si->nr_ours && !si->nr_theirs) {
1039 sha1_array_clear(&ref);
1040 return;
1042 for (i = 0; i < si->nr_ours; i++)
1043 sha1_array_append(&extra, sha1[si->ours[i]]);
1044 for (i = 0; i < si->nr_theirs; i++)
1045 sha1_array_append(&extra, sha1[si->theirs[i]]);
1046 setup_alternate_shallow(&shallow_lock,
1047 &alternate_shallow_file,
1048 &extra);
1049 commit_lock_file(&shallow_lock);
1050 sha1_array_clear(&extra);
1051 sha1_array_clear(&ref);
1052 return;
1056 * remote is also shallow, check what ref is safe to update
1057 * without updating .git/shallow
1059 status = xcalloc(nr_sought, sizeof(*status));
1060 assign_shallow_commits_to_refs(si, NULL, status);
1061 if (si->nr_ours || si->nr_theirs) {
1062 for (i = 0; i < nr_sought; i++)
1063 if (status[i])
1064 sought[i]->status = REF_STATUS_REJECT_SHALLOW;
1066 free(status);
1067 sha1_array_clear(&ref);
1070 struct ref *fetch_pack(struct fetch_pack_args *args,
1071 int fd[], struct child_process *conn,
1072 const struct ref *ref,
1073 const char *dest,
1074 struct ref **sought, int nr_sought,
1075 struct sha1_array *shallow,
1076 char **pack_lockfile)
1078 struct ref *ref_cpy;
1079 struct shallow_info si;
1081 fetch_pack_setup();
1082 if (nr_sought)
1083 nr_sought = remove_duplicates_in_refs(sought, nr_sought);
1085 if (!ref) {
1086 packet_flush(fd[1]);
1087 die(_("no matching remote head"));
1089 prepare_shallow_info(&si, shallow);
1090 ref_cpy = do_fetch_pack(args, fd, ref, sought, nr_sought,
1091 &si, pack_lockfile);
1092 reprepare_packed_git();
1093 update_shallow(args, sought, nr_sought, &si);
1094 clear_shallow_info(&si);
1095 return ref_cpy;