fetch-pack: Avoid memcpy() with src==dst
[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[] =
1b1dd23f 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 }
8cb560fc
JS
312 /* it is no error to fetch into a completely empty repo */
313 return count ? retval : 0;
def88e9a
LT
314}
315
96f1e58f 316static struct commit_list *complete;
49bb805e 317
8da19775 318static int mark_complete(const char *path, const unsigned char *sha1, int flag, void *cb_data)
49bb805e
JH
319{
320 struct object *o = parse_object(sha1);
321
1974632c 322 while (o && o->type == OBJ_TAG) {
f1f0a2be
JH
323 struct tag *t = (struct tag *) o;
324 if (!t->tagged)
325 break; /* broken repository */
49bb805e 326 o->flags |= COMPLETE;
f1f0a2be 327 o = parse_object(t->tagged->sha1);
49bb805e 328 }
1974632c 329 if (o && o->type == OBJ_COMMIT) {
49bb805e
JH
330 struct commit *commit = (struct commit *)o;
331 commit->object.flags |= COMPLETE;
332 insert_by_date(commit, &complete);
333 }
334 return 0;
335}
336
337static void mark_recent_complete_commits(unsigned long cutoff)
338{
339 while (complete && cutoff <= complete->item->date) {
fa740529 340 if (args.verbose)
49bb805e
JH
341 fprintf(stderr, "Marking %s as complete\n",
342 sha1_to_hex(complete->item->object.sha1));
343 pop_most_recent_commit(&complete, COMPLETE);
344 }
345}
346
1baaae5e
JS
347static void filter_refs(struct ref **refs, int nr_match, char **match)
348{
9546010b
JH
349 struct ref **return_refs;
350 struct ref *newlist = NULL;
351 struct ref **newtail = &newlist;
352 struct ref *ref, *next;
353 struct ref *fastarray[32];
354
fa740529 355 if (nr_match && !args.fetch_all) {
9546010b
JH
356 if (ARRAY_SIZE(fastarray) < nr_match)
357 return_refs = xcalloc(nr_match, sizeof(struct ref *));
358 else {
359 return_refs = fastarray;
360 memset(return_refs, 0, sizeof(struct ref *) * nr_match);
361 }
362 }
363 else
364 return_refs = NULL;
365
366 for (ref = *refs; ref; ref = next) {
367 next = ref->next;
368 if (!memcmp(ref->name, "refs/", 5) &&
369 check_ref_format(ref->name + 5))
370 ; /* trash */
fa740529
SP
371 else if (args.fetch_all &&
372 (!args.depth || prefixcmp(ref->name, "refs/tags/") )) {
9546010b
JH
373 *newtail = ref;
374 ref->next = NULL;
375 newtail = &ref->next;
376 continue;
377 }
378 else {
379 int order = path_match(ref->name, nr_match, match);
380 if (order) {
381 return_refs[order-1] = ref;
382 continue; /* we will link it later */
383 }
384 }
385 free(ref);
386 }
387
fa740529 388 if (!args.fetch_all) {
9546010b
JH
389 int i;
390 for (i = 0; i < nr_match; i++) {
391 ref = return_refs[i];
392 if (ref) {
393 *newtail = ref;
394 ref->next = NULL;
395 newtail = &ref->next;
396 }
397 }
398 if (return_refs != fastarray)
399 free(return_refs);
1baaae5e 400 }
9546010b 401 *refs = newlist;
1baaae5e
JS
402}
403
404static int everything_local(struct ref **refs, int nr_match, char **match)
2759cbc7 405{
49bb805e 406 struct ref *ref;
2759cbc7 407 int retval;
49bb805e
JH
408 unsigned long cutoff = 0;
409
49bb805e
JH
410 save_commit_buffer = 0;
411
1baaae5e 412 for (ref = *refs; ref; ref = ref->next) {
49bb805e
JH
413 struct object *o;
414
415 o = parse_object(ref->old_sha1);
416 if (!o)
417 continue;
418
419 /* We already have it -- which may mean that we were
420 * in sync with the other side at some time after
421 * that (it is OK if we guess wrong here).
422 */
1974632c 423 if (o->type == OBJ_COMMIT) {
49bb805e
JH
424 struct commit *commit = (struct commit *)o;
425 if (!cutoff || cutoff < commit->date)
426 cutoff = commit->date;
427 }
428 }
429
fa740529 430 if (!args.depth) {
f53514bc
JS
431 for_each_ref(mark_complete, NULL);
432 if (cutoff)
433 mark_recent_complete_commits(cutoff);
434 }
2759cbc7 435
1baaae5e
JS
436 /*
437 * Mark all complete remote refs as common refs.
438 * Don't mark them common yet; the server has to be told so first.
439 */
440 for (ref = *refs; ref; ref = ref->next) {
9534f40b
JH
441 struct object *o = deref_tag(lookup_object(ref->old_sha1),
442 NULL, 0);
1baaae5e 443
1974632c 444 if (!o || o->type != OBJ_COMMIT || !(o->flags & COMPLETE))
1baaae5e
JS
445 continue;
446
447 if (!(o->flags & SEEN)) {
448 rev_list_push((struct commit *)o, COMMON_REF | SEEN);
449
450 mark_common((struct commit *)o, 1, 1);
451 }
452 }
453
454 filter_refs(refs, nr_match, match);
455
456 for (retval = 1, ref = *refs; ref ; ref = ref->next) {
457 const unsigned char *remote = ref->old_sha1;
2759cbc7 458 unsigned char local[20];
49bb805e 459 struct object *o;
2759cbc7 460
1baaae5e 461 o = lookup_object(remote);
49bb805e 462 if (!o || !(o->flags & COMPLETE)) {
2759cbc7 463 retval = 0;
fa740529 464 if (!args.verbose)
2759cbc7
LT
465 continue;
466 fprintf(stderr,
467 "want %s (%s)\n", sha1_to_hex(remote),
1baaae5e 468 ref->name);
2759cbc7
LT
469 continue;
470 }
471
e702496e 472 hashcpy(ref->new_sha1, local);
fa740529 473 if (!args.verbose)
2759cbc7
LT
474 continue;
475 fprintf(stderr,
476 "already have %s (%s)\n", sha1_to_hex(remote),
1baaae5e 477 ref->name);
2759cbc7
LT
478 }
479 return retval;
480}
481
088fab5f 482static int sideband_demux(int fd, void *data)
da093d37 483{
088fab5f 484 int *xd = data;
da093d37 485
088fab5f
JS
486 return recv_sideband("fetch-pack", xd[0], fd, 2);
487}
488
1788c39c 489static int get_pack(int xd[2], char **pack_lockfile)
da093d37 490{
088fab5f 491 struct async demux;
9e10fd1a
JH
492 const char *argv[20];
493 char keep_arg[256];
494 char hdr_arg[256];
495 const char **av;
fa740529 496 int do_keep = args.keep_pack;
477822c3 497 struct child_process cmd;
da093d37 498
1f759eee
JS
499 memset(&demux, 0, sizeof(demux));
500 if (use_sideband) {
501 /* xd[] is talking with upload-pack; subprocess reads from
502 * xd[0], spits out band#2 to stderr, and feeds us band#1
503 * through demux->out.
504 */
505 demux.proc = sideband_demux;
506 demux.data = xd;
507 if (start_async(&demux))
508 die("fetch-pack: unable to fork off sideband"
509 " demultiplexer");
510 }
511 else
512 demux.out = xd[0];
9e10fd1a 513
477822c3
JS
514 memset(&cmd, 0, sizeof(cmd));
515 cmd.argv = argv;
9e10fd1a
JH
516 av = argv;
517 *hdr_arg = 0;
fa740529 518 if (!args.keep_pack && unpack_limit) {
9e10fd1a
JH
519 struct pack_header header;
520
1f759eee 521 if (read_pack_header(demux.out, &header))
9e10fd1a 522 die("protocol error: bad pack header");
6e1c2344
RJ
523 snprintf(hdr_arg, sizeof(hdr_arg),
524 "--pack_header=%"PRIu32",%"PRIu32,
9e10fd1a 525 ntohl(header.hdr_version), ntohl(header.hdr_entries));
af7cf268 526 if (ntohl(header.hdr_entries) < unpack_limit)
9e10fd1a
JH
527 do_keep = 0;
528 else
529 do_keep = 1;
530 }
531
532 if (do_keep) {
477822c3
JS
533 if (pack_lockfile)
534 cmd.out = -1;
9e10fd1a
JH
535 *av++ = "index-pack";
536 *av++ = "--stdin";
fa740529 537 if (!args.quiet && !args.no_progress)
9e10fd1a 538 *av++ = "-v";
fa740529 539 if (args.use_thin_pack)
9e10fd1a 540 *av++ = "--fix-thin";
fa740529 541 if (args.lock_pack || unpack_limit) {
9e10fd1a
JH
542 int s = sprintf(keep_arg,
543 "--keep=fetch-pack %d on ", getpid());
544 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
545 strcpy(keep_arg + s, "localhost");
546 *av++ = keep_arg;
547 }
548 }
549 else {
550 *av++ = "unpack-objects";
fa740529 551 if (args.quiet)
9e10fd1a
JH
552 *av++ = "-q";
553 }
554 if (*hdr_arg)
555 *av++ = hdr_arg;
556 *av++ = NULL;
557
1f759eee 558 cmd.in = demux.out;
477822c3
JS
559 cmd.git_cmd = 1;
560 if (start_command(&cmd))
da093d37 561 die("fetch-pack: unable to fork off %s", argv[0]);
e72ae288 562 if (do_keep && pack_lockfile) {
477822c3 563 *pack_lockfile = index_pack_lockfile(cmd.out);
e72ae288
JS
564 close(cmd.out);
565 }
477822c3
JS
566
567 if (finish_command(&cmd))
568 die("%s failed", argv[0]);
088fab5f
JS
569 if (use_sideband && finish_async(&demux))
570 die("error in sideband demultiplexer");
477822c3 571 return 0;
da093d37
NP
572}
573
1788c39c 574static struct ref *do_fetch_pack(int fd[2],
ba227857 575 const struct ref *orig_ref,
1788c39c
SP
576 int nr_match,
577 char **match,
578 char **pack_lockfile)
def88e9a 579{
ba227857 580 struct ref *ref = copy_ref_list(orig_ref);
d1c133f5 581 unsigned char sha1[20];
def88e9a 582
ed09aef0
JS
583 if (is_repository_shallow() && !server_supports("shallow"))
584 die("Server does not support shallow clients");
c4c86f07 585 if (server_supports("multi_ack")) {
fa740529 586 if (args.verbose)
c4c86f07
JS
587 fprintf(stderr, "Server supports multi_ack\n");
588 multi_ack = 1;
589 }
d47f3db7 590 if (server_supports("side-band-64k")) {
fa740529 591 if (args.verbose)
d47f3db7
JH
592 fprintf(stderr, "Server supports side-band-64k\n");
593 use_sideband = 2;
594 }
595 else if (server_supports("side-band")) {
fa740529 596 if (args.verbose)
583b7ea3
JH
597 fprintf(stderr, "Server supports side-band\n");
598 use_sideband = 1;
599 }
1baaae5e 600 if (everything_local(&ref, nr_match, match)) {
2759cbc7
LT
601 packet_flush(fd[1]);
602 goto all_done;
603 }
33b83034 604 if (find_common(fd, sha1, ref) < 0)
fa740529 605 if (!args.keep_pack)
dfeff66e
JH
606 /* When cloning, it is not unusual to have
607 * no common commit.
608 */
609 fprintf(stderr, "warning: no common commits\n");
ad897215 610
1788c39c 611 if (get_pack(fd, pack_lockfile))
7e44c935 612 die("git fetch-pack: fetch failed.");
ad897215
JH
613
614 all_done:
2d4177c0 615 return ref;
def88e9a
LT
616}
617
310b86d4
JH
618static int remove_duplicates(int nr_heads, char **heads)
619{
620 int src, dst;
621
622 for (src = dst = 0; src < nr_heads; src++) {
623 /* If heads[src] is different from any of
624 * heads[0..dst], push it in.
625 */
626 int i;
627 for (i = 0; i < dst; i++) {
628 if (!strcmp(heads[i], heads[src]))
629 break;
630 }
631 if (i < dst)
632 continue;
633 if (src != dst)
634 heads[dst] = heads[src];
635 dst++;
636 }
310b86d4
JH
637 return dst;
638}
639
ef90d6d4 640static int fetch_pack_config(const char *var, const char *value, void *cb)
af7cf268
JH
641{
642 if (strcmp(var, "fetch.unpacklimit") == 0) {
e28714c5
JH
643 fetch_unpack_limit = git_config_int(var, value);
644 return 0;
645 }
646
647 if (strcmp(var, "transfer.unpacklimit") == 0) {
648 transfer_unpack_limit = git_config_int(var, value);
af7cf268
JH
649 return 0;
650 }
651
ef90d6d4 652 return git_default_config(var, value, cb);
af7cf268
JH
653}
654
54b9e022
JH
655static struct lock_file lock;
656
50ab5fd3 657static void fetch_pack_setup(void)
def88e9a 658{
50ab5fd3
SP
659 static int did_setup;
660 if (did_setup)
661 return;
ef90d6d4 662 git_config(fetch_pack_config, NULL);
e28714c5
JH
663 if (0 <= transfer_unpack_limit)
664 unpack_limit = transfer_unpack_limit;
665 else if (0 <= fetch_unpack_limit)
666 unpack_limit = fetch_unpack_limit;
50ab5fd3
SP
667 did_setup = 1;
668}
669
670int cmd_fetch_pack(int argc, const char **argv, const char *prefix)
671{
672 int i, ret, nr_heads;
ba227857 673 struct ref *ref = NULL;
50ab5fd3 674 char *dest = NULL, **heads;
ba227857
DB
675 int fd[2];
676 struct child_process *conn;
e28714c5 677
def88e9a
LT
678 nr_heads = 0;
679 heads = NULL;
680 for (i = 1; i < argc; i++) {
2d4177c0 681 const char *arg = argv[i];
def88e9a
LT
682
683 if (*arg == '-') {
599065a3 684 if (!prefixcmp(arg, "--upload-pack=")) {
fa740529 685 args.uploadpack = arg + 14;
27dca07f
UKK
686 continue;
687 }
599065a3 688 if (!prefixcmp(arg, "--exec=")) {
fa740529 689 args.uploadpack = arg + 7;
8b3d9dc0
JH
690 continue;
691 }
2247efb4 692 if (!strcmp("--quiet", arg) || !strcmp("-q", arg)) {
fa740529 693 args.quiet = 1;
33b83034
JH
694 continue;
695 }
2247efb4 696 if (!strcmp("--keep", arg) || !strcmp("-k", arg)) {
fa740529
SP
697 args.lock_pack = args.keep_pack;
698 args.keep_pack = 1;
9e10fd1a
JH
699 continue;
700 }
b19696c2 701 if (!strcmp("--thin", arg)) {
fa740529 702 args.use_thin_pack = 1;
b19696c2
JH
703 continue;
704 }
348e390b
SP
705 if (!strcmp("--include-tag", arg)) {
706 args.include_tag = 1;
707 continue;
708 }
dfeff66e 709 if (!strcmp("--all", arg)) {
fa740529 710 args.fetch_all = 1;
dfeff66e
JH
711 continue;
712 }
33b83034 713 if (!strcmp("-v", arg)) {
fa740529 714 args.verbose = 1;
33b83034
JH
715 continue;
716 }
599065a3 717 if (!prefixcmp(arg, "--depth=")) {
fa740529 718 args.depth = strtol(arg + 8, NULL, 0);
016e6ccb
JS
719 continue;
720 }
83a5ad61 721 if (!strcmp("--no-progress", arg)) {
fa740529 722 args.no_progress = 1;
83a5ad61
JS
723 continue;
724 }
def88e9a
LT
725 usage(fetch_pack_usage);
726 }
2d4177c0
DB
727 dest = (char *)arg;
728 heads = (char **)(argv + i + 1);
def88e9a
LT
729 nr_heads = argc - i - 1;
730 break;
731 }
732 if (!dest)
733 usage(fetch_pack_usage);
2d4177c0 734
ba227857
DB
735 conn = git_connect(fd, (char *)dest, args.uploadpack,
736 args.verbose ? CONNECT_VERBOSE : 0);
737 if (conn) {
738 get_remote_heads(fd[0], &ref, 0, NULL, 0);
739
740 ref = fetch_pack(&args, fd, conn, ref, dest, nr_heads, heads, NULL);
741 close(fd[0]);
742 close(fd[1]);
743 if (finish_connect(conn))
744 ref = NULL;
745 } else {
746 ref = NULL;
747 }
2d4177c0
DB
748 ret = !ref;
749
ba227857
DB
750 if (!ret && nr_heads) {
751 /* If the heads to pull were given, we should have
752 * consumed all of them by matching the remote.
05207a28 753 * Otherwise, 'git fetch remote no-such-ref' would
ba227857
DB
754 * silently succeed without issuing an error.
755 */
756 for (i = 0; i < nr_heads; i++)
757 if (heads[i] && heads[i][0]) {
758 error("no such remote ref %s", heads[i]);
759 ret = 1;
760 }
761 }
2d4177c0
DB
762 while (ref) {
763 printf("%s %s\n",
764 sha1_to_hex(ref->old_sha1), ref->name);
765 ref = ref->next;
766 }
767
768 return ret;
769}
770
fa740529 771struct ref *fetch_pack(struct fetch_pack_args *my_args,
ba227857
DB
772 int fd[], struct child_process *conn,
773 const struct ref *ref,
fa740529 774 const char *dest,
1788c39c
SP
775 int nr_heads,
776 char **heads,
777 char **pack_lockfile)
2d4177c0 778{
2d4177c0 779 struct stat st;
ba227857 780 struct ref *ref_cpy;
2d4177c0 781
50ab5fd3 782 fetch_pack_setup();
d551bbaf
TR
783 if (&args != my_args)
784 memcpy(&args, my_args, sizeof(args));
fa740529 785 if (args.depth > 0) {
2d4177c0
DB
786 if (stat(git_path("shallow"), &st))
787 st.st_mtime = 0;
788 }
789
310b86d4
JH
790 if (heads && nr_heads)
791 nr_heads = remove_duplicates(nr_heads, heads);
ba227857
DB
792 if (!ref) {
793 packet_flush(fd[1]);
794 die("no matching remote head");
9e5d2b40 795 }
ba227857 796 ref_cpy = do_fetch_pack(fd, ref, nr_heads, heads, pack_lockfile);
9e5d2b40 797
ba227857 798 if (args.depth > 0) {
016e6ccb
JS
799 struct cache_time mtime;
800 char *shallow = git_path("shallow");
801 int fd;
802
803 mtime.sec = st.st_mtime;
804#ifdef USE_NSEC
805 mtime.usec = st.st_mtim.usec;
806#endif
807 if (stat(shallow, &st)) {
808 if (mtime.sec)
809 die("shallow file was removed during fetch");
810 } else if (st.st_mtime != mtime.sec
811#ifdef USE_NSEC
812 || st.st_mtim.usec != mtime.usec
813#endif
814 )
815 die("shallow file was changed during fetch");
816
acd3b9ec
JH
817 fd = hold_lock_file_for_update(&lock, shallow,
818 LOCK_DIE_ON_ERROR);
016e6ccb 819 if (!write_shallow_commits(fd, 0)) {
d6491e3a 820 unlink(shallow);
016e6ccb
JS
821 rollback_lock_file(&lock);
822 } else {
016e6ccb
JS
823 commit_lock_file(&lock);
824 }
825 }
826
48ec3e5c 827 reprepare_packed_git();
ba227857 828 return ref_cpy;
def88e9a 829}