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