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