1#include "cache.h"
2#include "config.h"
3#include "lockfile.h"
4#include "refs.h"
5#include "pkt-line.h"
6#include "commit.h"
7#include "tag.h"
8#include "exec_cmd.h"
9#include "pack.h"
10#include "sideband.h"
11#include "fetch-pack.h"
12#include "remote.h"
13#include "run-command.h"
14#include "connect.h"
15#include "transport.h"
16#include "version.h"
17#include "prio-queue.h"
18#include "sha1-array.h"
19
20static int transfer_unpack_limit = -1;
21static int fetch_unpack_limit = -1;
22static int unpack_limit = 100;
23static int prefer_ofs_delta = 1;
24static int no_done;
25static int deepen_since_ok;
26static int deepen_not_ok;
27static int fetch_fsck_objects = -1;
28static int transfer_fsck_objects = -1;
29static int agent_supported;
30static struct lock_file shallow_lock;
31static const char *alternate_shallow_file;
32
33/* Remember to update object flag allocation in object.h */
34#define COMPLETE (1U << 0)
35#define COMMON (1U << 1)
36#define COMMON_REF (1U << 2)
37#define SEEN (1U << 3)
38#define POPPED (1U << 4)
39#define ALTERNATE (1U << 5)
40
41static int marked;
42
43/*
44 * After sending this many "have"s if we do not get any new ACK , we
45 * give up traversing our history.
46 */
47#define MAX_IN_VAIN 256
48
49static struct prio_queue rev_list = { compare_commits_by_commit_date };
50static int non_common_revs, multi_ack, use_sideband;
51/* Allow specifying sha1 if it is a ref tip. */
52#define ALLOW_TIP_SHA1 01
53/* Allow request of a sha1 if it is reachable from a ref (possibly hidden ref). */
54#define ALLOW_REACHABLE_SHA1 02
55static unsigned int allow_unadvertised_object_request;
56
57__attribute__((format (printf, 2, 3)))
58static inline void print_verbose(const struct fetch_pack_args *args,
59 const char *fmt, ...)
60{
61 va_list params;
62
63 if (!args->verbose)
64 return;
65
66 va_start(params, fmt);
67 vfprintf(stderr, fmt, params);
68 va_end(params);
69 fputc('\n', stderr);
70}
71
72struct alternate_object_cache {
73 struct object **items;
74 size_t nr, alloc;
75};
76
77static void cache_one_alternate(const char *refname,
78 const struct object_id *oid,
79 void *vcache)
80{
81 struct alternate_object_cache *cache = vcache;
82 struct object *obj = parse_object(oid->hash);
83
84 if (!obj || (obj->flags & ALTERNATE))
85 return;
86
87 obj->flags |= ALTERNATE;
88 ALLOC_GROW(cache->items, cache->nr + 1, cache->alloc);
89 cache->items[cache->nr++] = obj;
90}
91
92static void for_each_cached_alternate(void (*cb)(struct object *))
93{
94 static int initialized;
95 static struct alternate_object_cache cache;
96 size_t i;
97
98 if (!initialized) {
99 for_each_alternate_ref(cache_one_alternate, &cache);
100 initialized = 1;
101 }
102
103 for (i = 0; i < cache.nr; i++)
104 cb(cache.items[i]);
105}
106
107static void rev_list_push(struct commit *commit, int mark)
108{
109 if (!(commit->object.flags & mark)) {
110 commit->object.flags |= mark;
111
112 if (parse_commit(commit))
113 return;
114
115 prio_queue_put(&rev_list, commit);
116
117 if (!(commit->object.flags & COMMON))
118 non_common_revs++;
119 }
120}
121
122static int rev_list_insert_ref(const char *refname, const unsigned char *sha1)
123{
124 struct object *o = deref_tag(parse_object(sha1), refname, 0);
125
126 if (o && o->type == OBJ_COMMIT)
127 rev_list_push((struct commit *)o, SEEN);
128
129 return 0;
130}
131
132static int rev_list_insert_ref_oid(const char *refname, const struct object_id *oid,
133 int flag, void *cb_data)
134{
135 return rev_list_insert_ref(refname, oid->hash);
136}
137
138static int clear_marks(const char *refname, const struct object_id *oid,
139 int flag, void *cb_data)
140{
141 struct object *o = deref_tag(parse_object(oid->hash), refname, 0);
142
143 if (o && o->type == OBJ_COMMIT)
144 clear_commit_marks((struct commit *)o,
145 COMMON | COMMON_REF | SEEN | POPPED);
146 return 0;
147}
148
149/*
150 This function marks a rev and its ancestors as common.
151 In some cases, it is desirable to mark only the ancestors (for example
152 when only the server does not yet know that they are common).
153*/
154
155static void mark_common(struct commit *commit,
156 int ancestors_only, int dont_parse)
157{
158 if (commit != NULL && !(commit->object.flags & COMMON)) {
159 struct object *o = (struct object *)commit;
160
161 if (!ancestors_only)
162 o->flags |= COMMON;
163
164 if (!(o->flags & SEEN))
165 rev_list_push(commit, SEEN);
166 else {
167 struct commit_list *parents;
168
169 if (!ancestors_only && !(o->flags & POPPED))
170 non_common_revs--;
171 if (!o->parsed && !dont_parse)
172 if (parse_commit(commit))
173 return;
174
175 for (parents = commit->parents;
176 parents;
177 parents = parents->next)
178 mark_common(parents->item, 0, dont_parse);
179 }
180 }
181}
182
183/*
184 Get the next rev to send, ignoring the common.
185*/
186
187static const unsigned char *get_rev(void)
188{
189 struct commit *commit = NULL;
190
191 while (commit == NULL) {
192 unsigned int mark;
193 struct commit_list *parents;
194
195 if (rev_list.nr == 0 || non_common_revs == 0)
196 return NULL;
197
198 commit = prio_queue_get(&rev_list);
199 parse_commit(commit);
200 parents = commit->parents;
201
202 commit->object.flags |= POPPED;
203 if (!(commit->object.flags & COMMON))
204 non_common_revs--;
205
206 if (commit->object.flags & COMMON) {
207 /* do not send "have", and ignore ancestors */
208 commit = NULL;
209 mark = COMMON | SEEN;
210 } else if (commit->object.flags & COMMON_REF)
211 /* send "have", and ignore ancestors */
212 mark = COMMON | SEEN;
213 else
214 /* send "have", also for its ancestors */
215 mark = SEEN;
216
217 while (parents) {
218 if (!(parents->item->object.flags & SEEN))
219 rev_list_push(parents->item, mark);
220 if (mark & COMMON)
221 mark_common(parents->item, 1, 0);
222 parents = parents->next;
223 }
224 }
225
226 return commit->object.oid.hash;
227}
228
229enum ack_type {
230 NAK = 0,
231 ACK,
232 ACK_continue,
233 ACK_common,
234 ACK_ready
235};
236
237static void consume_shallow_list(struct fetch_pack_args *args, int fd)
238{
239 if (args->stateless_rpc && args->deepen) {
240 /* If we sent a depth we will get back "duplicate"
241 * shallow and unshallow commands every time there
242 * is a block of have lines exchanged.
243 */
244 char *line;
245 while ((line = packet_read_line(fd, NULL))) {
246 if (starts_with(line, "shallow "))
247 continue;
248 if (starts_with(line, "unshallow "))
249 continue;
250 die(_("git fetch-pack: expected shallow list"));
251 }
252 }
253}
254
255static enum ack_type get_ack(int fd, unsigned char *result_sha1)
256{
257 int len;
258 char *line = packet_read_line(fd, &len);
259 const char *arg;
260
261 if (!len)
262 die(_("git fetch-pack: expected ACK/NAK, got EOF"));
263 if (!strcmp(line, "NAK"))
264 return NAK;
265 if (skip_prefix(line, "ACK ", &arg)) {
266 if (!get_sha1_hex(arg, result_sha1)) {
267 arg += 40;
268 len -= arg - line;
269 if (len < 1)
270 return ACK;
271 if (strstr(arg, "continue"))
272 return ACK_continue;
273 if (strstr(arg, "common"))
274 return ACK_common;
275 if (strstr(arg, "ready"))
276 return ACK_ready;
277 return ACK;
278 }
279 }
280 if (skip_prefix(line, "ERR ", &arg))
281 die(_("remote error: %s"), arg);
282 die(_("git fetch-pack: expected ACK/NAK, got '%s'"), line);
283}
284
285static void send_request(struct fetch_pack_args *args,
286 int fd, struct strbuf *buf)
287{
288 if (args->stateless_rpc) {
289 send_sideband(fd, -1, buf->buf, buf->len, LARGE_PACKET_MAX);
290 packet_flush(fd);
291 } else
292 write_or_die(fd, buf->buf, buf->len);
293}
294
295static void insert_one_alternate_object(struct object *obj)
296{
297 rev_list_insert_ref(NULL, obj->oid.hash);
298}
299
300#define INITIAL_FLUSH 16
301#define PIPESAFE_FLUSH 32
302#define LARGE_FLUSH 16384
303
304static int next_flush(struct fetch_pack_args *args, int count)
305{
306 if (args->stateless_rpc) {
307 if (count < LARGE_FLUSH)
308 count <<= 1;
309 else
310 count = count * 11 / 10;
311 } else {
312 if (count < PIPESAFE_FLUSH)
313 count <<= 1;
314 else
315 count += PIPESAFE_FLUSH;
316 }
317 return count;
318}
319
320static int find_common(struct fetch_pack_args *args,
321 int fd[2], unsigned char *result_sha1,
322 struct ref *refs)
323{
324 int fetching;
325 int count = 0, flushes = 0, flush_at = INITIAL_FLUSH, retval;
326 const unsigned char *sha1;
327 unsigned in_vain = 0;
328 int got_continue = 0;
329 int got_ready = 0;
330 struct strbuf req_buf = STRBUF_INIT;
331 size_t state_len = 0;
332
333 if (args->stateless_rpc && multi_ack == 1)
334 die(_("--stateless-rpc requires multi_ack_detailed"));
335 if (marked)
336 for_each_ref(clear_marks, NULL);
337 marked = 1;
338
339 for_each_ref(rev_list_insert_ref_oid, NULL);
340 for_each_cached_alternate(insert_one_alternate_object);
341
342 fetching = 0;
343 for ( ; refs ; refs = refs->next) {
344 unsigned char *remote = refs->old_oid.hash;
345 const char *remote_hex;
346 struct object *o;
347
348 /*
349 * If that object is complete (i.e. it is an ancestor of a
350 * local ref), we tell them we have it but do not have to
351 * tell them about its ancestors, which they already know
352 * about.
353 *
354 * We use lookup_object here because we are only
355 * interested in the case we *know* the object is
356 * reachable and we have already scanned it.
357 */
358 if (((o = lookup_object(remote)) != NULL) &&
359 (o->flags & COMPLETE)) {
360 continue;
361 }
362
363 remote_hex = sha1_to_hex(remote);
364 if (!fetching) {
365 struct strbuf c = STRBUF_INIT;
366 if (multi_ack == 2) strbuf_addstr(&c, " multi_ack_detailed");
367 if (multi_ack == 1) strbuf_addstr(&c, " multi_ack");
368 if (no_done) strbuf_addstr(&c, " no-done");
369 if (use_sideband == 2) strbuf_addstr(&c, " side-band-64k");
370 if (use_sideband == 1) strbuf_addstr(&c, " side-band");
371 if (args->deepen_relative) strbuf_addstr(&c, " deepen-relative");
372 if (args->use_thin_pack) strbuf_addstr(&c, " thin-pack");
373 if (args->no_progress) strbuf_addstr(&c, " no-progress");
374 if (args->include_tag) strbuf_addstr(&c, " include-tag");
375 if (prefer_ofs_delta) strbuf_addstr(&c, " ofs-delta");
376 if (deepen_since_ok) strbuf_addstr(&c, " deepen-since");
377 if (deepen_not_ok) strbuf_addstr(&c, " deepen-not");
378 if (agent_supported) strbuf_addf(&c, " agent=%s",
379 git_user_agent_sanitized());
380 packet_buf_write(&req_buf, "want %s%s\n", remote_hex, c.buf);
381 strbuf_release(&c);
382 } else
383 packet_buf_write(&req_buf, "want %s\n", remote_hex);
384 fetching++;
385 }
386
387 if (!fetching) {
388 strbuf_release(&req_buf);
389 packet_flush(fd[1]);
390 return 1;
391 }
392
393 if (is_repository_shallow())
394 write_shallow_commits(&req_buf, 1, NULL);
395 if (args->depth > 0)
396 packet_buf_write(&req_buf, "deepen %d", args->depth);
397 if (args->deepen_since) {
398 unsigned long max_age = approxidate(args->deepen_since);
399 packet_buf_write(&req_buf, "deepen-since %lu", max_age);
400 }
401 if (args->deepen_not) {
402 int i;
403 for (i = 0; i < args->deepen_not->nr; i++) {
404 struct string_list_item *s = args->deepen_not->items + i;
405 packet_buf_write(&req_buf, "deepen-not %s", s->string);
406 }
407 }
408 packet_buf_flush(&req_buf);
409 state_len = req_buf.len;
410
411 if (args->deepen) {
412 char *line;
413 const char *arg;
414 unsigned char sha1[20];
415
416 send_request(args, fd[1], &req_buf);
417 while ((line = packet_read_line(fd[0], NULL))) {
418 if (skip_prefix(line, "shallow ", &arg)) {
419 if (get_sha1_hex(arg, sha1))
420 die(_("invalid shallow line: %s"), line);
421 register_shallow(sha1);
422 continue;
423 }
424 if (skip_prefix(line, "unshallow ", &arg)) {
425 if (get_sha1_hex(arg, sha1))
426 die(_("invalid unshallow line: %s"), line);
427 if (!lookup_object(sha1))
428 die(_("object not found: %s"), line);
429 /* make sure that it is parsed as shallow */
430 if (!parse_object(sha1))
431 die(_("error in object: %s"), line);
432 if (unregister_shallow(sha1))
433 die(_("no shallow found: %s"), line);
434 continue;
435 }
436 die(_("expected shallow/unshallow, got %s"), line);
437 }
438 } else if (!args->stateless_rpc)
439 send_request(args, fd[1], &req_buf);
440
441 if (!args->stateless_rpc) {
442 /* If we aren't using the stateless-rpc interface
443 * we don't need to retain the headers.
444 */
445 strbuf_setlen(&req_buf, 0);
446 state_len = 0;
447 }
448
449 flushes = 0;
450 retval = -1;
451 while ((sha1 = get_rev())) {
452 packet_buf_write(&req_buf, "have %s\n", sha1_to_hex(sha1));
453 print_verbose(args, "have %s", sha1_to_hex(sha1));
454 in_vain++;
455 if (flush_at <= ++count) {
456 int ack;
457
458 packet_buf_flush(&req_buf);
459 send_request(args, fd[1], &req_buf);
460 strbuf_setlen(&req_buf, state_len);
461 flushes++;
462 flush_at = next_flush(args, count);
463
464 /*
465 * We keep one window "ahead" of the other side, and
466 * will wait for an ACK only on the next one
467 */
468 if (!args->stateless_rpc && count == INITIAL_FLUSH)
469 continue;
470
471 consume_shallow_list(args, fd[0]);
472 do {
473 ack = get_ack(fd[0], result_sha1);
474 if (ack)
475 print_verbose(args, _("got %s %d %s"), "ack",
476 ack, sha1_to_hex(result_sha1));
477 switch (ack) {
478 case ACK:
479 flushes = 0;
480 multi_ack = 0;
481 retval = 0;
482 goto done;
483 case ACK_common:
484 case ACK_ready:
485 case ACK_continue: {
486 struct commit *commit =
487 lookup_commit(result_sha1);
488 if (!commit)
489 die(_("invalid commit %s"), sha1_to_hex(result_sha1));
490 if (args->stateless_rpc
491 && ack == ACK_common
492 && !(commit->object.flags & COMMON)) {
493 /* We need to replay the have for this object
494 * on the next RPC request so the peer knows
495 * it is in common with us.
496 */
497 const char *hex = sha1_to_hex(result_sha1);
498 packet_buf_write(&req_buf, "have %s\n", hex);
499 state_len = req_buf.len;
500 /*
501 * Reset in_vain because an ack
502 * for this commit has not been
503 * seen.
504 */
505 in_vain = 0;
506 } else if (!args->stateless_rpc
507 || ack != ACK_common)
508 in_vain = 0;
509 mark_common(commit, 0, 1);
510 retval = 0;
511 got_continue = 1;
512 if (ack == ACK_ready) {
513 clear_prio_queue(&rev_list);
514 got_ready = 1;
515 }
516 break;
517 }
518 }
519 } while (ack);
520 flushes--;
521 if (got_continue && MAX_IN_VAIN < in_vain) {
522 print_verbose(args, _("giving up"));
523 break; /* give up */
524 }
525 }
526 }
527done:
528 if (!got_ready || !no_done) {
529 packet_buf_write(&req_buf, "done\n");
530 send_request(args, fd[1], &req_buf);
531 }
532 print_verbose(args, _("done"));
533 if (retval != 0) {
534 multi_ack = 0;
535 flushes++;
536 }
537 strbuf_release(&req_buf);
538
539 if (!got_ready || !no_done)
540 consume_shallow_list(args, fd[0]);
541 while (flushes || multi_ack) {
542 int ack = get_ack(fd[0], result_sha1);
543 if (ack) {
544 print_verbose(args, _("got %s (%d) %s"), "ack",
545 ack, sha1_to_hex(result_sha1));
546 if (ack == ACK)
547 return 0;
548 multi_ack = 1;
549 continue;
550 }
551 flushes--;
552 }
553 /* it is no error to fetch into a completely empty repo */
554 return count ? retval : 0;
555}
556
557static struct commit_list *complete;
558
559static int mark_complete(const unsigned char *sha1)
560{
561 struct object *o = parse_object(sha1);
562
563 while (o && o->type == OBJ_TAG) {
564 struct tag *t = (struct tag *) o;
565 if (!t->tagged)
566 break; /* broken repository */
567 o->flags |= COMPLETE;
568 o = parse_object(t->tagged->oid.hash);
569 }
570 if (o && o->type == OBJ_COMMIT) {
571 struct commit *commit = (struct commit *)o;
572 if (!(commit->object.flags & COMPLETE)) {
573 commit->object.flags |= COMPLETE;
574 commit_list_insert(commit, &complete);
575 }
576 }
577 return 0;
578}
579
580static int mark_complete_oid(const char *refname, const struct object_id *oid,
581 int flag, void *cb_data)
582{
583 return mark_complete(oid->hash);
584}
585
586static void mark_recent_complete_commits(struct fetch_pack_args *args,
587 unsigned long cutoff)
588{
589 while (complete && cutoff <= complete->item->date) {
590 print_verbose(args, _("Marking %s as complete"),
591 oid_to_hex(&complete->item->object.oid));
592 pop_most_recent_commit(&complete, COMPLETE);
593 }
594}
595
596static void filter_refs(struct fetch_pack_args *args,
597 struct ref **refs,
598 struct ref **sought, int nr_sought)
599{
600 struct ref *newlist = NULL;
601 struct ref **newtail = &newlist;
602 struct ref *ref, *next;
603 int i;
604
605 i = 0;
606 for (ref = *refs; ref; ref = next) {
607 int keep = 0;
608 next = ref->next;
609
610 if (starts_with(ref->name, "refs/") &&
611 check_refname_format(ref->name, 0))
612 ; /* trash */
613 else {
614 while (i < nr_sought) {
615 int cmp = strcmp(ref->name, sought[i]->name);
616 if (cmp < 0)
617 break; /* definitely do not have it */
618 else if (cmp == 0) {
619 keep = 1; /* definitely have it */
620 sought[i]->match_status = REF_MATCHED;
621 }
622 i++;
623 }
624 }
625
626 if (!keep && args->fetch_all &&
627 (!args->deepen || !starts_with(ref->name, "refs/tags/")))
628 keep = 1;
629
630 if (keep) {
631 *newtail = ref;
632 ref->next = NULL;
633 newtail = &ref->next;
634 } else {
635 free(ref);
636 }
637 }
638
639 /* Append unmatched requests to the list */
640 for (i = 0; i < nr_sought; i++) {
641 unsigned char sha1[20];
642
643 ref = sought[i];
644 if (ref->match_status != REF_NOT_MATCHED)
645 continue;
646 if (get_sha1_hex(ref->name, sha1) ||
647 ref->name[40] != '\0' ||
648 hashcmp(sha1, ref->old_oid.hash))
649 continue;
650
651 if ((allow_unadvertised_object_request &
652 (ALLOW_TIP_SHA1 | ALLOW_REACHABLE_SHA1))) {
653 ref->match_status = REF_MATCHED;
654 *newtail = copy_ref(ref);
655 newtail = &(*newtail)->next;
656 } else {
657 ref->match_status = REF_UNADVERTISED_NOT_ALLOWED;
658 }
659 }
660 *refs = newlist;
661}
662
663static void mark_alternate_complete(struct object *obj)
664{
665 mark_complete(obj->oid.hash);
666}
667
668static int everything_local(struct fetch_pack_args *args,
669 struct ref **refs,
670 struct ref **sought, int nr_sought)
671{
672 struct ref *ref;
673 int retval;
674 unsigned long cutoff = 0;
675
676 save_commit_buffer = 0;
677
678 for (ref = *refs; ref; ref = ref->next) {
679 struct object *o;
680
681 if (!has_object_file(&ref->old_oid))
682 continue;
683
684 o = parse_object(ref->old_oid.hash);
685 if (!o)
686 continue;
687
688 /* We already have it -- which may mean that we were
689 * in sync with the other side at some time after
690 * that (it is OK if we guess wrong here).
691 */
692 if (o->type == OBJ_COMMIT) {
693 struct commit *commit = (struct commit *)o;
694 if (!cutoff || cutoff < commit->date)
695 cutoff = commit->date;
696 }
697 }
698
699 if (!args->deepen) {
700 for_each_ref(mark_complete_oid, NULL);
701 for_each_cached_alternate(mark_alternate_complete);
702 commit_list_sort_by_date(&complete);
703 if (cutoff)
704 mark_recent_complete_commits(args, cutoff);
705 }
706
707 /*
708 * Mark all complete remote refs as common refs.
709 * Don't mark them common yet; the server has to be told so first.
710 */
711 for (ref = *refs; ref; ref = ref->next) {
712 struct object *o = deref_tag(lookup_object(ref->old_oid.hash),
713 NULL, 0);
714
715 if (!o || o->type != OBJ_COMMIT || !(o->flags & COMPLETE))
716 continue;
717
718 if (!(o->flags & SEEN)) {
719 rev_list_push((struct commit *)o, COMMON_REF | SEEN);
720
721 mark_common((struct commit *)o, 1, 1);
722 }
723 }
724
725 filter_refs(args, refs, sought, nr_sought);
726
727 for (retval = 1, ref = *refs; ref ; ref = ref->next) {
728 const unsigned char *remote = ref->old_oid.hash;
729 struct object *o;
730
731 o = lookup_object(remote);
732 if (!o || !(o->flags & COMPLETE)) {
733 retval = 0;
734 print_verbose(args, "want %s (%s)", sha1_to_hex(remote),
735 ref->name);
736 continue;
737 }
738 print_verbose(args, _("already have %s (%s)"), sha1_to_hex(remote),
739 ref->name);
740 }
741 return retval;
742}
743
744static int sideband_demux(int in, int out, void *data)
745{
746 int *xd = data;
747 int ret;
748
749 ret = recv_sideband("fetch-pack", xd[0], out);
750 close(out);
751 return ret;
752}
753
754static int get_pack(struct fetch_pack_args *args,
755 int xd[2], char **pack_lockfile)
756{
757 struct async demux;
758 int do_keep = args->keep_pack;
759 const char *cmd_name;
760 struct pack_header header;
761 int pass_header = 0;
762 struct child_process cmd = CHILD_PROCESS_INIT;
763 int ret;
764
765 memset(&demux, 0, sizeof(demux));
766 if (use_sideband) {
767 /* xd[] is talking with upload-pack; subprocess reads from
768 * xd[0], spits out band#2 to stderr, and feeds us band#1
769 * through demux->out.
770 */
771 demux.proc = sideband_demux;
772 demux.data = xd;
773 demux.out = -1;
774 demux.isolate_sigpipe = 1;
775 if (start_async(&demux))
776 die(_("fetch-pack: unable to fork off sideband demultiplexer"));
777 }
778 else
779 demux.out = xd[0];
780
781 if (!args->keep_pack && unpack_limit) {
782
783 if (read_pack_header(demux.out, &header))
784 die(_("protocol error: bad pack header"));
785 pass_header = 1;
786 if (ntohl(header.hdr_entries) < unpack_limit)
787 do_keep = 0;
788 else
789 do_keep = 1;
790 }
791
792 if (alternate_shallow_file) {
793 argv_array_push(&cmd.args, "--shallow-file");
794 argv_array_push(&cmd.args, alternate_shallow_file);
795 }
796
797 if (do_keep) {
798 if (pack_lockfile)
799 cmd.out = -1;
800 cmd_name = "index-pack";
801 argv_array_push(&cmd.args, cmd_name);
802 argv_array_push(&cmd.args, "--stdin");
803 if (!args->quiet && !args->no_progress)
804 argv_array_push(&cmd.args, "-v");
805 if (args->use_thin_pack)
806 argv_array_push(&cmd.args, "--fix-thin");
807 if (args->lock_pack || unpack_limit) {
808 char hostname[HOST_NAME_MAX + 1];
809 if (xgethostname(hostname, sizeof(hostname)))
810 xsnprintf(hostname, sizeof(hostname), "localhost");
811 argv_array_pushf(&cmd.args,
812 "--keep=fetch-pack %"PRIuMAX " on %s",
813 (uintmax_t)getpid(), hostname);
814 }
815 if (args->check_self_contained_and_connected)
816 argv_array_push(&cmd.args, "--check-self-contained-and-connected");
817 }
818 else {
819 cmd_name = "unpack-objects";
820 argv_array_push(&cmd.args, cmd_name);
821 if (args->quiet || args->no_progress)
822 argv_array_push(&cmd.args, "-q");
823 args->check_self_contained_and_connected = 0;
824 }
825
826 if (pass_header)
827 argv_array_pushf(&cmd.args, "--pack_header=%"PRIu32",%"PRIu32,
828 ntohl(header.hdr_version),
829 ntohl(header.hdr_entries));
830 if (fetch_fsck_objects >= 0
831 ? fetch_fsck_objects
832 : transfer_fsck_objects >= 0
833 ? transfer_fsck_objects
834 : 0)
835 argv_array_push(&cmd.args, "--strict");
836
837 cmd.in = demux.out;
838 cmd.git_cmd = 1;
839 if (start_command(&cmd))
840 die(_("fetch-pack: unable to fork off %s"), cmd_name);
841 if (do_keep && pack_lockfile) {
842 *pack_lockfile = index_pack_lockfile(cmd.out);
843 close(cmd.out);
844 }
845
846 if (!use_sideband)
847 /* Closed by start_command() */
848 xd[0] = -1;
849
850 ret = finish_command(&cmd);
851 if (!ret || (args->check_self_contained_and_connected && ret == 1))
852 args->self_contained_and_connected =
853 args->check_self_contained_and_connected &&
854 ret == 0;
855 else
856 die(_("%s failed"), cmd_name);
857 if (use_sideband && finish_async(&demux))
858 die(_("error in sideband demultiplexer"));
859 return 0;
860}
861
862static int cmp_ref_by_name(const void *a_, const void *b_)
863{
864 const struct ref *a = *((const struct ref **)a_);
865 const struct ref *b = *((const struct ref **)b_);
866 return strcmp(a->name, b->name);
867}
868
869static struct ref *do_fetch_pack(struct fetch_pack_args *args,
870 int fd[2],
871 const struct ref *orig_ref,
872 struct ref **sought, int nr_sought,
873 struct shallow_info *si,
874 char **pack_lockfile)
875{
876 struct ref *ref = copy_ref_list(orig_ref);
877 unsigned char sha1[20];
878 const char *agent_feature;
879 int agent_len;
880
881 sort_ref_list(&ref, ref_compare_name);
882 QSORT(sought, nr_sought, cmp_ref_by_name);
883
884 if ((args->depth > 0 || is_repository_shallow()) && !server_supports("shallow"))
885 die(_("Server does not support shallow clients"));
886 if (args->depth > 0 || args->deepen_since || args->deepen_not)
887 args->deepen = 1;
888 if (server_supports("multi_ack_detailed")) {
889 print_verbose(args, _("Server supports multi_ack_detailed"));
890 multi_ack = 2;
891 if (server_supports("no-done")) {
892 print_verbose(args, _("Server supports no-done"));
893 if (args->stateless_rpc)
894 no_done = 1;
895 }
896 }
897 else if (server_supports("multi_ack")) {
898 print_verbose(args, _("Server supports multi_ack"));
899 multi_ack = 1;
900 }
901 if (server_supports("side-band-64k")) {
902 print_verbose(args, _("Server supports side-band-64k"));
903 use_sideband = 2;
904 }
905 else if (server_supports("side-band")) {
906 print_verbose(args, _("Server supports side-band"));
907 use_sideband = 1;
908 }
909 if (server_supports("allow-tip-sha1-in-want")) {
910 print_verbose(args, _("Server supports allow-tip-sha1-in-want"));
911 allow_unadvertised_object_request |= ALLOW_TIP_SHA1;
912 }
913 if (server_supports("allow-reachable-sha1-in-want")) {
914 print_verbose(args, _("Server supports allow-reachable-sha1-in-want"));
915 allow_unadvertised_object_request |= ALLOW_REACHABLE_SHA1;
916 }
917 if (!server_supports("thin-pack"))
918 args->use_thin_pack = 0;
919 if (!server_supports("no-progress"))
920 args->no_progress = 0;
921 if (!server_supports("include-tag"))
922 args->include_tag = 0;
923 if (server_supports("ofs-delta"))
924 print_verbose(args, _("Server supports ofs-delta"));
925 else
926 prefer_ofs_delta = 0;
927
928 if ((agent_feature = server_feature_value("agent", &agent_len))) {
929 agent_supported = 1;
930 if (agent_len)
931 print_verbose(args, _("Server version is %.*s"),
932 agent_len, agent_feature);
933 }
934 if (server_supports("deepen-since"))
935 deepen_since_ok = 1;
936 else if (args->deepen_since)
937 die(_("Server does not support --shallow-since"));
938 if (server_supports("deepen-not"))
939 deepen_not_ok = 1;
940 else if (args->deepen_not)
941 die(_("Server does not support --shallow-exclude"));
942 if (!server_supports("deepen-relative") && args->deepen_relative)
943 die(_("Server does not support --deepen"));
944
945 if (everything_local(args, &ref, sought, nr_sought)) {
946 packet_flush(fd[1]);
947 goto all_done;
948 }
949 if (find_common(args, fd, sha1, ref) < 0)
950 if (!args->keep_pack)
951 /* When cloning, it is not unusual to have
952 * no common commit.
953 */
954 warning(_("no common commits"));
955
956 if (args->stateless_rpc)
957 packet_flush(fd[1]);
958 if (args->deepen)
959 setup_alternate_shallow(&shallow_lock, &alternate_shallow_file,
960 NULL);
961 else if (si->nr_ours || si->nr_theirs)
962 alternate_shallow_file = setup_temporary_shallow(si->shallow);
963 else
964 alternate_shallow_file = NULL;
965 if (get_pack(args, fd, pack_lockfile))
966 die(_("git fetch-pack: fetch failed."));
967
968 all_done:
969 return ref;
970}
971
972static void fetch_pack_config(void)
973{
974 git_config_get_int("fetch.unpacklimit", &fetch_unpack_limit);
975 git_config_get_int("transfer.unpacklimit", &transfer_unpack_limit);
976 git_config_get_bool("repack.usedeltabaseoffset", &prefer_ofs_delta);
977 git_config_get_bool("fetch.fsckobjects", &fetch_fsck_objects);
978 git_config_get_bool("transfer.fsckobjects", &transfer_fsck_objects);
979
980 git_config(git_default_config, NULL);
981}
982
983static void fetch_pack_setup(void)
984{
985 static int did_setup;
986 if (did_setup)
987 return;
988 fetch_pack_config();
989 if (0 <= transfer_unpack_limit)
990 unpack_limit = transfer_unpack_limit;
991 else if (0 <= fetch_unpack_limit)
992 unpack_limit = fetch_unpack_limit;
993 did_setup = 1;
994}
995
996static int remove_duplicates_in_refs(struct ref **ref, int nr)
997{
998 struct string_list names = STRING_LIST_INIT_NODUP;
999 int src, dst;
1000
1001 for (src = dst = 0; src < nr; src++) {
1002 struct string_list_item *item;
1003 item = string_list_insert(&names, ref[src]->name);
1004 if (item->util)
1005 continue; /* already have it */
1006 item->util = ref[src];
1007 if (src != dst)
1008 ref[dst] = ref[src];
1009 dst++;
1010 }
1011 for (src = dst; src < nr; src++)
1012 ref[src] = NULL;
1013 string_list_clear(&names, 0);
1014 return dst;
1015}
1016
1017static void update_shallow(struct fetch_pack_args *args,
1018 struct ref **sought, int nr_sought,
1019 struct shallow_info *si)
1020{
1021 struct oid_array ref = OID_ARRAY_INIT;
1022 int *status;
1023 int i;
1024
1025 if (args->deepen && alternate_shallow_file) {
1026 if (*alternate_shallow_file == '\0') { /* --unshallow */
1027 unlink_or_warn(git_path_shallow());
1028 rollback_lock_file(&shallow_lock);
1029 } else
1030 commit_lock_file(&shallow_lock);
1031 return;
1032 }
1033
1034 if (!si->shallow || !si->shallow->nr)
1035 return;
1036
1037 if (args->cloning) {
1038 /*
1039 * remote is shallow, but this is a clone, there are
1040 * no objects in repo to worry about. Accept any
1041 * shallow points that exist in the pack (iow in repo
1042 * after get_pack() and reprepare_packed_git())
1043 */
1044 struct oid_array extra = OID_ARRAY_INIT;
1045 struct object_id *oid = si->shallow->oid;
1046 for (i = 0; i < si->shallow->nr; i++)
1047 if (has_object_file(&oid[i]))
1048 oid_array_append(&extra, &oid[i]);
1049 if (extra.nr) {
1050 setup_alternate_shallow(&shallow_lock,
1051 &alternate_shallow_file,
1052 &extra);
1053 commit_lock_file(&shallow_lock);
1054 }
1055 oid_array_clear(&extra);
1056 return;
1057 }
1058
1059 if (!si->nr_ours && !si->nr_theirs)
1060 return;
1061
1062 remove_nonexistent_theirs_shallow(si);
1063 if (!si->nr_ours && !si->nr_theirs)
1064 return;
1065 for (i = 0; i < nr_sought; i++)
1066 oid_array_append(&ref, &sought[i]->old_oid);
1067 si->ref = &ref;
1068
1069 if (args->update_shallow) {
1070 /*
1071 * remote is also shallow, .git/shallow may be updated
1072 * so all refs can be accepted. Make sure we only add
1073 * shallow roots that are actually reachable from new
1074 * refs.
1075 */
1076 struct oid_array extra = OID_ARRAY_INIT;
1077 struct object_id *oid = si->shallow->oid;
1078 assign_shallow_commits_to_refs(si, NULL, NULL);
1079 if (!si->nr_ours && !si->nr_theirs) {
1080 oid_array_clear(&ref);
1081 return;
1082 }
1083 for (i = 0; i < si->nr_ours; i++)
1084 oid_array_append(&extra, &oid[si->ours[i]]);
1085 for (i = 0; i < si->nr_theirs; i++)
1086 oid_array_append(&extra, &oid[si->theirs[i]]);
1087 setup_alternate_shallow(&shallow_lock,
1088 &alternate_shallow_file,
1089 &extra);
1090 commit_lock_file(&shallow_lock);
1091 oid_array_clear(&extra);
1092 oid_array_clear(&ref);
1093 return;
1094 }
1095
1096 /*
1097 * remote is also shallow, check what ref is safe to update
1098 * without updating .git/shallow
1099 */
1100 status = xcalloc(nr_sought, sizeof(*status));
1101 assign_shallow_commits_to_refs(si, NULL, status);
1102 if (si->nr_ours || si->nr_theirs) {
1103 for (i = 0; i < nr_sought; i++)
1104 if (status[i])
1105 sought[i]->status = REF_STATUS_REJECT_SHALLOW;
1106 }
1107 free(status);
1108 oid_array_clear(&ref);
1109}
1110
1111struct ref *fetch_pack(struct fetch_pack_args *args,
1112 int fd[], struct child_process *conn,
1113 const struct ref *ref,
1114 const char *dest,
1115 struct ref **sought, int nr_sought,
1116 struct oid_array *shallow,
1117 char **pack_lockfile)
1118{
1119 struct ref *ref_cpy;
1120 struct shallow_info si;
1121
1122 fetch_pack_setup();
1123 if (nr_sought)
1124 nr_sought = remove_duplicates_in_refs(sought, nr_sought);
1125
1126 if (!ref) {
1127 packet_flush(fd[1]);
1128 die(_("no matching remote head"));
1129 }
1130 prepare_shallow_info(&si, shallow);
1131 ref_cpy = do_fetch_pack(args, fd, ref, sought, nr_sought,
1132 &si, pack_lockfile);
1133 reprepare_packed_git();
1134 update_shallow(args, sought, nr_sought, &si);
1135 clear_shallow_info(&si);
1136 return ref_cpy;
1137}
1138
1139int report_unmatched_refs(struct ref **sought, int nr_sought)
1140{
1141 int i, ret = 0;
1142
1143 for (i = 0; i < nr_sought; i++) {
1144 if (!sought[i])
1145 continue;
1146 switch (sought[i]->match_status) {
1147 case REF_MATCHED:
1148 continue;
1149 case REF_NOT_MATCHED:
1150 error(_("no such remote ref %s"), sought[i]->name);
1151 break;
1152 case REF_UNADVERTISED_NOT_ALLOWED:
1153 error(_("Server does not allow request for unadvertised object %s"),
1154 sought[i]->name);
1155 break;
1156 }
1157 ret = 1;
1158 }
1159 return ret;
1160}