fetch-pack: don't try to fetch peel values with --all
[git/git.git] / fetch-pack.c
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"
18
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;
31
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)
38
39 static int marked;
40
41 /*
42 * After sending this many "have"s if we do not get any new ACK , we
43 * give up traversing our history.
44 */
45 #define MAX_IN_VAIN 256
46
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;
54
55 __attribute__((format (printf, 2, 3)))
56 static inline void print_verbose(const struct fetch_pack_args *args,
57 const char *fmt, ...)
58 {
59 va_list params;
60
61 if (!args->verbose)
62 return;
63
64 va_start(params, fmt);
65 vfprintf(stderr, fmt, params);
66 va_end(params);
67 fputc('\n', stderr);
68 }
69
70 static void rev_list_push(struct commit *commit, int mark)
71 {
72 if (!(commit->object.flags & mark)) {
73 commit->object.flags |= mark;
74
75 if (parse_commit(commit))
76 return;
77
78 prio_queue_put(&rev_list, commit);
79
80 if (!(commit->object.flags & COMMON))
81 non_common_revs++;
82 }
83 }
84
85 static int rev_list_insert_ref(const char *refname, const unsigned char *sha1)
86 {
87 struct object *o = deref_tag(parse_object(sha1), refname, 0);
88
89 if (o && o->type == OBJ_COMMIT)
90 rev_list_push((struct commit *)o, SEEN);
91
92 return 0;
93 }
94
95 static int rev_list_insert_ref_oid(const char *refname, const struct object_id *oid,
96 int flag, void *cb_data)
97 {
98 return rev_list_insert_ref(refname, oid->hash);
99 }
100
101 static int clear_marks(const char *refname, const struct object_id *oid,
102 int flag, void *cb_data)
103 {
104 struct object *o = deref_tag(parse_object(oid->hash), refname, 0);
105
106 if (o && o->type == OBJ_COMMIT)
107 clear_commit_marks((struct commit *)o,
108 COMMON | COMMON_REF | SEEN | POPPED);
109 return 0;
110 }
111
112 /*
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).
116 */
117
118 static void mark_common(struct commit *commit,
119 int ancestors_only, int dont_parse)
120 {
121 if (commit != NULL && !(commit->object.flags & COMMON)) {
122 struct object *o = (struct object *)commit;
123
124 if (!ancestors_only)
125 o->flags |= COMMON;
126
127 if (!(o->flags & SEEN))
128 rev_list_push(commit, SEEN);
129 else {
130 struct commit_list *parents;
131
132 if (!ancestors_only && !(o->flags & POPPED))
133 non_common_revs--;
134 if (!o->parsed && !dont_parse)
135 if (parse_commit(commit))
136 return;
137
138 for (parents = commit->parents;
139 parents;
140 parents = parents->next)
141 mark_common(parents->item, 0, dont_parse);
142 }
143 }
144 }
145
146 /*
147 Get the next rev to send, ignoring the common.
148 */
149
150 static const unsigned char *get_rev(void)
151 {
152 struct commit *commit = NULL;
153
154 while (commit == NULL) {
155 unsigned int mark;
156 struct commit_list *parents;
157
158 if (rev_list.nr == 0 || non_common_revs == 0)
159 return NULL;
160
161 commit = prio_queue_get(&rev_list);
162 parse_commit(commit);
163 parents = commit->parents;
164
165 commit->object.flags |= POPPED;
166 if (!(commit->object.flags & COMMON))
167 non_common_revs--;
168
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;
179
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;
186 }
187 }
188
189 return commit->object.oid.hash;
190 }
191
192 enum ack_type {
193 NAK = 0,
194 ACK,
195 ACK_continue,
196 ACK_common,
197 ACK_ready
198 };
199
200 static void consume_shallow_list(struct fetch_pack_args *args, int fd)
201 {
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.
206 */
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"));
214 }
215 }
216 }
217
218 static enum ack_type get_ack(int fd, unsigned char *result_sha1)
219 {
220 int len;
221 char *line = packet_read_line(fd, &len);
222 const char *arg;
223
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;
241 }
242 }
243 die(_("git fetch-pack: expected ACK/NAK, got '%s'"), line);
244 }
245
246 static void send_request(struct fetch_pack_args *args,
247 int fd, struct strbuf *buf)
248 {
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);
254 }
255
256 static void insert_one_alternate_ref(const struct ref *ref, void *unused)
257 {
258 rev_list_insert_ref(NULL, ref->old_oid.hash);
259 }
260
261 #define INITIAL_FLUSH 16
262 #define PIPESAFE_FLUSH 32
263 #define LARGE_FLUSH 16384
264
265 static int next_flush(struct fetch_pack_args *args, int count)
266 {
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;
277 }
278 return count;
279 }
280
281 static int find_common(struct fetch_pack_args *args,
282 int fd[2], unsigned char *result_sha1,
283 struct ref *refs)
284 {
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;
293
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;
299
300 for_each_ref(rev_list_insert_ref_oid, NULL);
301 for_each_alternate_ref(insert_one_alternate_ref, NULL);
302
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;
308
309 /*
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.
314 *
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.
318 */
319 if (((o = lookup_object(remote)) != NULL) &&
320 (o->flags & COMPLETE)) {
321 continue;
322 }
323
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++;
346 }
347
348 if (!fetching) {
349 strbuf_release(&req_buf);
350 packet_flush(fd[1]);
351 return 1;
352 }
353
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);
361 }
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);
367 }
368 }
369 packet_buf_flush(&req_buf);
370 state_len = req_buf.len;
371
372 if (args->deepen) {
373 char *line;
374 const char *arg;
375 unsigned char sha1[20];
376
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;
384 }
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;
396 }
397 die(_("expected shallow/unshallow, got %s"), line);
398 }
399 } else if (!args->stateless_rpc)
400 send_request(args, fd[1], &req_buf);
401
402 if (!args->stateless_rpc) {
403 /* If we aren't using the stateless-rpc interface
404 * we don't need to retain the headers.
405 */
406 strbuf_setlen(&req_buf, 0);
407 state_len = 0;
408 }
409
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;
418
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);
424
425 /*
426 * We keep one window "ahead" of the other side, and
427 * will wait for an ACK only on the next one
428 */
429 if (!args->stateless_rpc && count == INITIAL_FLUSH)
430 continue;
431
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.
457 */
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;
461 /*
462 * Reset in_vain because an ack
463 * for this commit has not been
464 * seen.
465 */
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;
476 }
477 break;
478 }
479 }
480 } while (ack);
481 flushes--;
482 if (got_continue && MAX_IN_VAIN < in_vain) {
483 print_verbose(args, _("giving up"));
484 break; /* give up */
485 }
486 }
487 }
488 done:
489 if (!got_ready || !no_done) {
490 packet_buf_write(&req_buf, "done\n");
491 send_request(args, fd[1], &req_buf);
492 }
493 print_verbose(args, _("done"));
494 if (retval != 0) {
495 multi_ack = 0;
496 flushes++;
497 }
498 strbuf_release(&req_buf);
499
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;
511 }
512 flushes--;
513 }
514 /* it is no error to fetch into a completely empty repo */
515 return count ? retval : 0;
516 }
517
518 static struct commit_list *complete;
519
520 static int mark_complete(const unsigned char *sha1)
521 {
522 struct object *o = parse_object(sha1);
523
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);
530 }
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);
536 }
537 }
538 return 0;
539 }
540
541 static int mark_complete_oid(const char *refname, const struct object_id *oid,
542 int flag, void *cb_data)
543 {
544 return mark_complete(oid->hash);
545 }
546
547 static void mark_recent_complete_commits(struct fetch_pack_args *args,
548 unsigned long cutoff)
549 {
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);
554 }
555 }
556
557 static void filter_refs(struct fetch_pack_args *args,
558 struct ref **refs,
559 struct ref **sought, int nr_sought)
560 {
561 struct ref *newlist = NULL;
562 struct ref **newtail = &newlist;
563 struct ref *ref, *next;
564 int i;
565
566 i = 0;
567 for (ref = *refs; ref; ref = next) {
568 int keep = 0;
569 next = ref->next;
570
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;
582 }
583 i++;
584 }
585
586 if (!keep && args->fetch_all &&
587 (!args->deepen || !starts_with(ref->name, "refs/tags/")))
588 keep = 1;
589 }
590
591 if (keep) {
592 *newtail = ref;
593 ref->next = NULL;
594 newtail = &ref->next;
595 } else {
596 free(ref);
597 }
598 }
599
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];
605
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;
613
614 ref->matched = 1;
615 *newtail = copy_ref(ref);
616 newtail = &(*newtail)->next;
617 }
618 }
619 *refs = newlist;
620 }
621
622 static void mark_alternate_complete(const struct ref *ref, void *unused)
623 {
624 mark_complete(ref->old_oid.hash);
625 }
626
627 static int everything_local(struct fetch_pack_args *args,
628 struct ref **refs,
629 struct ref **sought, int nr_sought)
630 {
631 struct ref *ref;
632 int retval;
633 unsigned long cutoff = 0;
634
635 save_commit_buffer = 0;
636
637 for (ref = *refs; ref; ref = ref->next) {
638 struct object *o;
639
640 if (!has_object_file(&ref->old_oid))
641 continue;
642
643 o = parse_object(ref->old_oid.hash);
644 if (!o)
645 continue;
646
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).
650 */
651 if (o->type == OBJ_COMMIT) {
652 struct commit *commit = (struct commit *)o;
653 if (!cutoff || cutoff < commit->date)
654 cutoff = commit->date;
655 }
656 }
657
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);
664 }
665
666 /*
667 * Mark all complete remote refs as common refs.
668 * Don't mark them common yet; the server has to be told so first.
669 */
670 for (ref = *refs; ref; ref = ref->next) {
671 struct object *o = deref_tag(lookup_object(ref->old_oid.hash),
672 NULL, 0);
673
674 if (!o || o->type != OBJ_COMMIT || !(o->flags & COMPLETE))
675 continue;
676
677 if (!(o->flags & SEEN)) {
678 rev_list_push((struct commit *)o, COMMON_REF | SEEN);
679
680 mark_common((struct commit *)o, 1, 1);
681 }
682 }
683
684 filter_refs(args, refs, sought, nr_sought);
685
686 for (retval = 1, ref = *refs; ref ; ref = ref->next) {
687 const unsigned char *remote = ref->old_oid.hash;
688 struct object *o;
689
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;
696 }
697 print_verbose(args, _("already have %s (%s)"), sha1_to_hex(remote),
698 ref->name);
699 }
700 return retval;
701 }
702
703 static int sideband_demux(int in, int out, void *data)
704 {
705 int *xd = data;
706 int ret;
707
708 ret = recv_sideband("fetch-pack", xd[0], out);
709 close(out);
710 return ret;
711 }
712
713 static int get_pack(struct fetch_pack_args *args,
714 int xd[2], char **pack_lockfile)
715 {
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;
723
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.
729 */
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"));
736 }
737 else
738 demux.out = xd[0];
739
740 if (!args->keep_pack && unpack_limit) {
741
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;
749 }
750
751 if (alternate_shallow_file) {
752 argv_array_push(&cmd.args, "--shallow-file");
753 argv_array_push(&cmd.args, alternate_shallow_file);
754 }
755
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);
773 }
774 if (args->check_self_contained_and_connected)
775 argv_array_push(&cmd.args, "--check-self-contained-and-connected");
776 }
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;
783 }
784
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");
795
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);
803 }
804
805 if (!use_sideband)
806 /* Closed by start_command() */
807 xd[0] = -1;
808
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;
819 }
820
821 static int cmp_ref_by_name(const void *a_, const void *b_)
822 {
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);
826 }
827
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)
834 {
835 struct ref *ref = copy_ref_list(orig_ref);
836 unsigned char sha1[20];
837 const char *agent_feature;
838 int agent_len;
839
840 sort_ref_list(&ref, ref_compare_name);
841 QSORT(sought, nr_sought, cmp_ref_by_name);
842
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;
854 }
855 }
856 else if (server_supports("multi_ack")) {
857 print_verbose(args, _("Server supports multi_ack"));
858 multi_ack = 1;
859 }
860 if (server_supports("side-band-64k")) {
861 print_verbose(args, _("Server supports side-band-64k"));
862 use_sideband = 2;
863 }
864 else if (server_supports("side-band")) {
865 print_verbose(args, _("Server supports side-band"));
866 use_sideband = 1;
867 }
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;
871 }
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;
875 }
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;
886
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);
892 }
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"));
903
904 if (everything_local(args, &ref, sought, nr_sought)) {
905 packet_flush(fd[1]);
906 goto all_done;
907 }
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.
912 */
913 warning(_("no common commits"));
914
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."));
926
927 all_done:
928 return ref;
929 }
930
931 static void fetch_pack_config(void)
932 {
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);
938
939 git_config(git_default_config, NULL);
940 }
941
942 static void fetch_pack_setup(void)
943 {
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;
953 }
954
955 static int remove_duplicates_in_refs(struct ref **ref, int nr)
956 {
957 struct string_list names = STRING_LIST_INIT_NODUP;
958 int src, dst;
959
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++;
969 }
970 for (src = dst; src < nr; src++)
971 ref[src] = NULL;
972 string_list_clear(&names, 0);
973 return dst;
974 }
975
976 static void update_shallow(struct fetch_pack_args *args,
977 struct ref **sought, int nr_sought,
978 struct shallow_info *si)
979 {
980 struct sha1_array ref = SHA1_ARRAY_INIT;
981 int *status;
982 int i;
983
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;
991 }
992
993 if (!si->shallow || !si->shallow->nr)
994 return;
995
996 if (args->cloning) {
997 /*
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())
1002 */
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);
1013 }
1014 sha1_array_clear(&extra);
1015 return;
1016 }
1017
1018 if (!si->nr_ours && !si->nr_theirs)
1019 return;
1020
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;
1027
1028 if (args->update_shallow) {
1029 /*
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.
1034 */
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;
1041 }
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;
1053 }
1054
1055 /*
1056 * remote is also shallow, check what ref is safe to update
1057 * without updating .git/shallow
1058 */
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;
1065 }
1066 free(status);
1067 sha1_array_clear(&ref);
1068 }
1069
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)
1077 {
1078 struct ref *ref_cpy;
1079 struct shallow_info si;
1080
1081 fetch_pack_setup();
1082 if (nr_sought)
1083 nr_sought = remove_duplicates_in_refs(sought, nr_sought);
1084
1085 if (!ref) {
1086 packet_flush(fd[1]);
1087 die(_("no matching remote head"));
1088 }
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;
1096 }