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