allow deepening of a shallow repository
[git/git.git] / fetch-pack.c
1 #include "cache.h"
2 #include "refs.h"
3 #include "pkt-line.h"
4 #include "commit.h"
5 #include "tag.h"
6 #include "exec_cmd.h"
7 #include "sideband.h"
8 #include <sys/wait.h>
9
10 static int keep_pack;
11 static int quiet;
12 static int verbose;
13 static int fetch_all;
14 static int depth;
15 static const char fetch_pack_usage[] =
16 "git-fetch-pack [--all] [-q] [-v] [-k] [--thin] [--exec=upload-pack] [--depth=<n>] [host:]directory <refs>...";
17 static const char *exec = "git-upload-pack";
18
19 #define COMPLETE (1U << 0)
20 #define COMMON (1U << 1)
21 #define COMMON_REF (1U << 2)
22 #define SEEN (1U << 3)
23 #define POPPED (1U << 4)
24
25 /*
26 * After sending this many "have"s if we do not get any new ACK , we
27 * give up traversing our history.
28 */
29 #define MAX_IN_VAIN 256
30
31 static struct commit_list *rev_list;
32 static int non_common_revs, multi_ack, use_thin_pack, use_sideband;
33
34 static void rev_list_push(struct commit *commit, int mark)
35 {
36 if (!(commit->object.flags & mark)) {
37 commit->object.flags |= mark;
38
39 if (!(commit->object.parsed))
40 parse_commit(commit);
41
42 insert_by_date(commit, &rev_list);
43
44 if (!(commit->object.flags & COMMON))
45 non_common_revs++;
46 }
47 }
48
49 static int rev_list_insert_ref(const char *path, const unsigned char *sha1, int flag, void *cb_data)
50 {
51 struct object *o = deref_tag(parse_object(sha1), path, 0);
52
53 if (o && o->type == OBJ_COMMIT)
54 rev_list_push((struct commit *)o, SEEN);
55
56 return 0;
57 }
58
59 /*
60 This function marks a rev and its ancestors as common.
61 In some cases, it is desirable to mark only the ancestors (for example
62 when only the server does not yet know that they are common).
63 */
64
65 static void mark_common(struct commit *commit,
66 int ancestors_only, int dont_parse)
67 {
68 if (commit != NULL && !(commit->object.flags & COMMON)) {
69 struct object *o = (struct object *)commit;
70
71 if (!ancestors_only)
72 o->flags |= COMMON;
73
74 if (!(o->flags & SEEN))
75 rev_list_push(commit, SEEN);
76 else {
77 struct commit_list *parents;
78
79 if (!ancestors_only && !(o->flags & POPPED))
80 non_common_revs--;
81 if (!o->parsed && !dont_parse)
82 parse_commit(commit);
83
84 for (parents = commit->parents;
85 parents;
86 parents = parents->next)
87 mark_common(parents->item, 0, dont_parse);
88 }
89 }
90 }
91
92 /*
93 Get the next rev to send, ignoring the common.
94 */
95
96 static const unsigned char* get_rev(void)
97 {
98 struct commit *commit = NULL;
99
100 while (commit == NULL) {
101 unsigned int mark;
102 struct commit_list* parents;
103
104 if (rev_list == NULL || non_common_revs == 0)
105 return NULL;
106
107 commit = rev_list->item;
108 if (!(commit->object.parsed))
109 parse_commit(commit);
110 commit->object.flags |= POPPED;
111 if (!(commit->object.flags & COMMON))
112 non_common_revs--;
113
114 parents = commit->parents;
115
116 if (commit->object.flags & COMMON) {
117 /* do not send "have", and ignore ancestors */
118 commit = NULL;
119 mark = COMMON | SEEN;
120 } else if (commit->object.flags & COMMON_REF)
121 /* send "have", and ignore ancestors */
122 mark = COMMON | SEEN;
123 else
124 /* send "have", also for its ancestors */
125 mark = SEEN;
126
127 while (parents) {
128 if (!(parents->item->object.flags & SEEN))
129 rev_list_push(parents->item, mark);
130 if (mark & COMMON)
131 mark_common(parents->item, 1, 0);
132 parents = parents->next;
133 }
134
135 rev_list = rev_list->next;
136 }
137
138 return commit->object.sha1;
139 }
140
141 static int find_common(int fd[2], unsigned char *result_sha1,
142 struct ref *refs)
143 {
144 int fetching;
145 int count = 0, flushes = 0, retval;
146 const unsigned char *sha1;
147 unsigned in_vain = 0;
148 int got_continue = 0;
149
150 for_each_ref(rev_list_insert_ref, NULL);
151
152 fetching = 0;
153 for ( ; refs ; refs = refs->next) {
154 unsigned char *remote = refs->old_sha1;
155 struct object *o;
156
157 /*
158 * If that object is complete (i.e. it is an ancestor of a
159 * local ref), we tell them we have it but do not have to
160 * tell them about its ancestors, which they already know
161 * about.
162 *
163 * We use lookup_object here because we are only
164 * interested in the case we *know* the object is
165 * reachable and we have already scanned it.
166 */
167 if (((o = lookup_object(remote)) != NULL) &&
168 (o->flags & COMPLETE)) {
169 continue;
170 }
171
172 if (!fetching)
173 packet_write(fd[1], "want %s%s%s%s%s%s\n",
174 sha1_to_hex(remote),
175 (multi_ack ? " multi_ack" : ""),
176 (use_sideband == 2 ? " side-band-64k" : ""),
177 (use_sideband == 1 ? " side-band" : ""),
178 (use_thin_pack ? " thin-pack" : ""),
179 " ofs-delta");
180 else
181 packet_write(fd[1], "want %s\n", sha1_to_hex(remote));
182 fetching++;
183 }
184 if (is_repository_shallow())
185 write_shallow_commits(fd[1], 1);
186 if (depth > 0)
187 packet_write(fd[1], "deepen %d", depth);
188 packet_flush(fd[1]);
189 if (!fetching)
190 return 1;
191
192 if (depth > 0) {
193 char line[1024];
194 unsigned char sha1[20];
195 int len;
196
197 while ((len = packet_read_line(fd[0], line, sizeof(line)))) {
198 if (!strncmp("shallow ", line, 8)) {
199 if (get_sha1_hex(line + 8, sha1))
200 die("invalid shallow line: %s", line);
201 /* no need making it shallow if we have it already */
202 if (lookup_object(sha1))
203 continue;
204 register_shallow(sha1);
205 } else if (!strncmp("unshallow ", line, 10)) {
206 if (get_sha1_hex(line + 10, sha1))
207 die("invalid unshallow line: %s", line);
208 if (!lookup_object(sha1))
209 die("object not found: %s", line);
210 /* make sure that it is parsed as shallow */
211 parse_object(sha1);
212 if (unregister_shallow(sha1))
213 die("no shallow found: %s", line);
214 } else
215 die("expected shallow/unshallow, got %s", line);
216 }
217 }
218
219 flushes = 0;
220 retval = -1;
221 while ((sha1 = get_rev())) {
222 packet_write(fd[1], "have %s\n", sha1_to_hex(sha1));
223 if (verbose)
224 fprintf(stderr, "have %s\n", sha1_to_hex(sha1));
225 in_vain++;
226 if (!(31 & ++count)) {
227 int ack;
228
229 packet_flush(fd[1]);
230 flushes++;
231
232 /*
233 * We keep one window "ahead" of the other side, and
234 * will wait for an ACK only on the next one
235 */
236 if (count == 32)
237 continue;
238
239 do {
240 ack = get_ack(fd[0], result_sha1);
241 if (verbose && ack)
242 fprintf(stderr, "got ack %d %s\n", ack,
243 sha1_to_hex(result_sha1));
244 if (ack == 1) {
245 flushes = 0;
246 multi_ack = 0;
247 retval = 0;
248 goto done;
249 } else if (ack == 2) {
250 struct commit *commit =
251 lookup_commit(result_sha1);
252 mark_common(commit, 0, 1);
253 retval = 0;
254 in_vain = 0;
255 got_continue = 1;
256 }
257 } while (ack);
258 flushes--;
259 if (got_continue && MAX_IN_VAIN < in_vain) {
260 if (verbose)
261 fprintf(stderr, "giving up\n");
262 break; /* give up */
263 }
264 }
265 }
266 done:
267 packet_write(fd[1], "done\n");
268 if (verbose)
269 fprintf(stderr, "done\n");
270 if (retval != 0) {
271 multi_ack = 0;
272 flushes++;
273 }
274 while (flushes || multi_ack) {
275 int ack = get_ack(fd[0], result_sha1);
276 if (ack) {
277 if (verbose)
278 fprintf(stderr, "got ack (%d) %s\n", ack,
279 sha1_to_hex(result_sha1));
280 if (ack == 1)
281 return 0;
282 multi_ack = 1;
283 continue;
284 }
285 flushes--;
286 }
287 return retval;
288 }
289
290 static struct commit_list *complete;
291
292 static int mark_complete(const char *path, const unsigned char *sha1, int flag, void *cb_data)
293 {
294 struct object *o = parse_object(sha1);
295
296 while (o && o->type == OBJ_TAG) {
297 struct tag *t = (struct tag *) o;
298 if (!t->tagged)
299 break; /* broken repository */
300 o->flags |= COMPLETE;
301 o = parse_object(t->tagged->sha1);
302 }
303 if (o && o->type == OBJ_COMMIT) {
304 struct commit *commit = (struct commit *)o;
305 commit->object.flags |= COMPLETE;
306 insert_by_date(commit, &complete);
307 }
308 return 0;
309 }
310
311 static void mark_recent_complete_commits(unsigned long cutoff)
312 {
313 while (complete && cutoff <= complete->item->date) {
314 if (verbose)
315 fprintf(stderr, "Marking %s as complete\n",
316 sha1_to_hex(complete->item->object.sha1));
317 pop_most_recent_commit(&complete, COMPLETE);
318 }
319 }
320
321 static void filter_refs(struct ref **refs, int nr_match, char **match)
322 {
323 struct ref **return_refs;
324 struct ref *newlist = NULL;
325 struct ref **newtail = &newlist;
326 struct ref *ref, *next;
327 struct ref *fastarray[32];
328
329 if (nr_match && !fetch_all) {
330 if (ARRAY_SIZE(fastarray) < nr_match)
331 return_refs = xcalloc(nr_match, sizeof(struct ref *));
332 else {
333 return_refs = fastarray;
334 memset(return_refs, 0, sizeof(struct ref *) * nr_match);
335 }
336 }
337 else
338 return_refs = NULL;
339
340 for (ref = *refs; ref; ref = next) {
341 next = ref->next;
342 if (!memcmp(ref->name, "refs/", 5) &&
343 check_ref_format(ref->name + 5))
344 ; /* trash */
345 else if (fetch_all) {
346 *newtail = ref;
347 ref->next = NULL;
348 newtail = &ref->next;
349 continue;
350 }
351 else {
352 int order = path_match(ref->name, nr_match, match);
353 if (order) {
354 return_refs[order-1] = ref;
355 continue; /* we will link it later */
356 }
357 }
358 free(ref);
359 }
360
361 if (!fetch_all) {
362 int i;
363 for (i = 0; i < nr_match; i++) {
364 ref = return_refs[i];
365 if (ref) {
366 *newtail = ref;
367 ref->next = NULL;
368 newtail = &ref->next;
369 }
370 }
371 if (return_refs != fastarray)
372 free(return_refs);
373 }
374 *refs = newlist;
375 }
376
377 static int everything_local(struct ref **refs, int nr_match, char **match)
378 {
379 struct ref *ref;
380 int retval;
381 unsigned long cutoff = 0;
382
383 track_object_refs = 0;
384 save_commit_buffer = 0;
385
386 for (ref = *refs; ref; ref = ref->next) {
387 struct object *o;
388
389 o = parse_object(ref->old_sha1);
390 if (!o)
391 continue;
392
393 /* We already have it -- which may mean that we were
394 * in sync with the other side at some time after
395 * that (it is OK if we guess wrong here).
396 */
397 if (o->type == OBJ_COMMIT) {
398 struct commit *commit = (struct commit *)o;
399 if (!cutoff || cutoff < commit->date)
400 cutoff = commit->date;
401 }
402 }
403
404 if (!depth) {
405 for_each_ref(mark_complete, NULL);
406 if (cutoff)
407 mark_recent_complete_commits(cutoff);
408 }
409
410 /*
411 * Mark all complete remote refs as common refs.
412 * Don't mark them common yet; the server has to be told so first.
413 */
414 for (ref = *refs; ref; ref = ref->next) {
415 struct object *o = deref_tag(lookup_object(ref->old_sha1),
416 NULL, 0);
417
418 if (!o || o->type != OBJ_COMMIT || !(o->flags & COMPLETE))
419 continue;
420
421 if (!(o->flags & SEEN)) {
422 rev_list_push((struct commit *)o, COMMON_REF | SEEN);
423
424 mark_common((struct commit *)o, 1, 1);
425 }
426 }
427
428 filter_refs(refs, nr_match, match);
429
430 for (retval = 1, ref = *refs; ref ; ref = ref->next) {
431 const unsigned char *remote = ref->old_sha1;
432 unsigned char local[20];
433 struct object *o;
434
435 o = lookup_object(remote);
436 if (!o || !(o->flags & COMPLETE)) {
437 retval = 0;
438 if (!verbose)
439 continue;
440 fprintf(stderr,
441 "want %s (%s)\n", sha1_to_hex(remote),
442 ref->name);
443 continue;
444 }
445
446 hashcpy(ref->new_sha1, local);
447 if (!verbose)
448 continue;
449 fprintf(stderr,
450 "already have %s (%s)\n", sha1_to_hex(remote),
451 ref->name);
452 }
453 return retval;
454 }
455
456 static pid_t setup_sideband(int fd[2], int xd[2])
457 {
458 pid_t side_pid;
459
460 if (!use_sideband) {
461 fd[0] = xd[0];
462 fd[1] = xd[1];
463 return 0;
464 }
465 /* xd[] is talking with upload-pack; subprocess reads from
466 * xd[0], spits out band#2 to stderr, and feeds us band#1
467 * through our fd[0].
468 */
469 if (pipe(fd) < 0)
470 die("fetch-pack: unable to set up pipe");
471 side_pid = fork();
472 if (side_pid < 0)
473 die("fetch-pack: unable to fork off sideband demultiplexer");
474 if (!side_pid) {
475 /* subprocess */
476 close(fd[0]);
477 if (xd[0] != xd[1])
478 close(xd[1]);
479 if (recv_sideband("fetch-pack", xd[0], fd[1], 2))
480 exit(1);
481 exit(0);
482 }
483 close(xd[0]);
484 close(fd[1]);
485 fd[1] = xd[1];
486 return side_pid;
487 }
488
489 static int get_pack(int xd[2], const char **argv)
490 {
491 int status;
492 pid_t pid, side_pid;
493 int fd[2];
494
495 side_pid = setup_sideband(fd, xd);
496 pid = fork();
497 if (pid < 0)
498 die("fetch-pack: unable to fork off %s", argv[0]);
499 if (!pid) {
500 dup2(fd[0], 0);
501 close(fd[0]);
502 close(fd[1]);
503 execv_git_cmd(argv);
504 die("%s exec failed", argv[0]);
505 }
506 close(fd[0]);
507 close(fd[1]);
508 while (waitpid(pid, &status, 0) < 0) {
509 if (errno != EINTR)
510 die("waiting for %s: %s", argv[0], strerror(errno));
511 }
512 if (WIFEXITED(status)) {
513 int code = WEXITSTATUS(status);
514 if (code)
515 die("%s died with error code %d", argv[0], code);
516 return 0;
517 }
518 if (WIFSIGNALED(status)) {
519 int sig = WTERMSIG(status);
520 die("%s died of signal %d", argv[0], sig);
521 }
522 die("%s died of unnatural causes %d", argv[0], status);
523 }
524
525 static int explode_rx_pack(int xd[2])
526 {
527 const char *argv[3] = { "unpack-objects", quiet ? "-q" : NULL, NULL };
528 return get_pack(xd, argv);
529 }
530
531 static int keep_rx_pack(int xd[2])
532 {
533 const char *argv[6];
534 char keep_arg[256];
535 int n = 0;
536
537 argv[n++] = "index-pack";
538 argv[n++] = "--stdin";
539 if (!quiet)
540 argv[n++] = "-v";
541 if (use_thin_pack)
542 argv[n++] = "--fix-thin";
543 if (keep_pack > 1) {
544 int s = sprintf(keep_arg, "--keep=fetch-pack %i on ", getpid());
545 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
546 strcpy(keep_arg + s, "localhost");
547 argv[n++] = keep_arg;
548 }
549 argv[n] = NULL;
550 return get_pack(xd, argv);
551 }
552
553 static int fetch_pack(int fd[2], int nr_match, char **match)
554 {
555 struct ref *ref;
556 unsigned char sha1[20];
557 int status;
558
559 get_remote_heads(fd[0], &ref, 0, NULL, 0);
560 if (is_repository_shallow() && !server_supports("shallow"))
561 die("Server does not support shallow clients");
562 if (server_supports("multi_ack")) {
563 if (verbose)
564 fprintf(stderr, "Server supports multi_ack\n");
565 multi_ack = 1;
566 }
567 if (server_supports("side-band-64k")) {
568 if (verbose)
569 fprintf(stderr, "Server supports side-band-64k\n");
570 use_sideband = 2;
571 }
572 else if (server_supports("side-band")) {
573 if (verbose)
574 fprintf(stderr, "Server supports side-band\n");
575 use_sideband = 1;
576 }
577 if (!ref) {
578 packet_flush(fd[1]);
579 die("no matching remote head");
580 }
581 if (everything_local(&ref, nr_match, match)) {
582 packet_flush(fd[1]);
583 goto all_done;
584 }
585 if (find_common(fd, sha1, ref) < 0)
586 if (keep_pack != 1)
587 /* When cloning, it is not unusual to have
588 * no common commit.
589 */
590 fprintf(stderr, "warning: no common commits\n");
591
592 status = (keep_pack) ? keep_rx_pack(fd) : explode_rx_pack(fd);
593 if (status)
594 die("git-fetch-pack: fetch failed.");
595
596 all_done:
597 while (ref) {
598 printf("%s %s\n",
599 sha1_to_hex(ref->old_sha1), ref->name);
600 ref = ref->next;
601 }
602 return 0;
603 }
604
605 int main(int argc, char **argv)
606 {
607 int i, ret, nr_heads;
608 char *dest = NULL, **heads;
609 int fd[2];
610 pid_t pid;
611 struct stat st;
612 struct lock_file lock;
613
614 setup_git_directory();
615
616 nr_heads = 0;
617 heads = NULL;
618 for (i = 1; i < argc; i++) {
619 char *arg = argv[i];
620
621 if (*arg == '-') {
622 if (!strncmp("--exec=", arg, 7)) {
623 exec = arg + 7;
624 continue;
625 }
626 if (!strcmp("--quiet", arg) || !strcmp("-q", arg)) {
627 quiet = 1;
628 continue;
629 }
630 if (!strcmp("--keep", arg) || !strcmp("-k", arg)) {
631 keep_pack++;
632 continue;
633 }
634 if (!strcmp("--thin", arg)) {
635 use_thin_pack = 1;
636 continue;
637 }
638 if (!strcmp("--all", arg)) {
639 fetch_all = 1;
640 continue;
641 }
642 if (!strcmp("-v", arg)) {
643 verbose = 1;
644 continue;
645 }
646 if (!strncmp("--depth=", arg, 8)) {
647 depth = strtol(arg + 8, NULL, 0);
648 if (stat(git_path("shallow"), &st))
649 st.st_mtime = 0;
650 continue;
651 }
652 usage(fetch_pack_usage);
653 }
654 dest = arg;
655 heads = argv + i + 1;
656 nr_heads = argc - i - 1;
657 break;
658 }
659 if (!dest)
660 usage(fetch_pack_usage);
661 pid = git_connect(fd, dest, exec);
662 if (pid < 0)
663 return 1;
664 ret = fetch_pack(fd, nr_heads, heads);
665 close(fd[0]);
666 close(fd[1]);
667 ret |= finish_connect(pid);
668
669 if (!ret && nr_heads) {
670 /* If the heads to pull were given, we should have
671 * consumed all of them by matching the remote.
672 * Otherwise, 'git-fetch remote no-such-ref' would
673 * silently succeed without issuing an error.
674 */
675 for (i = 0; i < nr_heads; i++)
676 if (heads[i] && heads[i][0]) {
677 error("no such remote ref %s", heads[i]);
678 ret = 1;
679 }
680 }
681
682 if (!ret && depth > 0) {
683 struct cache_time mtime;
684 char *shallow = git_path("shallow");
685 int fd;
686
687 mtime.sec = st.st_mtime;
688 #ifdef USE_NSEC
689 mtime.usec = st.st_mtim.usec;
690 #endif
691 if (stat(shallow, &st)) {
692 if (mtime.sec)
693 die("shallow file was removed during fetch");
694 } else if (st.st_mtime != mtime.sec
695 #ifdef USE_NSEC
696 || st.st_mtim.usec != mtime.usec
697 #endif
698 )
699 die("shallow file was changed during fetch");
700
701 fd = hold_lock_file_for_update(&lock, shallow, 1);
702 if (!write_shallow_commits(fd, 0)) {
703 unlink(lock.filename);
704 rollback_lock_file(&lock);
705 } else {
706 close(fd);
707 commit_lock_file(&lock);
708 }
709 }
710
711 return !!ret;
712 }