Git 1.7.9
[git/git.git] / builtin / fetch-pack.c
CommitLineData
c2e86add 1#include "builtin.h"
fb9040cc 2#include "refs.h"
def88e9a 3#include "pkt-line.h"
49bb805e
JH
4#include "commit.h"
5#include "tag.h"
da093d37 6#include "exec_cmd.h"
9e10fd1a 7#include "pack.h"
da093d37 8#include "sideband.h"
2d4177c0 9#include "fetch-pack.h"
ba227857 10#include "remote.h"
477822c3 11#include "run-command.h"
e52d7192 12#include "transport.h"
def88e9a 13
e28714c5
JH
14static int transfer_unpack_limit = -1;
15static int fetch_unpack_limit = -1;
af7cf268 16static int unpack_limit = 100;
f04833ef 17static int prefer_ofs_delta = 1;
ca0c9764 18static int no_done;
dab76d3a
JH
19static int fetch_fsck_objects = -1;
20static int transfer_fsck_objects = -1;
09149c78
DB
21static struct fetch_pack_args args = {
22 /* .uploadpack = */ "git-upload-pack",
23};
fa740529 24
33b83034 25static const char fetch_pack_usage[] =
1b1dd23f 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>...]";
def88e9a 27
0a8944dd 28#define COMPLETE (1U << 0)
23d61f83
JS
29#define COMMON (1U << 1)
30#define COMMON_REF (1U << 2)
31#define SEEN (1U << 3)
32#define POPPED (1U << 4)
33
420e9af4
DB
34static int marked;
35
f061e5fd
JH
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
96f1e58f 42static struct commit_list *rev_list;
3891f390 43static int non_common_revs, multi_ack, use_sideband;
23d61f83
JS
44
45static 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))
f3ec5494
MK
51 if (parse_commit(commit))
52 return;
23d61f83 53
47e44ed1 54 commit_list_insert_by_date(commit, &rev_list);
23d61f83
JS
55
56 if (!(commit->object.flags & COMMON))
57 non_common_revs++;
58 }
59}
60
8da19775 61static int rev_list_insert_ref(const char *path, const unsigned char *sha1, int flag, void *cb_data)
23d61f83 62{
9534f40b 63 struct object *o = deref_tag(parse_object(sha1), path, 0);
23d61f83 64
1974632c 65 if (o && o->type == OBJ_COMMIT)
23d61f83
JS
66 rev_list_push((struct commit *)o, SEEN);
67
68 return 0;
69}
70
420e9af4
DB
71static 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
23d61f83
JS
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
87static 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)
f3ec5494
MK
104 if (parse_commit(commit))
105 return;
23d61f83
JS
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
4b25d091 119static const unsigned char *get_rev(void)
23d61f83
JS
120{
121 struct commit *commit = NULL;
122
123 while (commit == NULL) {
124 unsigned int mark;
72269ad9 125 struct commit_list *parents;
23d61f83
JS
126
127 if (rev_list == NULL || non_common_revs == 0)
128 return NULL;
129
130 commit = rev_list->item;
2d8bed96 131 if (!commit->object.parsed)
72269ad9
LT
132 parse_commit(commit);
133 parents = commit->parents;
f3ec5494 134
23d61f83
JS
135 commit->object.flags |= POPPED;
136 if (!(commit->object.flags & COMMON))
137 non_common_revs--;
a6080a0a 138
23d61f83
JS
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}
0a8944dd 163
78affc49
SP
164enum ack_type {
165 NAK = 0,
166 ACK,
167 ACK_continue,
168 ACK_common,
169 ACK_ready
170};
171
249b2004
SP
172static 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
294e15fc
NTND
190struct write_shallow_data {
191 struct strbuf *out;
192 int use_pack_protocol;
193 int count;
194};
195
196static 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
210static 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
78affc49 220static enum ack_type get_ack(int fd, unsigned char *result_sha1)
28754ab5
SP
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"))
78affc49 230 return NAK;
28754ab5
SP
231 if (!prefixcmp(line, "ACK ")) {
232 if (!get_sha1_hex(line+4, result_sha1)) {
233 if (strstr(line+45, "continue"))
78affc49
SP
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;
28754ab5
SP
240 }
241 }
242 die("git fetch_pack: expected ACK/NAK, got '%s'", line);
243}
244
249b2004
SP
245static 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
e52d7192
JH
254static 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
259static void insert_alternate_refs(void)
260{
114a6a88 261 for_each_alternate_ref(insert_one_alternate_ref, NULL);
e52d7192
JH
262}
263
066bf4c2 264#define INITIAL_FLUSH 16
44d8dc54 265#define PIPESAFE_FLUSH 32
6afca450 266#define LARGE_FLUSH 1024
c12f5917
JH
267
268static int next_flush(int count)
269{
44d8dc54
JH
270 int flush_limit = args.stateless_rpc ? LARGE_FLUSH : PIPESAFE_FLUSH;
271
272 if (count < flush_limit)
6afca450
JH
273 count <<= 1;
274 else
44d8dc54 275 count += flush_limit;
6afca450 276 return count;
c12f5917
JH
277}
278
33b83034
JH
279static int find_common(int fd[2], unsigned char *result_sha1,
280 struct ref *refs)
def88e9a 281{
2759cbc7 282 int fetching;
c12f5917 283 int count = 0, flushes = 0, flush_at = INITIAL_FLUSH, retval;
23d61f83 284 const unsigned char *sha1;
f061e5fd
JH
285 unsigned in_vain = 0;
286 int got_continue = 0;
4e10cf9a 287 int got_ready = 0;
edace6f0 288 struct strbuf req_buf = STRBUF_INIT;
249b2004 289 size_t state_len = 0;
23d61f83 290
249b2004
SP
291 if (args.stateless_rpc && multi_ack == 1)
292 die("--stateless-rpc requires multi_ack_detailed");
420e9af4
DB
293 if (marked)
294 for_each_ref(clear_marks, NULL);
295 marked = 1;
296
cb5d709f 297 for_each_ref(rev_list_insert_ref, NULL);
e52d7192 298 insert_alternate_refs();
def88e9a 299
2759cbc7
LT
300 fetching = 0;
301 for ( ; refs ; refs = refs->next) {
33b83034 302 unsigned char *remote = refs->old_sha1;
edace6f0 303 const char *remote_hex;
4dab94d5 304 struct object *o;
2759cbc7 305
0a8944dd 306 /*
4dab94d5
JH
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.
f1f0a2be
JH
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.
4dab94d5 315 */
f1f0a2be 316 if (((o = lookup_object(remote)) != NULL) &&
1baaae5e 317 (o->flags & COMPLETE)) {
2759cbc7 318 continue;
0a8944dd 319 }
23d61f83 320
edace6f0
SP
321 remote_hex = sha1_to_hex(remote);
322 if (!fetching) {
323 struct strbuf c = STRBUF_INIT;
78affc49
SP
324 if (multi_ack == 2) strbuf_addstr(&c, " multi_ack_detailed");
325 if (multi_ack == 1) strbuf_addstr(&c, " multi_ack");
4e10cf9a 326 if (no_done) strbuf_addstr(&c, " no-done");
edace6f0
SP
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);
2759cbc7 337 fetching++;
33b83034 338 }
edace6f0
SP
339
340 if (!fetching) {
341 strbuf_release(&req_buf);
342 packet_flush(fd[1]);
343 return 1;
344 }
345
ed09aef0 346 if (is_repository_shallow())
edace6f0 347 write_shallow_commits(&req_buf, 1);
fa740529 348 if (args.depth > 0)
edace6f0
SP
349 packet_buf_write(&req_buf, "deepen %d", args.depth);
350 packet_buf_flush(&req_buf);
249b2004 351 state_len = req_buf.len;
0a8944dd 352
fa740529 353 if (args.depth > 0) {
016e6ccb
JS
354 char line[1024];
355 unsigned char sha1[20];
016e6ccb 356
249b2004 357 send_request(fd[1], &req_buf);
eb3a9dd3 358 while (packet_read_line(fd[0], line, sizeof(line))) {
599065a3 359 if (!prefixcmp(line, "shallow ")) {
016e6ccb
JS
360 if (get_sha1_hex(line + 8, sha1))
361 die("invalid shallow line: %s", line);
016e6ccb 362 register_shallow(sha1);
cf01bd52
JH
363 continue;
364 }
599065a3 365 if (!prefixcmp(line, "unshallow ")) {
f53514bc
JS
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 */
f3ec5494
MK
371 if (!parse_object(sha1))
372 die("error in object: %s", line);
f53514bc
JS
373 if (unregister_shallow(sha1))
374 die("no shallow found: %s", line);
cf01bd52
JH
375 continue;
376 }
377 die("expected shallow/unshallow, got %s", line);
016e6ccb 378 }
249b2004
SP
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;
016e6ccb
JS
388 }
389
23d61f83 390 flushes = 0;
75bfc6c2 391 retval = -1;
23d61f83 392 while ((sha1 = get_rev())) {
249b2004 393 packet_buf_write(&req_buf, "have %s\n", sha1_to_hex(sha1));
fa740529 394 if (args.verbose)
33b83034 395 fprintf(stderr, "have %s\n", sha1_to_hex(sha1));
f061e5fd 396 in_vain++;
c12f5917 397 if (flush_at <= ++count) {
c4c86f07
JS
398 int ack;
399
249b2004
SP
400 packet_buf_flush(&req_buf);
401 send_request(fd[1], &req_buf);
402 strbuf_setlen(&req_buf, state_len);
def88e9a 403 flushes++;
c12f5917 404 flush_at = next_flush(count);
def88e9a
LT
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 */
c12f5917 410 if (!args.stateless_rpc && count == INITIAL_FLUSH)
def88e9a 411 continue;
c4c86f07 412
249b2004 413 consume_shallow_list(fd[0]);
c4c86f07
JS
414 do {
415 ack = get_ack(fd[0], result_sha1);
fa740529 416 if (args.verbose && ack)
c4c86f07
JS
417 fprintf(stderr, "got ack %d %s\n", ack,
418 sha1_to_hex(result_sha1));
78affc49
SP
419 switch (ack) {
420 case ACK:
c4c86f07
JS
421 flushes = 0;
422 multi_ack = 0;
423 retval = 0;
424 goto done;
78affc49
SP
425 case ACK_common:
426 case ACK_ready:
427 case ACK_continue: {
c4c86f07
JS
428 struct commit *commit =
429 lookup_commit(result_sha1);
ec099546
NTND
430 if (!commit)
431 die("invalid commit %s", sha1_to_hex(result_sha1));
249b2004
SP
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 }
c4c86f07
JS
443 mark_common(commit, 0, 1);
444 retval = 0;
f061e5fd
JH
445 in_vain = 0;
446 got_continue = 1;
4e10cf9a 447 if (ack == ACK_ready) {
f2cba929 448 rev_list = NULL;
4e10cf9a
JH
449 got_ready = 1;
450 }
78affc49
SP
451 break;
452 }
c4c86f07
JS
453 }
454 } while (ack);
def88e9a 455 flushes--;
f061e5fd 456 if (got_continue && MAX_IN_VAIN < in_vain) {
fa740529 457 if (args.verbose)
f061e5fd
JH
458 fprintf(stderr, "giving up\n");
459 break; /* give up */
460 }
def88e9a
LT
461 }
462 }
c4c86f07 463done:
4e10cf9a
JH
464 if (!got_ready || !no_done) {
465 packet_buf_write(&req_buf, "done\n");
466 send_request(fd[1], &req_buf);
467 }
fa740529 468 if (args.verbose)
33b83034 469 fprintf(stderr, "done\n");
c4c86f07
JS
470 if (retval != 0) {
471 multi_ack = 0;
23d61f83 472 flushes++;
c4c86f07 473 }
edace6f0
SP
474 strbuf_release(&req_buf);
475
249b2004 476 consume_shallow_list(fd[0]);
c4c86f07
JS
477 while (flushes || multi_ack) {
478 int ack = get_ack(fd[0], result_sha1);
479 if (ack) {
fa740529 480 if (args.verbose)
c4c86f07
JS
481 fprintf(stderr, "got ack (%d) %s\n", ack,
482 sha1_to_hex(result_sha1));
78affc49 483 if (ack == ACK)
c4c86f07
JS
484 return 0;
485 multi_ack = 1;
486 continue;
33b83034 487 }
c4c86f07 488 flushes--;
def88e9a 489 }
8cb560fc
JS
490 /* it is no error to fetch into a completely empty repo */
491 return count ? retval : 0;
def88e9a
LT
492}
493
96f1e58f 494static struct commit_list *complete;
49bb805e 495
8da19775 496static int mark_complete(const char *path, const unsigned char *sha1, int flag, void *cb_data)
49bb805e
JH
497{
498 struct object *o = parse_object(sha1);
499
1974632c 500 while (o && o->type == OBJ_TAG) {
f1f0a2be
JH
501 struct tag *t = (struct tag *) o;
502 if (!t->tagged)
503 break; /* broken repository */
49bb805e 504 o->flags |= COMPLETE;
f1f0a2be 505 o = parse_object(t->tagged->sha1);
49bb805e 506 }
1974632c 507 if (o && o->type == OBJ_COMMIT) {
49bb805e 508 struct commit *commit = (struct commit *)o;
ea5f2208
JK
509 if (!(commit->object.flags & COMPLETE)) {
510 commit->object.flags |= COMPLETE;
511 commit_list_insert_by_date(commit, &complete);
512 }
49bb805e
JH
513 }
514 return 0;
515}
516
517static void mark_recent_complete_commits(unsigned long cutoff)
518{
519 while (complete && cutoff <= complete->item->date) {
fa740529 520 if (args.verbose)
49bb805e
JH
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
1baaae5e
JS
527static void filter_refs(struct ref **refs, int nr_match, char **match)
528{
9546010b
JH
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
fa740529 535 if (nr_match && !args.fetch_all) {
9546010b
JH
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) &&
8d9c5010 549 check_refname_format(ref->name + 5, 0))
9546010b 550 ; /* trash */
fa740529
SP
551 else if (args.fetch_all &&
552 (!args.depth || prefixcmp(ref->name, "refs/tags/") )) {
9546010b
JH
553 *newtail = ref;
554 ref->next = NULL;
555 newtail = &ref->next;
556 continue;
557 }
558 else {
1e7ba0f9
JK
559 int i;
560 for (i = 0; i < nr_match; i++) {
561 if (!strcmp(ref->name, match[i])) {
562 match[i][0] = '\0';
563 return_refs[i] = ref;
564 break;
565 }
9546010b 566 }
1e7ba0f9
JK
567 if (i < nr_match)
568 continue; /* we will link it later */
9546010b
JH
569 }
570 free(ref);
571 }
572
fa740529 573 if (!args.fetch_all) {
9546010b
JH
574 int i;
575 for (i = 0; i < nr_match; i++) {
576 ref = return_refs[i];
577 if (ref) {
578 *newtail = ref;
579 ref->next = NULL;
580 newtail = &ref->next;
581 }
582 }
583 if (return_refs != fastarray)
584 free(return_refs);
1baaae5e 585 }
9546010b 586 *refs = newlist;
1baaae5e
JS
587}
588
589static int everything_local(struct ref **refs, int nr_match, char **match)
2759cbc7 590{
49bb805e 591 struct ref *ref;
2759cbc7 592 int retval;
49bb805e
JH
593 unsigned long cutoff = 0;
594
49bb805e
JH
595 save_commit_buffer = 0;
596
1baaae5e 597 for (ref = *refs; ref; ref = ref->next) {
49bb805e
JH
598 struct object *o;
599
600 o = parse_object(ref->old_sha1);
601 if (!o)
602 continue;
603
604 /* We already have it -- which may mean that we were
605 * in sync with the other side at some time after
606 * that (it is OK if we guess wrong here).
607 */
1974632c 608 if (o->type == OBJ_COMMIT) {
49bb805e
JH
609 struct commit *commit = (struct commit *)o;
610 if (!cutoff || cutoff < commit->date)
611 cutoff = commit->date;
612 }
613 }
614
fa740529 615 if (!args.depth) {
f53514bc
JS
616 for_each_ref(mark_complete, NULL);
617 if (cutoff)
618 mark_recent_complete_commits(cutoff);
619 }
2759cbc7 620
1baaae5e
JS
621 /*
622 * Mark all complete remote refs as common refs.
623 * Don't mark them common yet; the server has to be told so first.
624 */
625 for (ref = *refs; ref; ref = ref->next) {
9534f40b
JH
626 struct object *o = deref_tag(lookup_object(ref->old_sha1),
627 NULL, 0);
1baaae5e 628
1974632c 629 if (!o || o->type != OBJ_COMMIT || !(o->flags & COMPLETE))
1baaae5e
JS
630 continue;
631
632 if (!(o->flags & SEEN)) {
633 rev_list_push((struct commit *)o, COMMON_REF | SEEN);
634
635 mark_common((struct commit *)o, 1, 1);
636 }
637 }
638
639 filter_refs(refs, nr_match, match);
640
641 for (retval = 1, ref = *refs; ref ; ref = ref->next) {
642 const unsigned char *remote = ref->old_sha1;
2759cbc7 643 unsigned char local[20];
49bb805e 644 struct object *o;
2759cbc7 645
1baaae5e 646 o = lookup_object(remote);
49bb805e 647 if (!o || !(o->flags & COMPLETE)) {
2759cbc7 648 retval = 0;
fa740529 649 if (!args.verbose)
2759cbc7
LT
650 continue;
651 fprintf(stderr,
652 "want %s (%s)\n", sha1_to_hex(remote),
1baaae5e 653 ref->name);
2759cbc7
LT
654 continue;
655 }
656
e702496e 657 hashcpy(ref->new_sha1, local);
fa740529 658 if (!args.verbose)
2759cbc7
LT
659 continue;
660 fprintf(stderr,
661 "already have %s (%s)\n", sha1_to_hex(remote),
1baaae5e 662 ref->name);
2759cbc7
LT
663 }
664 return retval;
665}
666
ae6a5609 667static int sideband_demux(int in, int out, void *data)
da093d37 668{
088fab5f 669 int *xd = data;
da093d37 670
ae6a5609
EFL
671 int ret = recv_sideband("fetch-pack", xd[0], out);
672 close(out);
3ef67cf2 673 return ret;
088fab5f
JS
674}
675
1788c39c 676static int get_pack(int xd[2], char **pack_lockfile)
da093d37 677{
088fab5f 678 struct async demux;
9e10fd1a
JH
679 const char *argv[20];
680 char keep_arg[256];
681 char hdr_arg[256];
682 const char **av;
fa740529 683 int do_keep = args.keep_pack;
477822c3 684 struct child_process cmd;
da093d37 685
1f759eee
JS
686 memset(&demux, 0, sizeof(demux));
687 if (use_sideband) {
688 /* xd[] is talking with upload-pack; subprocess reads from
689 * xd[0], spits out band#2 to stderr, and feeds us band#1
690 * through demux->out.
691 */
692 demux.proc = sideband_demux;
693 demux.data = xd;
ae6a5609 694 demux.out = -1;
1f759eee
JS
695 if (start_async(&demux))
696 die("fetch-pack: unable to fork off sideband"
697 " demultiplexer");
698 }
699 else
700 demux.out = xd[0];
9e10fd1a 701
477822c3
JS
702 memset(&cmd, 0, sizeof(cmd));
703 cmd.argv = argv;
9e10fd1a
JH
704 av = argv;
705 *hdr_arg = 0;
fa740529 706 if (!args.keep_pack && unpack_limit) {
9e10fd1a
JH
707 struct pack_header header;
708
1f759eee 709 if (read_pack_header(demux.out, &header))
9e10fd1a 710 die("protocol error: bad pack header");
6e1c2344
RJ
711 snprintf(hdr_arg, sizeof(hdr_arg),
712 "--pack_header=%"PRIu32",%"PRIu32,
9e10fd1a 713 ntohl(header.hdr_version), ntohl(header.hdr_entries));
af7cf268 714 if (ntohl(header.hdr_entries) < unpack_limit)
9e10fd1a
JH
715 do_keep = 0;
716 else
717 do_keep = 1;
718 }
719
720 if (do_keep) {
477822c3
JS
721 if (pack_lockfile)
722 cmd.out = -1;
9e10fd1a
JH
723 *av++ = "index-pack";
724 *av++ = "--stdin";
fa740529 725 if (!args.quiet && !args.no_progress)
9e10fd1a 726 *av++ = "-v";
fa740529 727 if (args.use_thin_pack)
9e10fd1a 728 *av++ = "--fix-thin";
fa740529 729 if (args.lock_pack || unpack_limit) {
9e10fd1a 730 int s = sprintf(keep_arg,
85e72830 731 "--keep=fetch-pack %"PRIuMAX " on ", (uintmax_t) getpid());
9e10fd1a
JH
732 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
733 strcpy(keep_arg + s, "localhost");
734 *av++ = keep_arg;
735 }
736 }
737 else {
738 *av++ = "unpack-objects";
fa740529 739 if (args.quiet)
9e10fd1a
JH
740 *av++ = "-q";
741 }
742 if (*hdr_arg)
743 *av++ = hdr_arg;
dab76d3a
JH
744 if (fetch_fsck_objects >= 0
745 ? fetch_fsck_objects
746 : transfer_fsck_objects >= 0
747 ? transfer_fsck_objects
748 : 0)
5e838ea7 749 *av++ = "--strict";
9e10fd1a
JH
750 *av++ = NULL;
751
1f759eee 752 cmd.in = demux.out;
477822c3
JS
753 cmd.git_cmd = 1;
754 if (start_command(&cmd))
da093d37 755 die("fetch-pack: unable to fork off %s", argv[0]);
e72ae288 756 if (do_keep && pack_lockfile) {
477822c3 757 *pack_lockfile = index_pack_lockfile(cmd.out);
e72ae288
JS
758 close(cmd.out);
759 }
477822c3
JS
760
761 if (finish_command(&cmd))
762 die("%s failed", argv[0]);
088fab5f
JS
763 if (use_sideband && finish_async(&demux))
764 die("error in sideband demultiplexer");
477822c3 765 return 0;
da093d37
NP
766}
767
1788c39c 768static struct ref *do_fetch_pack(int fd[2],
ba227857 769 const struct ref *orig_ref,
1788c39c
SP
770 int nr_match,
771 char **match,
772 char **pack_lockfile)
def88e9a 773{
ba227857 774 struct ref *ref = copy_ref_list(orig_ref);
d1c133f5 775 unsigned char sha1[20];
def88e9a 776
ed09aef0
JS
777 if (is_repository_shallow() && !server_supports("shallow"))
778 die("Server does not support shallow clients");
78affc49
SP
779 if (server_supports("multi_ack_detailed")) {
780 if (args.verbose)
781 fprintf(stderr, "Server supports multi_ack_detailed\n");
782 multi_ack = 2;
4e10cf9a
JH
783 if (server_supports("no-done")) {
784 if (args.verbose)
785 fprintf(stderr, "Server supports no-done\n");
8e9182e0
JH
786 if (args.stateless_rpc)
787 no_done = 1;
4e10cf9a 788 }
78affc49
SP
789 }
790 else if (server_supports("multi_ack")) {
fa740529 791 if (args.verbose)
c4c86f07
JS
792 fprintf(stderr, "Server supports multi_ack\n");
793 multi_ack = 1;
794 }
d47f3db7 795 if (server_supports("side-band-64k")) {
fa740529 796 if (args.verbose)
d47f3db7
JH
797 fprintf(stderr, "Server supports side-band-64k\n");
798 use_sideband = 2;
799 }
800 else if (server_supports("side-band")) {
fa740529 801 if (args.verbose)
583b7ea3
JH
802 fprintf(stderr, "Server supports side-band\n");
803 use_sideband = 1;
804 }
f04833ef
NP
805 if (server_supports("ofs-delta")) {
806 if (args.verbose)
807 fprintf(stderr, "Server supports ofs-delta\n");
808 } else
809 prefer_ofs_delta = 0;
1baaae5e 810 if (everything_local(&ref, nr_match, match)) {
2759cbc7
LT
811 packet_flush(fd[1]);
812 goto all_done;
813 }
33b83034 814 if (find_common(fd, sha1, ref) < 0)
fa740529 815 if (!args.keep_pack)
dfeff66e
JH
816 /* When cloning, it is not unusual to have
817 * no common commit.
818 */
78509d21 819 warning("no common commits");
ad897215 820
249b2004
SP
821 if (args.stateless_rpc)
822 packet_flush(fd[1]);
1788c39c 823 if (get_pack(fd, pack_lockfile))
7e44c935 824 die("git fetch-pack: fetch failed.");
ad897215
JH
825
826 all_done:
2d4177c0 827 return ref;
def88e9a
LT
828}
829
310b86d4
JH
830static int remove_duplicates(int nr_heads, char **heads)
831{
832 int src, dst;
833
834 for (src = dst = 0; src < nr_heads; src++) {
835 /* If heads[src] is different from any of
836 * heads[0..dst], push it in.
837 */
838 int i;
839 for (i = 0; i < dst; i++) {
840 if (!strcmp(heads[i], heads[src]))
841 break;
842 }
843 if (i < dst)
844 continue;
845 if (src != dst)
846 heads[dst] = heads[src];
847 dst++;
848 }
310b86d4
JH
849 return dst;
850}
851
ef90d6d4 852static int fetch_pack_config(const char *var, const char *value, void *cb)
af7cf268
JH
853{
854 if (strcmp(var, "fetch.unpacklimit") == 0) {
e28714c5
JH
855 fetch_unpack_limit = git_config_int(var, value);
856 return 0;
857 }
858
859 if (strcmp(var, "transfer.unpacklimit") == 0) {
860 transfer_unpack_limit = git_config_int(var, value);
af7cf268
JH
861 return 0;
862 }
863
f04833ef
NP
864 if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
865 prefer_ofs_delta = git_config_bool(var, value);
866 return 0;
867 }
868
5e838ea7
JH
869 if (!strcmp(var, "fetch.fsckobjects")) {
870 fetch_fsck_objects = git_config_bool(var, value);
871 return 0;
872 }
873
dab76d3a
JH
874 if (!strcmp(var, "transfer.fsckobjects")) {
875 transfer_fsck_objects = git_config_bool(var, value);
876 return 0;
877 }
878
ef90d6d4 879 return git_default_config(var, value, cb);
af7cf268
JH
880}
881
54b9e022
JH
882static struct lock_file lock;
883
50ab5fd3 884static void fetch_pack_setup(void)
def88e9a 885{
50ab5fd3
SP
886 static int did_setup;
887 if (did_setup)
888 return;
ef90d6d4 889 git_config(fetch_pack_config, NULL);
e28714c5
JH
890 if (0 <= transfer_unpack_limit)
891 unpack_limit = transfer_unpack_limit;
892 else if (0 <= fetch_unpack_limit)
893 unpack_limit = fetch_unpack_limit;
50ab5fd3
SP
894 did_setup = 1;
895}
896
897int cmd_fetch_pack(int argc, const char **argv, const char *prefix)
898{
899 int i, ret, nr_heads;
ba227857 900 struct ref *ref = NULL;
50ab5fd3 901 char *dest = NULL, **heads;
ba227857 902 int fd[2];
249b2004
SP
903 char *pack_lockfile = NULL;
904 char **pack_lockfile_ptr = NULL;
ba227857 905 struct child_process *conn;
e28714c5 906
bbc30f99
JK
907 packet_trace_identity("fetch-pack");
908
def88e9a
LT
909 nr_heads = 0;
910 heads = NULL;
911 for (i = 1; i < argc; i++) {
2d4177c0 912 const char *arg = argv[i];
def88e9a
LT
913
914 if (*arg == '-') {
599065a3 915 if (!prefixcmp(arg, "--upload-pack=")) {
fa740529 916 args.uploadpack = arg + 14;
27dca07f
UKK
917 continue;
918 }
599065a3 919 if (!prefixcmp(arg, "--exec=")) {
fa740529 920 args.uploadpack = arg + 7;
8b3d9dc0
JH
921 continue;
922 }
2247efb4 923 if (!strcmp("--quiet", arg) || !strcmp("-q", arg)) {
fa740529 924 args.quiet = 1;
33b83034
JH
925 continue;
926 }
2247efb4 927 if (!strcmp("--keep", arg) || !strcmp("-k", arg)) {
fa740529
SP
928 args.lock_pack = args.keep_pack;
929 args.keep_pack = 1;
9e10fd1a
JH
930 continue;
931 }
b19696c2 932 if (!strcmp("--thin", arg)) {
fa740529 933 args.use_thin_pack = 1;
b19696c2
JH
934 continue;
935 }
348e390b
SP
936 if (!strcmp("--include-tag", arg)) {
937 args.include_tag = 1;
938 continue;
939 }
dfeff66e 940 if (!strcmp("--all", arg)) {
fa740529 941 args.fetch_all = 1;
dfeff66e
JH
942 continue;
943 }
33b83034 944 if (!strcmp("-v", arg)) {
fa740529 945 args.verbose = 1;
33b83034
JH
946 continue;
947 }
599065a3 948 if (!prefixcmp(arg, "--depth=")) {
fa740529 949 args.depth = strtol(arg + 8, NULL, 0);
016e6ccb
JS
950 continue;
951 }
83a5ad61 952 if (!strcmp("--no-progress", arg)) {
fa740529 953 args.no_progress = 1;
83a5ad61
JS
954 continue;
955 }
249b2004
SP
956 if (!strcmp("--stateless-rpc", arg)) {
957 args.stateless_rpc = 1;
958 continue;
959 }
960 if (!strcmp("--lock-pack", arg)) {
961 args.lock_pack = 1;
962 pack_lockfile_ptr = &pack_lockfile;
963 continue;
964 }
def88e9a
LT
965 usage(fetch_pack_usage);
966 }
2d4177c0
DB
967 dest = (char *)arg;
968 heads = (char **)(argv + i + 1);
def88e9a
LT
969 nr_heads = argc - i - 1;
970 break;
971 }
972 if (!dest)
973 usage(fetch_pack_usage);
2d4177c0 974
249b2004
SP
975 if (args.stateless_rpc) {
976 conn = NULL;
977 fd[0] = 0;
978 fd[1] = 1;
ba227857 979 } else {
249b2004
SP
980 conn = git_connect(fd, (char *)dest, args.uploadpack,
981 args.verbose ? CONNECT_VERBOSE : 0);
982 }
983
afe7c5ff 984 get_remote_heads(fd[0], &ref, 0, NULL);
249b2004
SP
985
986 ref = fetch_pack(&args, fd, conn, ref, dest,
987 nr_heads, heads, pack_lockfile_ptr);
988 if (pack_lockfile) {
989 printf("lock %s\n", pack_lockfile);
990 fflush(stdout);
ba227857 991 }
249b2004
SP
992 close(fd[0]);
993 close(fd[1]);
994 if (finish_connect(conn))
995 ref = NULL;
2d4177c0
DB
996 ret = !ref;
997
ba227857
DB
998 if (!ret && nr_heads) {
999 /* If the heads to pull were given, we should have
1000 * consumed all of them by matching the remote.
05207a28 1001 * Otherwise, 'git fetch remote no-such-ref' would
ba227857
DB
1002 * silently succeed without issuing an error.
1003 */
1004 for (i = 0; i < nr_heads; i++)
1005 if (heads[i] && heads[i][0]) {
1006 error("no such remote ref %s", heads[i]);
1007 ret = 1;
1008 }
1009 }
2d4177c0
DB
1010 while (ref) {
1011 printf("%s %s\n",
1012 sha1_to_hex(ref->old_sha1), ref->name);
1013 ref = ref->next;
1014 }
1015
1016 return ret;
1017}
1018
fa740529 1019struct ref *fetch_pack(struct fetch_pack_args *my_args,
ba227857
DB
1020 int fd[], struct child_process *conn,
1021 const struct ref *ref,
fa740529 1022 const char *dest,
1788c39c
SP
1023 int nr_heads,
1024 char **heads,
1025 char **pack_lockfile)
2d4177c0 1026{
2d4177c0 1027 struct stat st;
ba227857 1028 struct ref *ref_cpy;
2d4177c0 1029
50ab5fd3 1030 fetch_pack_setup();
d551bbaf
TR
1031 if (&args != my_args)
1032 memcpy(&args, my_args, sizeof(args));
fa740529 1033 if (args.depth > 0) {
2d4177c0
DB
1034 if (stat(git_path("shallow"), &st))
1035 st.st_mtime = 0;
1036 }
1037
310b86d4
JH
1038 if (heads && nr_heads)
1039 nr_heads = remove_duplicates(nr_heads, heads);
ba227857
DB
1040 if (!ref) {
1041 packet_flush(fd[1]);
1042 die("no matching remote head");
9e5d2b40 1043 }
ba227857 1044 ref_cpy = do_fetch_pack(fd, ref, nr_heads, heads, pack_lockfile);
9e5d2b40 1045
ba227857 1046 if (args.depth > 0) {
016e6ccb 1047 struct cache_time mtime;
edace6f0 1048 struct strbuf sb = STRBUF_INIT;
016e6ccb
JS
1049 char *shallow = git_path("shallow");
1050 int fd;
1051
1052 mtime.sec = st.st_mtime;
c06ff490 1053 mtime.nsec = ST_MTIME_NSEC(st);
016e6ccb
JS
1054 if (stat(shallow, &st)) {
1055 if (mtime.sec)
1056 die("shallow file was removed during fetch");
1057 } else if (st.st_mtime != mtime.sec
1058#ifdef USE_NSEC
5bcf109c 1059 || ST_MTIME_NSEC(st) != mtime.nsec
016e6ccb
JS
1060#endif
1061 )
1062 die("shallow file was changed during fetch");
1063
acd3b9ec
JH
1064 fd = hold_lock_file_for_update(&lock, shallow,
1065 LOCK_DIE_ON_ERROR);
edace6f0
SP
1066 if (!write_shallow_commits(&sb, 0)
1067 || write_in_full(fd, sb.buf, sb.len) != sb.len) {
691f1a28 1068 unlink_or_warn(shallow);
016e6ccb
JS
1069 rollback_lock_file(&lock);
1070 } else {
016e6ccb
JS
1071 commit_lock_file(&lock);
1072 }
edace6f0 1073 strbuf_release(&sb);
016e6ccb
JS
1074 }
1075
48ec3e5c 1076 reprepare_packed_git();
ba227857 1077 return ref_cpy;
def88e9a 1078}