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