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