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