Provide git_config with a callback-data parameter
[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;
09149c78
DB
16static struct fetch_pack_args args = {
17 /* .uploadpack = */ "git-upload-pack",
18};
fa740529 19
33b83034 20static const char fetch_pack_usage[] =
348e390b 21"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 22
0a8944dd 23#define COMPLETE (1U << 0)
23d61f83
JS
24#define COMMON (1U << 1)
25#define COMMON_REF (1U << 2)
26#define SEEN (1U << 3)
27#define POPPED (1U << 4)
28
420e9af4
DB
29static int marked;
30
f061e5fd
JH
31/*
32 * After sending this many "have"s if we do not get any new ACK , we
33 * give up traversing our history.
34 */
35#define MAX_IN_VAIN 256
36
96f1e58f 37static struct commit_list *rev_list;
3891f390 38static int non_common_revs, multi_ack, use_sideband;
23d61f83
JS
39
40static void rev_list_push(struct commit *commit, int mark)
41{
42 if (!(commit->object.flags & mark)) {
43 commit->object.flags |= mark;
44
45 if (!(commit->object.parsed))
f3ec5494
MK
46 if (parse_commit(commit))
47 return;
23d61f83
JS
48
49 insert_by_date(commit, &rev_list);
50
51 if (!(commit->object.flags & COMMON))
52 non_common_revs++;
53 }
54}
55
8da19775 56static int rev_list_insert_ref(const char *path, const unsigned char *sha1, int flag, void *cb_data)
23d61f83 57{
9534f40b 58 struct object *o = deref_tag(parse_object(sha1), path, 0);
23d61f83 59
1974632c 60 if (o && o->type == OBJ_COMMIT)
23d61f83
JS
61 rev_list_push((struct commit *)o, SEEN);
62
63 return 0;
64}
65
420e9af4
DB
66static int clear_marks(const char *path, const unsigned char *sha1, int flag, void *cb_data)
67{
68 struct object *o = deref_tag(parse_object(sha1), path, 0);
69
70 if (o && o->type == OBJ_COMMIT)
71 clear_commit_marks((struct commit *)o,
72 COMMON | COMMON_REF | SEEN | POPPED);
73 return 0;
74}
75
23d61f83
JS
76/*
77 This function marks a rev and its ancestors as common.
78 In some cases, it is desirable to mark only the ancestors (for example
79 when only the server does not yet know that they are common).
80*/
81
82static void mark_common(struct commit *commit,
83 int ancestors_only, int dont_parse)
84{
85 if (commit != NULL && !(commit->object.flags & COMMON)) {
86 struct object *o = (struct object *)commit;
87
88 if (!ancestors_only)
89 o->flags |= COMMON;
90
91 if (!(o->flags & SEEN))
92 rev_list_push(commit, SEEN);
93 else {
94 struct commit_list *parents;
95
96 if (!ancestors_only && !(o->flags & POPPED))
97 non_common_revs--;
98 if (!o->parsed && !dont_parse)
f3ec5494
MK
99 if (parse_commit(commit))
100 return;
23d61f83
JS
101
102 for (parents = commit->parents;
103 parents;
104 parents = parents->next)
105 mark_common(parents->item, 0, dont_parse);
106 }
107 }
108}
109
110/*
111 Get the next rev to send, ignoring the common.
112*/
113
962554c6 114static const unsigned char* get_rev(void)
23d61f83
JS
115{
116 struct commit *commit = NULL;
117
118 while (commit == NULL) {
119 unsigned int mark;
72269ad9 120 struct commit_list *parents;
23d61f83
JS
121
122 if (rev_list == NULL || non_common_revs == 0)
123 return NULL;
124
125 commit = rev_list->item;
2d8bed96 126 if (!commit->object.parsed)
72269ad9
LT
127 parse_commit(commit);
128 parents = commit->parents;
f3ec5494 129
23d61f83
JS
130 commit->object.flags |= POPPED;
131 if (!(commit->object.flags & COMMON))
132 non_common_revs--;
a6080a0a 133
23d61f83
JS
134 if (commit->object.flags & COMMON) {
135 /* do not send "have", and ignore ancestors */
136 commit = NULL;
137 mark = COMMON | SEEN;
138 } else if (commit->object.flags & COMMON_REF)
139 /* send "have", and ignore ancestors */
140 mark = COMMON | SEEN;
141 else
142 /* send "have", also for its ancestors */
143 mark = SEEN;
144
145 while (parents) {
146 if (!(parents->item->object.flags & SEEN))
147 rev_list_push(parents->item, mark);
148 if (mark & COMMON)
149 mark_common(parents->item, 1, 0);
150 parents = parents->next;
151 }
152
153 rev_list = rev_list->next;
154 }
155
156 return commit->object.sha1;
157}
0a8944dd 158
33b83034
JH
159static int find_common(int fd[2], unsigned char *result_sha1,
160 struct ref *refs)
def88e9a 161{
2759cbc7 162 int fetching;
23d61f83
JS
163 int count = 0, flushes = 0, retval;
164 const unsigned char *sha1;
f061e5fd
JH
165 unsigned in_vain = 0;
166 int got_continue = 0;
23d61f83 167
420e9af4
DB
168 if (marked)
169 for_each_ref(clear_marks, NULL);
170 marked = 1;
171
cb5d709f 172 for_each_ref(rev_list_insert_ref, NULL);
def88e9a 173
2759cbc7
LT
174 fetching = 0;
175 for ( ; refs ; refs = refs->next) {
33b83034 176 unsigned char *remote = refs->old_sha1;
4dab94d5 177 struct object *o;
2759cbc7 178
0a8944dd 179 /*
4dab94d5
JH
180 * If that object is complete (i.e. it is an ancestor of a
181 * local ref), we tell them we have it but do not have to
182 * tell them about its ancestors, which they already know
183 * about.
f1f0a2be
JH
184 *
185 * We use lookup_object here because we are only
186 * interested in the case we *know* the object is
187 * reachable and we have already scanned it.
4dab94d5 188 */
f1f0a2be 189 if (((o = lookup_object(remote)) != NULL) &&
1baaae5e 190 (o->flags & COMPLETE)) {
2759cbc7 191 continue;
0a8944dd 192 }
23d61f83 193
583b7ea3 194 if (!fetching)
348e390b 195 packet_write(fd[1], "want %s%s%s%s%s%s%s%s\n",
583b7ea3
JH
196 sha1_to_hex(remote),
197 (multi_ack ? " multi_ack" : ""),
d47f3db7
JH
198 (use_sideband == 2 ? " side-band-64k" : ""),
199 (use_sideband == 1 ? " side-band" : ""),
3891f390 200 (args.use_thin_pack ? " thin-pack" : ""),
fa740529 201 (args.no_progress ? " no-progress" : ""),
348e390b 202 (args.include_tag ? " include-tag" : ""),
e4fe4b8e 203 " ofs-delta");
583b7ea3
JH
204 else
205 packet_write(fd[1], "want %s\n", sha1_to_hex(remote));
2759cbc7 206 fetching++;
33b83034 207 }
ed09aef0
JS
208 if (is_repository_shallow())
209 write_shallow_commits(fd[1], 1);
fa740529
SP
210 if (args.depth > 0)
211 packet_write(fd[1], "deepen %d", args.depth);
fb9040cc 212 packet_flush(fd[1]);
2759cbc7
LT
213 if (!fetching)
214 return 1;
0a8944dd 215
fa740529 216 if (args.depth > 0) {
016e6ccb
JS
217 char line[1024];
218 unsigned char sha1[20];
219 int len;
220
221 while ((len = packet_read_line(fd[0], line, sizeof(line)))) {
599065a3 222 if (!prefixcmp(line, "shallow ")) {
016e6ccb
JS
223 if (get_sha1_hex(line + 8, sha1))
224 die("invalid shallow line: %s", line);
016e6ccb 225 register_shallow(sha1);
cf01bd52
JH
226 continue;
227 }
599065a3 228 if (!prefixcmp(line, "unshallow ")) {
f53514bc
JS
229 if (get_sha1_hex(line + 10, sha1))
230 die("invalid unshallow line: %s", line);
231 if (!lookup_object(sha1))
232 die("object not found: %s", line);
233 /* make sure that it is parsed as shallow */
f3ec5494
MK
234 if (!parse_object(sha1))
235 die("error in object: %s", line);
f53514bc
JS
236 if (unregister_shallow(sha1))
237 die("no shallow found: %s", line);
cf01bd52
JH
238 continue;
239 }
240 die("expected shallow/unshallow, got %s", line);
016e6ccb
JS
241 }
242 }
243
23d61f83 244 flushes = 0;
75bfc6c2 245 retval = -1;
23d61f83 246 while ((sha1 = get_rev())) {
def88e9a 247 packet_write(fd[1], "have %s\n", sha1_to_hex(sha1));
fa740529 248 if (args.verbose)
33b83034 249 fprintf(stderr, "have %s\n", sha1_to_hex(sha1));
f061e5fd 250 in_vain++;
def88e9a 251 if (!(31 & ++count)) {
c4c86f07
JS
252 int ack;
253
def88e9a
LT
254 packet_flush(fd[1]);
255 flushes++;
256
257 /*
258 * We keep one window "ahead" of the other side, and
259 * will wait for an ACK only on the next one
260 */
261 if (count == 32)
262 continue;
c4c86f07
JS
263
264 do {
265 ack = get_ack(fd[0], result_sha1);
fa740529 266 if (args.verbose && ack)
c4c86f07
JS
267 fprintf(stderr, "got ack %d %s\n", ack,
268 sha1_to_hex(result_sha1));
269 if (ack == 1) {
270 flushes = 0;
271 multi_ack = 0;
272 retval = 0;
273 goto done;
274 } else if (ack == 2) {
275 struct commit *commit =
276 lookup_commit(result_sha1);
277 mark_common(commit, 0, 1);
278 retval = 0;
f061e5fd
JH
279 in_vain = 0;
280 got_continue = 1;
c4c86f07
JS
281 }
282 } while (ack);
def88e9a 283 flushes--;
f061e5fd 284 if (got_continue && MAX_IN_VAIN < in_vain) {
fa740529 285 if (args.verbose)
f061e5fd
JH
286 fprintf(stderr, "giving up\n");
287 break; /* give up */
288 }
def88e9a
LT
289 }
290 }
c4c86f07 291done:
75bfc6c2 292 packet_write(fd[1], "done\n");
fa740529 293 if (args.verbose)
33b83034 294 fprintf(stderr, "done\n");
c4c86f07
JS
295 if (retval != 0) {
296 multi_ack = 0;
23d61f83 297 flushes++;
c4c86f07
JS
298 }
299 while (flushes || multi_ack) {
300 int ack = get_ack(fd[0], result_sha1);
301 if (ack) {
fa740529 302 if (args.verbose)
c4c86f07
JS
303 fprintf(stderr, "got ack (%d) %s\n", ack,
304 sha1_to_hex(result_sha1));
305 if (ack == 1)
306 return 0;
307 multi_ack = 1;
308 continue;
33b83034 309 }
c4c86f07 310 flushes--;
def88e9a 311 }
75bfc6c2 312 return retval;
def88e9a
LT
313}
314
96f1e58f 315static struct commit_list *complete;
49bb805e 316
8da19775 317static int mark_complete(const char *path, const unsigned char *sha1, int flag, void *cb_data)
49bb805e
JH
318{
319 struct object *o = parse_object(sha1);
320
1974632c 321 while (o && o->type == OBJ_TAG) {
f1f0a2be
JH
322 struct tag *t = (struct tag *) o;
323 if (!t->tagged)
324 break; /* broken repository */
49bb805e 325 o->flags |= COMPLETE;
f1f0a2be 326 o = parse_object(t->tagged->sha1);
49bb805e 327 }
1974632c 328 if (o && o->type == OBJ_COMMIT) {
49bb805e
JH
329 struct commit *commit = (struct commit *)o;
330 commit->object.flags |= COMPLETE;
331 insert_by_date(commit, &complete);
332 }
333 return 0;
334}
335
336static void mark_recent_complete_commits(unsigned long cutoff)
337{
338 while (complete && cutoff <= complete->item->date) {
fa740529 339 if (args.verbose)
49bb805e
JH
340 fprintf(stderr, "Marking %s as complete\n",
341 sha1_to_hex(complete->item->object.sha1));
342 pop_most_recent_commit(&complete, COMPLETE);
343 }
344}
345
1baaae5e
JS
346static void filter_refs(struct ref **refs, int nr_match, char **match)
347{
9546010b
JH
348 struct ref **return_refs;
349 struct ref *newlist = NULL;
350 struct ref **newtail = &newlist;
351 struct ref *ref, *next;
352 struct ref *fastarray[32];
353
fa740529 354 if (nr_match && !args.fetch_all) {
9546010b
JH
355 if (ARRAY_SIZE(fastarray) < nr_match)
356 return_refs = xcalloc(nr_match, sizeof(struct ref *));
357 else {
358 return_refs = fastarray;
359 memset(return_refs, 0, sizeof(struct ref *) * nr_match);
360 }
361 }
362 else
363 return_refs = NULL;
364
365 for (ref = *refs; ref; ref = next) {
366 next = ref->next;
367 if (!memcmp(ref->name, "refs/", 5) &&
368 check_ref_format(ref->name + 5))
369 ; /* trash */
fa740529
SP
370 else if (args.fetch_all &&
371 (!args.depth || prefixcmp(ref->name, "refs/tags/") )) {
9546010b
JH
372 *newtail = ref;
373 ref->next = NULL;
374 newtail = &ref->next;
375 continue;
376 }
377 else {
378 int order = path_match(ref->name, nr_match, match);
379 if (order) {
380 return_refs[order-1] = ref;
381 continue; /* we will link it later */
382 }
383 }
384 free(ref);
385 }
386
fa740529 387 if (!args.fetch_all) {
9546010b
JH
388 int i;
389 for (i = 0; i < nr_match; i++) {
390 ref = return_refs[i];
391 if (ref) {
392 *newtail = ref;
393 ref->next = NULL;
394 newtail = &ref->next;
395 }
396 }
397 if (return_refs != fastarray)
398 free(return_refs);
1baaae5e 399 }
9546010b 400 *refs = newlist;
1baaae5e
JS
401}
402
403static int everything_local(struct ref **refs, int nr_match, char **match)
2759cbc7 404{
49bb805e 405 struct ref *ref;
2759cbc7 406 int retval;
49bb805e
JH
407 unsigned long cutoff = 0;
408
49bb805e
JH
409 save_commit_buffer = 0;
410
1baaae5e 411 for (ref = *refs; ref; ref = ref->next) {
49bb805e
JH
412 struct object *o;
413
414 o = parse_object(ref->old_sha1);
415 if (!o)
416 continue;
417
418 /* We already have it -- which may mean that we were
419 * in sync with the other side at some time after
420 * that (it is OK if we guess wrong here).
421 */
1974632c 422 if (o->type == OBJ_COMMIT) {
49bb805e
JH
423 struct commit *commit = (struct commit *)o;
424 if (!cutoff || cutoff < commit->date)
425 cutoff = commit->date;
426 }
427 }
428
fa740529 429 if (!args.depth) {
f53514bc
JS
430 for_each_ref(mark_complete, NULL);
431 if (cutoff)
432 mark_recent_complete_commits(cutoff);
433 }
2759cbc7 434
1baaae5e
JS
435 /*
436 * Mark all complete remote refs as common refs.
437 * Don't mark them common yet; the server has to be told so first.
438 */
439 for (ref = *refs; ref; ref = ref->next) {
9534f40b
JH
440 struct object *o = deref_tag(lookup_object(ref->old_sha1),
441 NULL, 0);
1baaae5e 442
1974632c 443 if (!o || o->type != OBJ_COMMIT || !(o->flags & COMPLETE))
1baaae5e
JS
444 continue;
445
446 if (!(o->flags & SEEN)) {
447 rev_list_push((struct commit *)o, COMMON_REF | SEEN);
448
449 mark_common((struct commit *)o, 1, 1);
450 }
451 }
452
453 filter_refs(refs, nr_match, match);
454
455 for (retval = 1, ref = *refs; ref ; ref = ref->next) {
456 const unsigned char *remote = ref->old_sha1;
2759cbc7 457 unsigned char local[20];
49bb805e 458 struct object *o;
2759cbc7 459
1baaae5e 460 o = lookup_object(remote);
49bb805e 461 if (!o || !(o->flags & COMPLETE)) {
2759cbc7 462 retval = 0;
fa740529 463 if (!args.verbose)
2759cbc7
LT
464 continue;
465 fprintf(stderr,
466 "want %s (%s)\n", sha1_to_hex(remote),
1baaae5e 467 ref->name);
2759cbc7
LT
468 continue;
469 }
470
e702496e 471 hashcpy(ref->new_sha1, local);
fa740529 472 if (!args.verbose)
2759cbc7
LT
473 continue;
474 fprintf(stderr,
475 "already have %s (%s)\n", sha1_to_hex(remote),
1baaae5e 476 ref->name);
2759cbc7
LT
477 }
478 return retval;
479}
480
088fab5f 481static int sideband_demux(int fd, void *data)
da093d37 482{
088fab5f 483 int *xd = data;
da093d37 484
088fab5f
JS
485 return recv_sideband("fetch-pack", xd[0], fd, 2);
486}
487
1788c39c 488static int get_pack(int xd[2], char **pack_lockfile)
da093d37 489{
088fab5f 490 struct async demux;
9e10fd1a
JH
491 const char *argv[20];
492 char keep_arg[256];
493 char hdr_arg[256];
494 const char **av;
fa740529 495 int do_keep = args.keep_pack;
477822c3 496 struct child_process cmd;
da093d37 497
1f759eee
JS
498 memset(&demux, 0, sizeof(demux));
499 if (use_sideband) {
500 /* xd[] is talking with upload-pack; subprocess reads from
501 * xd[0], spits out band#2 to stderr, and feeds us band#1
502 * through demux->out.
503 */
504 demux.proc = sideband_demux;
505 demux.data = xd;
506 if (start_async(&demux))
507 die("fetch-pack: unable to fork off sideband"
508 " demultiplexer");
509 }
510 else
511 demux.out = xd[0];
9e10fd1a 512
477822c3
JS
513 memset(&cmd, 0, sizeof(cmd));
514 cmd.argv = argv;
9e10fd1a
JH
515 av = argv;
516 *hdr_arg = 0;
fa740529 517 if (!args.keep_pack && unpack_limit) {
9e10fd1a
JH
518 struct pack_header header;
519
1f759eee 520 if (read_pack_header(demux.out, &header))
9e10fd1a
JH
521 die("protocol error: bad pack header");
522 snprintf(hdr_arg, sizeof(hdr_arg), "--pack_header=%u,%u",
523 ntohl(header.hdr_version), ntohl(header.hdr_entries));
af7cf268 524 if (ntohl(header.hdr_entries) < unpack_limit)
9e10fd1a
JH
525 do_keep = 0;
526 else
527 do_keep = 1;
528 }
529
530 if (do_keep) {
477822c3
JS
531 if (pack_lockfile)
532 cmd.out = -1;
9e10fd1a
JH
533 *av++ = "index-pack";
534 *av++ = "--stdin";
fa740529 535 if (!args.quiet && !args.no_progress)
9e10fd1a 536 *av++ = "-v";
fa740529 537 if (args.use_thin_pack)
9e10fd1a 538 *av++ = "--fix-thin";
fa740529 539 if (args.lock_pack || unpack_limit) {
9e10fd1a
JH
540 int s = sprintf(keep_arg,
541 "--keep=fetch-pack %d on ", getpid());
542 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
543 strcpy(keep_arg + s, "localhost");
544 *av++ = keep_arg;
545 }
546 }
547 else {
548 *av++ = "unpack-objects";
fa740529 549 if (args.quiet)
9e10fd1a
JH
550 *av++ = "-q";
551 }
552 if (*hdr_arg)
553 *av++ = hdr_arg;
554 *av++ = NULL;
555
1f759eee 556 cmd.in = demux.out;
477822c3
JS
557 cmd.git_cmd = 1;
558 if (start_command(&cmd))
da093d37 559 die("fetch-pack: unable to fork off %s", argv[0]);
e72ae288 560 if (do_keep && pack_lockfile) {
477822c3 561 *pack_lockfile = index_pack_lockfile(cmd.out);
e72ae288
JS
562 close(cmd.out);
563 }
477822c3
JS
564
565 if (finish_command(&cmd))
566 die("%s failed", argv[0]);
088fab5f
JS
567 if (use_sideband && finish_async(&demux))
568 die("error in sideband demultiplexer");
477822c3 569 return 0;
da093d37
NP
570}
571
1788c39c 572static struct ref *do_fetch_pack(int fd[2],
ba227857 573 const struct ref *orig_ref,
1788c39c
SP
574 int nr_match,
575 char **match,
576 char **pack_lockfile)
def88e9a 577{
ba227857 578 struct ref *ref = copy_ref_list(orig_ref);
d1c133f5 579 unsigned char sha1[20];
def88e9a 580
ed09aef0
JS
581 if (is_repository_shallow() && !server_supports("shallow"))
582 die("Server does not support shallow clients");
c4c86f07 583 if (server_supports("multi_ack")) {
fa740529 584 if (args.verbose)
c4c86f07
JS
585 fprintf(stderr, "Server supports multi_ack\n");
586 multi_ack = 1;
587 }
d47f3db7 588 if (server_supports("side-band-64k")) {
fa740529 589 if (args.verbose)
d47f3db7
JH
590 fprintf(stderr, "Server supports side-band-64k\n");
591 use_sideband = 2;
592 }
593 else if (server_supports("side-band")) {
fa740529 594 if (args.verbose)
583b7ea3
JH
595 fprintf(stderr, "Server supports side-band\n");
596 use_sideband = 1;
597 }
1baaae5e 598 if (everything_local(&ref, nr_match, match)) {
2759cbc7
LT
599 packet_flush(fd[1]);
600 goto all_done;
601 }
33b83034 602 if (find_common(fd, sha1, ref) < 0)
fa740529 603 if (!args.keep_pack)
dfeff66e
JH
604 /* When cloning, it is not unusual to have
605 * no common commit.
606 */
607 fprintf(stderr, "warning: no common commits\n");
ad897215 608
1788c39c 609 if (get_pack(fd, pack_lockfile))
ad897215
JH
610 die("git-fetch-pack: fetch failed.");
611
612 all_done:
2d4177c0 613 return ref;
def88e9a
LT
614}
615
310b86d4
JH
616static int remove_duplicates(int nr_heads, char **heads)
617{
618 int src, dst;
619
620 for (src = dst = 0; src < nr_heads; src++) {
621 /* If heads[src] is different from any of
622 * heads[0..dst], push it in.
623 */
624 int i;
625 for (i = 0; i < dst; i++) {
626 if (!strcmp(heads[i], heads[src]))
627 break;
628 }
629 if (i < dst)
630 continue;
631 if (src != dst)
632 heads[dst] = heads[src];
633 dst++;
634 }
310b86d4
JH
635 return dst;
636}
637
ef90d6d4 638static int fetch_pack_config(const char *var, const char *value, void *cb)
af7cf268
JH
639{
640 if (strcmp(var, "fetch.unpacklimit") == 0) {
e28714c5
JH
641 fetch_unpack_limit = git_config_int(var, value);
642 return 0;
643 }
644
645 if (strcmp(var, "transfer.unpacklimit") == 0) {
646 transfer_unpack_limit = git_config_int(var, value);
af7cf268
JH
647 return 0;
648 }
649
ef90d6d4 650 return git_default_config(var, value, cb);
af7cf268
JH
651}
652
54b9e022
JH
653static struct lock_file lock;
654
50ab5fd3 655static void fetch_pack_setup(void)
def88e9a 656{
50ab5fd3
SP
657 static int did_setup;
658 if (did_setup)
659 return;
ef90d6d4 660 git_config(fetch_pack_config, NULL);
e28714c5
JH
661 if (0 <= transfer_unpack_limit)
662 unpack_limit = transfer_unpack_limit;
663 else if (0 <= fetch_unpack_limit)
664 unpack_limit = fetch_unpack_limit;
50ab5fd3
SP
665 did_setup = 1;
666}
667
668int cmd_fetch_pack(int argc, const char **argv, const char *prefix)
669{
670 int i, ret, nr_heads;
ba227857 671 struct ref *ref = NULL;
50ab5fd3 672 char *dest = NULL, **heads;
ba227857
DB
673 int fd[2];
674 struct child_process *conn;
e28714c5 675
def88e9a
LT
676 nr_heads = 0;
677 heads = NULL;
678 for (i = 1; i < argc; i++) {
2d4177c0 679 const char *arg = argv[i];
def88e9a
LT
680
681 if (*arg == '-') {
599065a3 682 if (!prefixcmp(arg, "--upload-pack=")) {
fa740529 683 args.uploadpack = arg + 14;
27dca07f
UKK
684 continue;
685 }
599065a3 686 if (!prefixcmp(arg, "--exec=")) {
fa740529 687 args.uploadpack = arg + 7;
8b3d9dc0
JH
688 continue;
689 }
2247efb4 690 if (!strcmp("--quiet", arg) || !strcmp("-q", arg)) {
fa740529 691 args.quiet = 1;
33b83034
JH
692 continue;
693 }
2247efb4 694 if (!strcmp("--keep", arg) || !strcmp("-k", arg)) {
fa740529
SP
695 args.lock_pack = args.keep_pack;
696 args.keep_pack = 1;
9e10fd1a
JH
697 continue;
698 }
b19696c2 699 if (!strcmp("--thin", arg)) {
fa740529 700 args.use_thin_pack = 1;
b19696c2
JH
701 continue;
702 }
348e390b
SP
703 if (!strcmp("--include-tag", arg)) {
704 args.include_tag = 1;
705 continue;
706 }
dfeff66e 707 if (!strcmp("--all", arg)) {
fa740529 708 args.fetch_all = 1;
dfeff66e
JH
709 continue;
710 }
33b83034 711 if (!strcmp("-v", arg)) {
fa740529 712 args.verbose = 1;
33b83034
JH
713 continue;
714 }
599065a3 715 if (!prefixcmp(arg, "--depth=")) {
fa740529 716 args.depth = strtol(arg + 8, NULL, 0);
016e6ccb
JS
717 continue;
718 }
83a5ad61 719 if (!strcmp("--no-progress", arg)) {
fa740529 720 args.no_progress = 1;
83a5ad61
JS
721 continue;
722 }
def88e9a
LT
723 usage(fetch_pack_usage);
724 }
2d4177c0
DB
725 dest = (char *)arg;
726 heads = (char **)(argv + i + 1);
def88e9a
LT
727 nr_heads = argc - i - 1;
728 break;
729 }
730 if (!dest)
731 usage(fetch_pack_usage);
2d4177c0 732
ba227857
DB
733 conn = git_connect(fd, (char *)dest, args.uploadpack,
734 args.verbose ? CONNECT_VERBOSE : 0);
735 if (conn) {
736 get_remote_heads(fd[0], &ref, 0, NULL, 0);
737
738 ref = fetch_pack(&args, fd, conn, ref, dest, nr_heads, heads, NULL);
739 close(fd[0]);
740 close(fd[1]);
741 if (finish_connect(conn))
742 ref = NULL;
743 } else {
744 ref = NULL;
745 }
2d4177c0
DB
746 ret = !ref;
747
ba227857
DB
748 if (!ret && nr_heads) {
749 /* If the heads to pull were given, we should have
750 * consumed all of them by matching the remote.
751 * Otherwise, 'git-fetch remote no-such-ref' would
752 * silently succeed without issuing an error.
753 */
754 for (i = 0; i < nr_heads; i++)
755 if (heads[i] && heads[i][0]) {
756 error("no such remote ref %s", heads[i]);
757 ret = 1;
758 }
759 }
2d4177c0
DB
760 while (ref) {
761 printf("%s %s\n",
762 sha1_to_hex(ref->old_sha1), ref->name);
763 ref = ref->next;
764 }
765
766 return ret;
767}
768
fa740529 769struct ref *fetch_pack(struct fetch_pack_args *my_args,
ba227857
DB
770 int fd[], struct child_process *conn,
771 const struct ref *ref,
fa740529 772 const char *dest,
1788c39c
SP
773 int nr_heads,
774 char **heads,
775 char **pack_lockfile)
2d4177c0 776{
2d4177c0 777 struct stat st;
ba227857 778 struct ref *ref_cpy;
2d4177c0 779
50ab5fd3 780 fetch_pack_setup();
fa740529
SP
781 memcpy(&args, my_args, sizeof(args));
782 if (args.depth > 0) {
2d4177c0
DB
783 if (stat(git_path("shallow"), &st))
784 st.st_mtime = 0;
785 }
786
310b86d4
JH
787 if (heads && nr_heads)
788 nr_heads = remove_duplicates(nr_heads, heads);
ba227857
DB
789 if (!ref) {
790 packet_flush(fd[1]);
791 die("no matching remote head");
9e5d2b40 792 }
ba227857 793 ref_cpy = do_fetch_pack(fd, ref, nr_heads, heads, pack_lockfile);
9e5d2b40 794
ba227857 795 if (args.depth > 0) {
016e6ccb
JS
796 struct cache_time mtime;
797 char *shallow = git_path("shallow");
798 int fd;
799
800 mtime.sec = st.st_mtime;
801#ifdef USE_NSEC
802 mtime.usec = st.st_mtim.usec;
803#endif
804 if (stat(shallow, &st)) {
805 if (mtime.sec)
806 die("shallow file was removed during fetch");
807 } else if (st.st_mtime != mtime.sec
808#ifdef USE_NSEC
809 || st.st_mtim.usec != mtime.usec
810#endif
811 )
812 die("shallow file was changed during fetch");
813
814 fd = hold_lock_file_for_update(&lock, shallow, 1);
815 if (!write_shallow_commits(fd, 0)) {
d6491e3a 816 unlink(shallow);
016e6ccb
JS
817 rollback_lock_file(&lock);
818 } else {
016e6ccb
JS
819 commit_lock_file(&lock);
820 }
821 }
822
ba227857 823 return ref_cpy;
def88e9a 824}