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