Git 1.8.2-rc2
[git/jnareb-git.git] / fetch-pack.c
blob6d8926a5504a6cd93e19860f85d58816bdd5c222
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 "pack.h"
8 #include "sideband.h"
9 #include "fetch-pack.h"
10 #include "remote.h"
11 #include "run-command.h"
12 #include "transport.h"
13 #include "version.h"
15 static int transfer_unpack_limit = -1;
16 static int fetch_unpack_limit = -1;
17 static int unpack_limit = 100;
18 static int prefer_ofs_delta = 1;
19 static int no_done;
20 static int fetch_fsck_objects = -1;
21 static int transfer_fsck_objects = -1;
22 static int agent_supported;
24 #define COMPLETE (1U << 0)
25 #define COMMON (1U << 1)
26 #define COMMON_REF (1U << 2)
27 #define SEEN (1U << 3)
28 #define POPPED (1U << 4)
30 static int marked;
33 * After sending this many "have"s if we do not get any new ACK , we
34 * give up traversing our history.
36 #define MAX_IN_VAIN 256
38 static struct commit_list *rev_list;
39 static int non_common_revs, multi_ack, use_sideband;
41 static void rev_list_push(struct commit *commit, int mark)
43 if (!(commit->object.flags & mark)) {
44 commit->object.flags |= mark;
46 if (!(commit->object.parsed))
47 if (parse_commit(commit))
48 return;
50 commit_list_insert_by_date(commit, &rev_list);
52 if (!(commit->object.flags & COMMON))
53 non_common_revs++;
57 static int rev_list_insert_ref(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
59 struct object *o = deref_tag(parse_object(sha1), refname, 0);
61 if (o && o->type == OBJ_COMMIT)
62 rev_list_push((struct commit *)o, SEEN);
64 return 0;
67 static int clear_marks(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
69 struct object *o = deref_tag(parse_object(sha1), refname, 0);
71 if (o && o->type == OBJ_COMMIT)
72 clear_commit_marks((struct commit *)o,
73 COMMON | COMMON_REF | SEEN | POPPED);
74 return 0;
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).
83 static void mark_common(struct commit *commit,
84 int ancestors_only, int dont_parse)
86 if (commit != NULL && !(commit->object.flags & COMMON)) {
87 struct object *o = (struct object *)commit;
89 if (!ancestors_only)
90 o->flags |= COMMON;
92 if (!(o->flags & SEEN))
93 rev_list_push(commit, SEEN);
94 else {
95 struct commit_list *parents;
97 if (!ancestors_only && !(o->flags & POPPED))
98 non_common_revs--;
99 if (!o->parsed && !dont_parse)
100 if (parse_commit(commit))
101 return;
103 for (parents = commit->parents;
104 parents;
105 parents = parents->next)
106 mark_common(parents->item, 0, dont_parse);
112 Get the next rev to send, ignoring the common.
115 static const unsigned char *get_rev(void)
117 struct commit *commit = NULL;
119 while (commit == NULL) {
120 unsigned int mark;
121 struct commit_list *parents;
123 if (rev_list == NULL || non_common_revs == 0)
124 return NULL;
126 commit = rev_list->item;
127 if (!commit->object.parsed)
128 parse_commit(commit);
129 parents = commit->parents;
131 commit->object.flags |= POPPED;
132 if (!(commit->object.flags & COMMON))
133 non_common_revs--;
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;
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;
154 rev_list = rev_list->next;
157 return commit->object.sha1;
160 enum ack_type {
161 NAK = 0,
162 ACK,
163 ACK_continue,
164 ACK_common,
165 ACK_ready
168 static void consume_shallow_list(struct fetch_pack_args *args, int fd)
170 if (args->stateless_rpc && args->depth > 0) {
171 /* If we sent a depth we will get back "duplicate"
172 * shallow and unshallow commands every time there
173 * is a block of have lines exchanged.
175 char line[1000];
176 while (packet_read_line(fd, line, sizeof(line))) {
177 if (!prefixcmp(line, "shallow "))
178 continue;
179 if (!prefixcmp(line, "unshallow "))
180 continue;
181 die("git fetch-pack: expected shallow list");
186 struct write_shallow_data {
187 struct strbuf *out;
188 int use_pack_protocol;
189 int count;
192 static int write_one_shallow(const struct commit_graft *graft, void *cb_data)
194 struct write_shallow_data *data = cb_data;
195 const char *hex = sha1_to_hex(graft->sha1);
196 data->count++;
197 if (data->use_pack_protocol)
198 packet_buf_write(data->out, "shallow %s", hex);
199 else {
200 strbuf_addstr(data->out, hex);
201 strbuf_addch(data->out, '\n');
203 return 0;
206 static int write_shallow_commits(struct strbuf *out, int use_pack_protocol)
208 struct write_shallow_data data;
209 data.out = out;
210 data.use_pack_protocol = use_pack_protocol;
211 data.count = 0;
212 for_each_commit_graft(write_one_shallow, &data);
213 return data.count;
216 static enum ack_type get_ack(int fd, unsigned char *result_sha1)
218 static char line[1000];
219 int len = packet_read_line(fd, line, sizeof(line));
221 if (!len)
222 die("git fetch-pack: expected ACK/NAK, got EOF");
223 if (line[len-1] == '\n')
224 line[--len] = 0;
225 if (!strcmp(line, "NAK"))
226 return NAK;
227 if (!prefixcmp(line, "ACK ")) {
228 if (!get_sha1_hex(line+4, result_sha1)) {
229 if (strstr(line+45, "continue"))
230 return ACK_continue;
231 if (strstr(line+45, "common"))
232 return ACK_common;
233 if (strstr(line+45, "ready"))
234 return ACK_ready;
235 return ACK;
238 die("git fetch_pack: expected ACK/NAK, got '%s'", line);
241 static void send_request(struct fetch_pack_args *args,
242 int fd, struct strbuf *buf)
244 if (args->stateless_rpc) {
245 send_sideband(fd, -1, buf->buf, buf->len, LARGE_PACKET_MAX);
246 packet_flush(fd);
247 } else
248 safe_write(fd, buf->buf, buf->len);
251 static void insert_one_alternate_ref(const struct ref *ref, void *unused)
253 rev_list_insert_ref(NULL, ref->old_sha1, 0, NULL);
256 #define INITIAL_FLUSH 16
257 #define PIPESAFE_FLUSH 32
258 #define LARGE_FLUSH 1024
260 static int next_flush(struct fetch_pack_args *args, int count)
262 int flush_limit = args->stateless_rpc ? LARGE_FLUSH : PIPESAFE_FLUSH;
264 if (count < flush_limit)
265 count <<= 1;
266 else
267 count += flush_limit;
268 return count;
271 static int find_common(struct fetch_pack_args *args,
272 int fd[2], unsigned char *result_sha1,
273 struct ref *refs)
275 int fetching;
276 int count = 0, flushes = 0, flush_at = INITIAL_FLUSH, retval;
277 const unsigned char *sha1;
278 unsigned in_vain = 0;
279 int got_continue = 0;
280 int got_ready = 0;
281 struct strbuf req_buf = STRBUF_INIT;
282 size_t state_len = 0;
284 if (args->stateless_rpc && multi_ack == 1)
285 die("--stateless-rpc requires multi_ack_detailed");
286 if (marked)
287 for_each_ref(clear_marks, NULL);
288 marked = 1;
290 for_each_ref(rev_list_insert_ref, NULL);
291 for_each_alternate_ref(insert_one_alternate_ref, NULL);
293 fetching = 0;
294 for ( ; refs ; refs = refs->next) {
295 unsigned char *remote = refs->old_sha1;
296 const char *remote_hex;
297 struct object *o;
300 * If that object is complete (i.e. it is an ancestor of a
301 * local ref), we tell them we have it but do not have to
302 * tell them about its ancestors, which they already know
303 * about.
305 * We use lookup_object here because we are only
306 * interested in the case we *know* the object is
307 * reachable and we have already scanned it.
309 if (((o = lookup_object(remote)) != NULL) &&
310 (o->flags & COMPLETE)) {
311 continue;
314 remote_hex = sha1_to_hex(remote);
315 if (!fetching) {
316 struct strbuf c = STRBUF_INIT;
317 if (multi_ack == 2) strbuf_addstr(&c, " multi_ack_detailed");
318 if (multi_ack == 1) strbuf_addstr(&c, " multi_ack");
319 if (no_done) strbuf_addstr(&c, " no-done");
320 if (use_sideband == 2) strbuf_addstr(&c, " side-band-64k");
321 if (use_sideband == 1) strbuf_addstr(&c, " side-band");
322 if (args->use_thin_pack) strbuf_addstr(&c, " thin-pack");
323 if (args->no_progress) strbuf_addstr(&c, " no-progress");
324 if (args->include_tag) strbuf_addstr(&c, " include-tag");
325 if (prefer_ofs_delta) strbuf_addstr(&c, " ofs-delta");
326 if (agent_supported) strbuf_addf(&c, " agent=%s",
327 git_user_agent_sanitized());
328 packet_buf_write(&req_buf, "want %s%s\n", remote_hex, c.buf);
329 strbuf_release(&c);
330 } else
331 packet_buf_write(&req_buf, "want %s\n", remote_hex);
332 fetching++;
335 if (!fetching) {
336 strbuf_release(&req_buf);
337 packet_flush(fd[1]);
338 return 1;
341 if (is_repository_shallow())
342 write_shallow_commits(&req_buf, 1);
343 if (args->depth > 0)
344 packet_buf_write(&req_buf, "deepen %d", args->depth);
345 packet_buf_flush(&req_buf);
346 state_len = req_buf.len;
348 if (args->depth > 0) {
349 char line[1024];
350 unsigned char sha1[20];
352 send_request(args, fd[1], &req_buf);
353 while (packet_read_line(fd[0], line, sizeof(line))) {
354 if (!prefixcmp(line, "shallow ")) {
355 if (get_sha1_hex(line + 8, sha1))
356 die("invalid shallow line: %s", line);
357 register_shallow(sha1);
358 continue;
360 if (!prefixcmp(line, "unshallow ")) {
361 if (get_sha1_hex(line + 10, sha1))
362 die("invalid unshallow line: %s", line);
363 if (!lookup_object(sha1))
364 die("object not found: %s", line);
365 /* make sure that it is parsed as shallow */
366 if (!parse_object(sha1))
367 die("error in object: %s", line);
368 if (unregister_shallow(sha1))
369 die("no shallow found: %s", line);
370 continue;
372 die("expected shallow/unshallow, got %s", line);
374 } else if (!args->stateless_rpc)
375 send_request(args, fd[1], &req_buf);
377 if (!args->stateless_rpc) {
378 /* If we aren't using the stateless-rpc interface
379 * we don't need to retain the headers.
381 strbuf_setlen(&req_buf, 0);
382 state_len = 0;
385 flushes = 0;
386 retval = -1;
387 while ((sha1 = get_rev())) {
388 packet_buf_write(&req_buf, "have %s\n", sha1_to_hex(sha1));
389 if (args->verbose)
390 fprintf(stderr, "have %s\n", sha1_to_hex(sha1));
391 in_vain++;
392 if (flush_at <= ++count) {
393 int ack;
395 packet_buf_flush(&req_buf);
396 send_request(args, fd[1], &req_buf);
397 strbuf_setlen(&req_buf, state_len);
398 flushes++;
399 flush_at = next_flush(args, count);
402 * We keep one window "ahead" of the other side, and
403 * will wait for an ACK only on the next one
405 if (!args->stateless_rpc && count == INITIAL_FLUSH)
406 continue;
408 consume_shallow_list(args, fd[0]);
409 do {
410 ack = get_ack(fd[0], result_sha1);
411 if (args->verbose && ack)
412 fprintf(stderr, "got ack %d %s\n", ack,
413 sha1_to_hex(result_sha1));
414 switch (ack) {
415 case ACK:
416 flushes = 0;
417 multi_ack = 0;
418 retval = 0;
419 goto done;
420 case ACK_common:
421 case ACK_ready:
422 case ACK_continue: {
423 struct commit *commit =
424 lookup_commit(result_sha1);
425 if (!commit)
426 die("invalid commit %s", sha1_to_hex(result_sha1));
427 if (args->stateless_rpc
428 && ack == ACK_common
429 && !(commit->object.flags & COMMON)) {
430 /* We need to replay the have for this object
431 * on the next RPC request so the peer knows
432 * it is in common with us.
434 const char *hex = sha1_to_hex(result_sha1);
435 packet_buf_write(&req_buf, "have %s\n", hex);
436 state_len = req_buf.len;
438 mark_common(commit, 0, 1);
439 retval = 0;
440 in_vain = 0;
441 got_continue = 1;
442 if (ack == ACK_ready) {
443 rev_list = NULL;
444 got_ready = 1;
446 break;
449 } while (ack);
450 flushes--;
451 if (got_continue && MAX_IN_VAIN < in_vain) {
452 if (args->verbose)
453 fprintf(stderr, "giving up\n");
454 break; /* give up */
458 done:
459 if (!got_ready || !no_done) {
460 packet_buf_write(&req_buf, "done\n");
461 send_request(args, fd[1], &req_buf);
463 if (args->verbose)
464 fprintf(stderr, "done\n");
465 if (retval != 0) {
466 multi_ack = 0;
467 flushes++;
469 strbuf_release(&req_buf);
471 consume_shallow_list(args, fd[0]);
472 while (flushes || multi_ack) {
473 int ack = get_ack(fd[0], result_sha1);
474 if (ack) {
475 if (args->verbose)
476 fprintf(stderr, "got ack (%d) %s\n", ack,
477 sha1_to_hex(result_sha1));
478 if (ack == ACK)
479 return 0;
480 multi_ack = 1;
481 continue;
483 flushes--;
485 /* it is no error to fetch into a completely empty repo */
486 return count ? retval : 0;
489 static struct commit_list *complete;
491 static int mark_complete(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
493 struct object *o = parse_object(sha1);
495 while (o && o->type == OBJ_TAG) {
496 struct tag *t = (struct tag *) o;
497 if (!t->tagged)
498 break; /* broken repository */
499 o->flags |= COMPLETE;
500 o = parse_object(t->tagged->sha1);
502 if (o && o->type == OBJ_COMMIT) {
503 struct commit *commit = (struct commit *)o;
504 if (!(commit->object.flags & COMPLETE)) {
505 commit->object.flags |= COMPLETE;
506 commit_list_insert_by_date(commit, &complete);
509 return 0;
512 static void mark_recent_complete_commits(struct fetch_pack_args *args,
513 unsigned long cutoff)
515 while (complete && cutoff <= complete->item->date) {
516 if (args->verbose)
517 fprintf(stderr, "Marking %s as complete\n",
518 sha1_to_hex(complete->item->object.sha1));
519 pop_most_recent_commit(&complete, COMPLETE);
523 static int non_matching_ref(struct string_list_item *item, void *unused)
525 if (item->util) {
526 item->util = NULL;
527 return 0;
529 else
530 return 1;
533 static void filter_refs(struct fetch_pack_args *args,
534 struct ref **refs, struct string_list *sought)
536 struct ref *newlist = NULL;
537 struct ref **newtail = &newlist;
538 struct ref *ref, *next;
539 int sought_pos;
541 sought_pos = 0;
542 for (ref = *refs; ref; ref = next) {
543 int keep = 0;
544 next = ref->next;
545 if (!memcmp(ref->name, "refs/", 5) &&
546 check_refname_format(ref->name + 5, 0))
547 ; /* trash */
548 else {
549 while (sought_pos < sought->nr) {
550 int cmp = strcmp(ref->name, sought->items[sought_pos].string);
551 if (cmp < 0)
552 break; /* definitely do not have it */
553 else if (cmp == 0) {
554 keep = 1; /* definitely have it */
555 sought->items[sought_pos++].util = "matched";
556 break;
558 else
559 sought_pos++; /* might have it; keep looking */
563 if (! keep && args->fetch_all &&
564 (!args->depth || prefixcmp(ref->name, "refs/tags/")))
565 keep = 1;
567 if (keep) {
568 *newtail = ref;
569 ref->next = NULL;
570 newtail = &ref->next;
571 } else {
572 free(ref);
576 filter_string_list(sought, 0, non_matching_ref, NULL);
577 *refs = newlist;
580 static void mark_alternate_complete(const struct ref *ref, void *unused)
582 mark_complete(NULL, ref->old_sha1, 0, NULL);
585 static int everything_local(struct fetch_pack_args *args,
586 struct ref **refs, struct string_list *sought)
588 struct ref *ref;
589 int retval;
590 unsigned long cutoff = 0;
592 save_commit_buffer = 0;
594 for (ref = *refs; ref; ref = ref->next) {
595 struct object *o;
597 if (!has_sha1_file(ref->old_sha1))
598 continue;
600 o = parse_object(ref->old_sha1);
601 if (!o)
602 continue;
604 /* We already have it -- which may mean that we were
605 * in sync with the other side at some time after
606 * that (it is OK if we guess wrong here).
608 if (o->type == OBJ_COMMIT) {
609 struct commit *commit = (struct commit *)o;
610 if (!cutoff || cutoff < commit->date)
611 cutoff = commit->date;
615 if (!args->depth) {
616 for_each_ref(mark_complete, NULL);
617 for_each_alternate_ref(mark_alternate_complete, NULL);
618 if (cutoff)
619 mark_recent_complete_commits(args, cutoff);
623 * Mark all complete remote refs as common refs.
624 * Don't mark them common yet; the server has to be told so first.
626 for (ref = *refs; ref; ref = ref->next) {
627 struct object *o = deref_tag(lookup_object(ref->old_sha1),
628 NULL, 0);
630 if (!o || o->type != OBJ_COMMIT || !(o->flags & COMPLETE))
631 continue;
633 if (!(o->flags & SEEN)) {
634 rev_list_push((struct commit *)o, COMMON_REF | SEEN);
636 mark_common((struct commit *)o, 1, 1);
640 filter_refs(args, refs, sought);
642 for (retval = 1, ref = *refs; ref ; ref = ref->next) {
643 const unsigned char *remote = ref->old_sha1;
644 unsigned char local[20];
645 struct object *o;
647 o = lookup_object(remote);
648 if (!o || !(o->flags & COMPLETE)) {
649 retval = 0;
650 if (!args->verbose)
651 continue;
652 fprintf(stderr,
653 "want %s (%s)\n", sha1_to_hex(remote),
654 ref->name);
655 continue;
658 hashcpy(ref->new_sha1, local);
659 if (!args->verbose)
660 continue;
661 fprintf(stderr,
662 "already have %s (%s)\n", sha1_to_hex(remote),
663 ref->name);
665 return retval;
668 static int sideband_demux(int in, int out, void *data)
670 int *xd = data;
672 int ret = recv_sideband("fetch-pack", xd[0], out);
673 close(out);
674 return ret;
677 static int get_pack(struct fetch_pack_args *args,
678 int xd[2], char **pack_lockfile)
680 struct async demux;
681 const char *argv[20];
682 char keep_arg[256];
683 char hdr_arg[256];
684 const char **av;
685 int do_keep = args->keep_pack;
686 struct child_process cmd;
688 memset(&demux, 0, sizeof(demux));
689 if (use_sideband) {
690 /* xd[] is talking with upload-pack; subprocess reads from
691 * xd[0], spits out band#2 to stderr, and feeds us band#1
692 * through demux->out.
694 demux.proc = sideband_demux;
695 demux.data = xd;
696 demux.out = -1;
697 if (start_async(&demux))
698 die("fetch-pack: unable to fork off sideband"
699 " demultiplexer");
701 else
702 demux.out = xd[0];
704 memset(&cmd, 0, sizeof(cmd));
705 cmd.argv = argv;
706 av = argv;
707 *hdr_arg = 0;
708 if (!args->keep_pack && unpack_limit) {
709 struct pack_header header;
711 if (read_pack_header(demux.out, &header))
712 die("protocol error: bad pack header");
713 snprintf(hdr_arg, sizeof(hdr_arg),
714 "--pack_header=%"PRIu32",%"PRIu32,
715 ntohl(header.hdr_version), ntohl(header.hdr_entries));
716 if (ntohl(header.hdr_entries) < unpack_limit)
717 do_keep = 0;
718 else
719 do_keep = 1;
722 if (do_keep) {
723 if (pack_lockfile)
724 cmd.out = -1;
725 *av++ = "index-pack";
726 *av++ = "--stdin";
727 if (!args->quiet && !args->no_progress)
728 *av++ = "-v";
729 if (args->use_thin_pack)
730 *av++ = "--fix-thin";
731 if (args->lock_pack || unpack_limit) {
732 int s = sprintf(keep_arg,
733 "--keep=fetch-pack %"PRIuMAX " on ", (uintmax_t) getpid());
734 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
735 strcpy(keep_arg + s, "localhost");
736 *av++ = keep_arg;
739 else {
740 *av++ = "unpack-objects";
741 if (args->quiet || args->no_progress)
742 *av++ = "-q";
744 if (*hdr_arg)
745 *av++ = hdr_arg;
746 if (fetch_fsck_objects >= 0
747 ? fetch_fsck_objects
748 : transfer_fsck_objects >= 0
749 ? transfer_fsck_objects
750 : 0)
751 *av++ = "--strict";
752 *av++ = NULL;
754 cmd.in = demux.out;
755 cmd.git_cmd = 1;
756 if (start_command(&cmd))
757 die("fetch-pack: unable to fork off %s", argv[0]);
758 if (do_keep && pack_lockfile) {
759 *pack_lockfile = index_pack_lockfile(cmd.out);
760 close(cmd.out);
763 if (finish_command(&cmd))
764 die("%s failed", argv[0]);
765 if (use_sideband && finish_async(&demux))
766 die("error in sideband demultiplexer");
767 return 0;
770 static struct ref *do_fetch_pack(struct fetch_pack_args *args,
771 int fd[2],
772 const struct ref *orig_ref,
773 struct string_list *sought,
774 char **pack_lockfile)
776 struct ref *ref = copy_ref_list(orig_ref);
777 unsigned char sha1[20];
778 const char *agent_feature;
779 int agent_len;
781 sort_ref_list(&ref, ref_compare_name);
783 if (is_repository_shallow() && !server_supports("shallow"))
784 die("Server does not support shallow clients");
785 if (server_supports("multi_ack_detailed")) {
786 if (args->verbose)
787 fprintf(stderr, "Server supports multi_ack_detailed\n");
788 multi_ack = 2;
789 if (server_supports("no-done")) {
790 if (args->verbose)
791 fprintf(stderr, "Server supports no-done\n");
792 if (args->stateless_rpc)
793 no_done = 1;
796 else if (server_supports("multi_ack")) {
797 if (args->verbose)
798 fprintf(stderr, "Server supports multi_ack\n");
799 multi_ack = 1;
801 if (server_supports("side-band-64k")) {
802 if (args->verbose)
803 fprintf(stderr, "Server supports side-band-64k\n");
804 use_sideband = 2;
806 else if (server_supports("side-band")) {
807 if (args->verbose)
808 fprintf(stderr, "Server supports side-band\n");
809 use_sideband = 1;
811 if (!server_supports("thin-pack"))
812 args->use_thin_pack = 0;
813 if (!server_supports("no-progress"))
814 args->no_progress = 0;
815 if (!server_supports("include-tag"))
816 args->include_tag = 0;
817 if (server_supports("ofs-delta")) {
818 if (args->verbose)
819 fprintf(stderr, "Server supports ofs-delta\n");
820 } else
821 prefer_ofs_delta = 0;
823 if ((agent_feature = server_feature_value("agent", &agent_len))) {
824 agent_supported = 1;
825 if (args->verbose && agent_len)
826 fprintf(stderr, "Server version is %.*s\n",
827 agent_len, agent_feature);
830 if (everything_local(args, &ref, sought)) {
831 packet_flush(fd[1]);
832 goto all_done;
834 if (find_common(args, fd, sha1, ref) < 0)
835 if (!args->keep_pack)
836 /* When cloning, it is not unusual to have
837 * no common commit.
839 warning("no common commits");
841 if (args->stateless_rpc)
842 packet_flush(fd[1]);
843 if (get_pack(args, fd, pack_lockfile))
844 die("git fetch-pack: fetch failed.");
846 all_done:
847 return ref;
850 static int fetch_pack_config(const char *var, const char *value, void *cb)
852 if (strcmp(var, "fetch.unpacklimit") == 0) {
853 fetch_unpack_limit = git_config_int(var, value);
854 return 0;
857 if (strcmp(var, "transfer.unpacklimit") == 0) {
858 transfer_unpack_limit = git_config_int(var, value);
859 return 0;
862 if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
863 prefer_ofs_delta = git_config_bool(var, value);
864 return 0;
867 if (!strcmp(var, "fetch.fsckobjects")) {
868 fetch_fsck_objects = git_config_bool(var, value);
869 return 0;
872 if (!strcmp(var, "transfer.fsckobjects")) {
873 transfer_fsck_objects = git_config_bool(var, value);
874 return 0;
877 return git_default_config(var, value, cb);
880 static void fetch_pack_setup(void)
882 static int did_setup;
883 if (did_setup)
884 return;
885 git_config(fetch_pack_config, NULL);
886 if (0 <= transfer_unpack_limit)
887 unpack_limit = transfer_unpack_limit;
888 else if (0 <= fetch_unpack_limit)
889 unpack_limit = fetch_unpack_limit;
890 did_setup = 1;
893 struct ref *fetch_pack(struct fetch_pack_args *args,
894 int fd[], struct child_process *conn,
895 const struct ref *ref,
896 const char *dest,
897 struct string_list *sought,
898 char **pack_lockfile)
900 struct stat st;
901 struct ref *ref_cpy;
903 fetch_pack_setup();
904 if (args->depth > 0) {
905 if (stat(git_path("shallow"), &st))
906 st.st_mtime = 0;
909 if (sought->nr) {
910 sort_string_list(sought);
911 string_list_remove_duplicates(sought, 0);
914 if (!ref) {
915 packet_flush(fd[1]);
916 die("no matching remote head");
918 ref_cpy = do_fetch_pack(args, fd, ref, sought, pack_lockfile);
920 if (args->depth > 0) {
921 static struct lock_file lock;
922 struct cache_time mtime;
923 struct strbuf sb = STRBUF_INIT;
924 char *shallow = git_path("shallow");
925 int fd;
927 mtime.sec = st.st_mtime;
928 mtime.nsec = ST_MTIME_NSEC(st);
929 if (stat(shallow, &st)) {
930 if (mtime.sec)
931 die("shallow file was removed during fetch");
932 } else if (st.st_mtime != mtime.sec
933 #ifdef USE_NSEC
934 || ST_MTIME_NSEC(st) != mtime.nsec
935 #endif
937 die("shallow file was changed during fetch");
939 fd = hold_lock_file_for_update(&lock, shallow,
940 LOCK_DIE_ON_ERROR);
941 if (!write_shallow_commits(&sb, 0)
942 || write_in_full(fd, sb.buf, sb.len) != sb.len) {
943 unlink_or_warn(shallow);
944 rollback_lock_file(&lock);
945 } else {
946 commit_lock_file(&lock);
948 strbuf_release(&sb);
951 reprepare_packed_git();
952 return ref_cpy;