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