10 #include "fetch-pack.h"
12 #include "run-command.h"
14 #include "transport.h"
16 #include "prio-queue.h"
17 #include "sha1-array.h"
19 static int transfer_unpack_limit
= -1;
20 static int fetch_unpack_limit
= -1;
21 static int unpack_limit
= 100;
22 static int prefer_ofs_delta
= 1;
24 static int deepen_since_ok
;
25 static int deepen_not_ok
;
26 static int fetch_fsck_objects
= -1;
27 static int transfer_fsck_objects
= -1;
28 static int agent_supported
;
29 static struct lock_file shallow_lock
;
30 static const char *alternate_shallow_file
;
32 /* Remember to update object flag allocation in object.h */
33 #define COMPLETE (1U << 0)
34 #define COMMON (1U << 1)
35 #define COMMON_REF (1U << 2)
36 #define SEEN (1U << 3)
37 #define POPPED (1U << 4)
42 * After sending this many "have"s if we do not get any new ACK , we
43 * give up traversing our history.
45 #define MAX_IN_VAIN 256
47 static struct prio_queue rev_list
= { compare_commits_by_commit_date
};
48 static int non_common_revs
, multi_ack
, use_sideband
;
49 /* Allow specifying sha1 if it is a ref tip. */
50 #define ALLOW_TIP_SHA1 01
51 /* Allow request of a sha1 if it is reachable from a ref (possibly hidden ref). */
52 #define ALLOW_REACHABLE_SHA1 02
53 static unsigned int allow_unadvertised_object_request
;
55 __attribute__((format (printf
, 2, 3)))
56 static inline void print_verbose(const struct fetch_pack_args
*args
,
64 va_start(params
, fmt
);
65 vfprintf(stderr
, fmt
, params
);
70 static void rev_list_push(struct commit
*commit
, int mark
)
72 if (!(commit
->object
.flags
& mark
)) {
73 commit
->object
.flags
|= mark
;
75 if (parse_commit(commit
))
78 prio_queue_put(&rev_list
, commit
);
80 if (!(commit
->object
.flags
& COMMON
))
85 static int rev_list_insert_ref(const char *refname
, const unsigned char *sha1
)
87 struct object
*o
= deref_tag(parse_object(sha1
), refname
, 0);
89 if (o
&& o
->type
== OBJ_COMMIT
)
90 rev_list_push((struct commit
*)o
, SEEN
);
95 static int rev_list_insert_ref_oid(const char *refname
, const struct object_id
*oid
,
96 int flag
, void *cb_data
)
98 return rev_list_insert_ref(refname
, oid
->hash
);
101 static int clear_marks(const char *refname
, const struct object_id
*oid
,
102 int flag
, void *cb_data
)
104 struct object
*o
= deref_tag(parse_object(oid
->hash
), refname
, 0);
106 if (o
&& o
->type
== OBJ_COMMIT
)
107 clear_commit_marks((struct commit
*)o
,
108 COMMON
| COMMON_REF
| SEEN
| POPPED
);
113 This function marks a rev and its ancestors as common.
114 In some cases, it is desirable to mark only the ancestors (for example
115 when only the server does not yet know that they are common).
118 static void mark_common(struct commit
*commit
,
119 int ancestors_only
, int dont_parse
)
121 if (commit
!= NULL
&& !(commit
->object
.flags
& COMMON
)) {
122 struct object
*o
= (struct object
*)commit
;
127 if (!(o
->flags
& SEEN
))
128 rev_list_push(commit
, SEEN
);
130 struct commit_list
*parents
;
132 if (!ancestors_only
&& !(o
->flags
& POPPED
))
134 if (!o
->parsed
&& !dont_parse
)
135 if (parse_commit(commit
))
138 for (parents
= commit
->parents
;
140 parents
= parents
->next
)
141 mark_common(parents
->item
, 0, dont_parse
);
147 Get the next rev to send, ignoring the common.
150 static const unsigned char *get_rev(void)
152 struct commit
*commit
= NULL
;
154 while (commit
== NULL
) {
156 struct commit_list
*parents
;
158 if (rev_list
.nr
== 0 || non_common_revs
== 0)
161 commit
= prio_queue_get(&rev_list
);
162 parse_commit(commit
);
163 parents
= commit
->parents
;
165 commit
->object
.flags
|= POPPED
;
166 if (!(commit
->object
.flags
& COMMON
))
169 if (commit
->object
.flags
& COMMON
) {
170 /* do not send "have", and ignore ancestors */
172 mark
= COMMON
| SEEN
;
173 } else if (commit
->object
.flags
& COMMON_REF
)
174 /* send "have", and ignore ancestors */
175 mark
= COMMON
| SEEN
;
177 /* send "have", also for its ancestors */
181 if (!(parents
->item
->object
.flags
& SEEN
))
182 rev_list_push(parents
->item
, mark
);
184 mark_common(parents
->item
, 1, 0);
185 parents
= parents
->next
;
189 return commit
->object
.oid
.hash
;
200 static void consume_shallow_list(struct fetch_pack_args
*args
, int fd
)
202 if (args
->stateless_rpc
&& args
->deepen
) {
203 /* If we sent a depth we will get back "duplicate"
204 * shallow and unshallow commands every time there
205 * is a block of have lines exchanged.
208 while ((line
= packet_read_line(fd
, NULL
))) {
209 if (starts_with(line
, "shallow "))
211 if (starts_with(line
, "unshallow "))
213 die(_("git fetch-pack: expected shallow list"));
218 static enum ack_type
get_ack(int fd
, unsigned char *result_sha1
)
221 char *line
= packet_read_line(fd
, &len
);
225 die(_("git fetch-pack: expected ACK/NAK, got EOF"));
226 if (!strcmp(line
, "NAK"))
228 if (skip_prefix(line
, "ACK ", &arg
)) {
229 if (!get_sha1_hex(arg
, result_sha1
)) {
234 if (strstr(arg
, "continue"))
236 if (strstr(arg
, "common"))
238 if (strstr(arg
, "ready"))
243 die(_("git fetch-pack: expected ACK/NAK, got '%s'"), line
);
246 static void send_request(struct fetch_pack_args
*args
,
247 int fd
, struct strbuf
*buf
)
249 if (args
->stateless_rpc
) {
250 send_sideband(fd
, -1, buf
->buf
, buf
->len
, LARGE_PACKET_MAX
);
253 write_or_die(fd
, buf
->buf
, buf
->len
);
256 static void insert_one_alternate_ref(const char *refname
,
257 const struct object_id
*oid
,
260 rev_list_insert_ref(NULL
, oid
->hash
);
263 #define INITIAL_FLUSH 16
264 #define PIPESAFE_FLUSH 32
265 #define LARGE_FLUSH 16384
267 static int next_flush(struct fetch_pack_args
*args
, int count
)
269 if (args
->stateless_rpc
) {
270 if (count
< LARGE_FLUSH
)
273 count
= count
* 11 / 10;
275 if (count
< PIPESAFE_FLUSH
)
278 count
+= PIPESAFE_FLUSH
;
283 static int find_common(struct fetch_pack_args
*args
,
284 int fd
[2], unsigned char *result_sha1
,
288 int count
= 0, flushes
= 0, flush_at
= INITIAL_FLUSH
, retval
;
289 const unsigned char *sha1
;
290 unsigned in_vain
= 0;
291 int got_continue
= 0;
293 struct strbuf req_buf
= STRBUF_INIT
;
294 size_t state_len
= 0;
296 if (args
->stateless_rpc
&& multi_ack
== 1)
297 die(_("--stateless-rpc requires multi_ack_detailed"));
299 for_each_ref(clear_marks
, NULL
);
302 for_each_ref(rev_list_insert_ref_oid
, NULL
);
303 for_each_alternate_ref(insert_one_alternate_ref
, NULL
);
306 for ( ; refs
; refs
= refs
->next
) {
307 unsigned char *remote
= refs
->old_oid
.hash
;
308 const char *remote_hex
;
312 * If that object is complete (i.e. it is an ancestor of a
313 * local ref), we tell them we have it but do not have to
314 * tell them about its ancestors, which they already know
317 * We use lookup_object here because we are only
318 * interested in the case we *know* the object is
319 * reachable and we have already scanned it.
321 if (((o
= lookup_object(remote
)) != NULL
) &&
322 (o
->flags
& COMPLETE
)) {
326 remote_hex
= sha1_to_hex(remote
);
328 struct strbuf c
= STRBUF_INIT
;
329 if (multi_ack
== 2) strbuf_addstr(&c
, " multi_ack_detailed");
330 if (multi_ack
== 1) strbuf_addstr(&c
, " multi_ack");
331 if (no_done
) strbuf_addstr(&c
, " no-done");
332 if (use_sideband
== 2) strbuf_addstr(&c
, " side-band-64k");
333 if (use_sideband
== 1) strbuf_addstr(&c
, " side-band");
334 if (args
->deepen_relative
) strbuf_addstr(&c
, " deepen-relative");
335 if (args
->use_thin_pack
) strbuf_addstr(&c
, " thin-pack");
336 if (args
->no_progress
) strbuf_addstr(&c
, " no-progress");
337 if (args
->include_tag
) strbuf_addstr(&c
, " include-tag");
338 if (prefer_ofs_delta
) strbuf_addstr(&c
, " ofs-delta");
339 if (deepen_since_ok
) strbuf_addstr(&c
, " deepen-since");
340 if (deepen_not_ok
) strbuf_addstr(&c
, " deepen-not");
341 if (agent_supported
) strbuf_addf(&c
, " agent=%s",
342 git_user_agent_sanitized());
343 packet_buf_write(&req_buf
, "want %s%s\n", remote_hex
, c
.buf
);
346 packet_buf_write(&req_buf
, "want %s\n", remote_hex
);
351 strbuf_release(&req_buf
);
356 if (is_repository_shallow())
357 write_shallow_commits(&req_buf
, 1, NULL
);
359 packet_buf_write(&req_buf
, "deepen %d", args
->depth
);
360 if (args
->deepen_since
) {
361 unsigned long max_age
= approxidate(args
->deepen_since
);
362 packet_buf_write(&req_buf
, "deepen-since %lu", max_age
);
364 if (args
->deepen_not
) {
366 for (i
= 0; i
< args
->deepen_not
->nr
; i
++) {
367 struct string_list_item
*s
= args
->deepen_not
->items
+ i
;
368 packet_buf_write(&req_buf
, "deepen-not %s", s
->string
);
371 packet_buf_flush(&req_buf
);
372 state_len
= req_buf
.len
;
377 unsigned char sha1
[20];
379 send_request(args
, fd
[1], &req_buf
);
380 while ((line
= packet_read_line(fd
[0], NULL
))) {
381 if (skip_prefix(line
, "shallow ", &arg
)) {
382 if (get_sha1_hex(arg
, sha1
))
383 die(_("invalid shallow line: %s"), line
);
384 register_shallow(sha1
);
387 if (skip_prefix(line
, "unshallow ", &arg
)) {
388 if (get_sha1_hex(arg
, sha1
))
389 die(_("invalid unshallow line: %s"), line
);
390 if (!lookup_object(sha1
))
391 die(_("object not found: %s"), line
);
392 /* make sure that it is parsed as shallow */
393 if (!parse_object(sha1
))
394 die(_("error in object: %s"), line
);
395 if (unregister_shallow(sha1
))
396 die(_("no shallow found: %s"), line
);
399 die(_("expected shallow/unshallow, got %s"), line
);
401 } else if (!args
->stateless_rpc
)
402 send_request(args
, fd
[1], &req_buf
);
404 if (!args
->stateless_rpc
) {
405 /* If we aren't using the stateless-rpc interface
406 * we don't need to retain the headers.
408 strbuf_setlen(&req_buf
, 0);
414 while ((sha1
= get_rev())) {
415 packet_buf_write(&req_buf
, "have %s\n", sha1_to_hex(sha1
));
416 print_verbose(args
, "have %s", sha1_to_hex(sha1
));
418 if (flush_at
<= ++count
) {
421 packet_buf_flush(&req_buf
);
422 send_request(args
, fd
[1], &req_buf
);
423 strbuf_setlen(&req_buf
, state_len
);
425 flush_at
= next_flush(args
, count
);
428 * We keep one window "ahead" of the other side, and
429 * will wait for an ACK only on the next one
431 if (!args
->stateless_rpc
&& count
== INITIAL_FLUSH
)
434 consume_shallow_list(args
, fd
[0]);
436 ack
= get_ack(fd
[0], result_sha1
);
438 print_verbose(args
, _("got %s %d %s"), "ack",
439 ack
, sha1_to_hex(result_sha1
));
449 struct commit
*commit
=
450 lookup_commit(result_sha1
);
452 die(_("invalid commit %s"), sha1_to_hex(result_sha1
));
453 if (args
->stateless_rpc
455 && !(commit
->object
.flags
& COMMON
)) {
456 /* We need to replay the have for this object
457 * on the next RPC request so the peer knows
458 * it is in common with us.
460 const char *hex
= sha1_to_hex(result_sha1
);
461 packet_buf_write(&req_buf
, "have %s\n", hex
);
462 state_len
= req_buf
.len
;
464 * Reset in_vain because an ack
465 * for this commit has not been
469 } else if (!args
->stateless_rpc
470 || ack
!= ACK_common
)
472 mark_common(commit
, 0, 1);
475 if (ack
== ACK_ready
) {
476 clear_prio_queue(&rev_list
);
484 if (got_continue
&& MAX_IN_VAIN
< in_vain
) {
485 print_verbose(args
, _("giving up"));
491 if (!got_ready
|| !no_done
) {
492 packet_buf_write(&req_buf
, "done\n");
493 send_request(args
, fd
[1], &req_buf
);
495 print_verbose(args
, _("done"));
500 strbuf_release(&req_buf
);
502 if (!got_ready
|| !no_done
)
503 consume_shallow_list(args
, fd
[0]);
504 while (flushes
|| multi_ack
) {
505 int ack
= get_ack(fd
[0], result_sha1
);
507 print_verbose(args
, _("got %s (%d) %s"), "ack",
508 ack
, sha1_to_hex(result_sha1
));
516 /* it is no error to fetch into a completely empty repo */
517 return count
? retval
: 0;
520 static struct commit_list
*complete
;
522 static int mark_complete(const unsigned char *sha1
)
524 struct object
*o
= parse_object(sha1
);
526 while (o
&& o
->type
== OBJ_TAG
) {
527 struct tag
*t
= (struct tag
*) o
;
529 break; /* broken repository */
530 o
->flags
|= COMPLETE
;
531 o
= parse_object(t
->tagged
->oid
.hash
);
533 if (o
&& o
->type
== OBJ_COMMIT
) {
534 struct commit
*commit
= (struct commit
*)o
;
535 if (!(commit
->object
.flags
& COMPLETE
)) {
536 commit
->object
.flags
|= COMPLETE
;
537 commit_list_insert(commit
, &complete
);
543 static int mark_complete_oid(const char *refname
, const struct object_id
*oid
,
544 int flag
, void *cb_data
)
546 return mark_complete(oid
->hash
);
549 static void mark_recent_complete_commits(struct fetch_pack_args
*args
,
550 unsigned long cutoff
)
552 while (complete
&& cutoff
<= complete
->item
->date
) {
553 print_verbose(args
, _("Marking %s as complete"),
554 oid_to_hex(&complete
->item
->object
.oid
));
555 pop_most_recent_commit(&complete
, COMPLETE
);
559 static void filter_refs(struct fetch_pack_args
*args
,
561 struct ref
**sought
, int nr_sought
)
563 struct ref
*newlist
= NULL
;
564 struct ref
**newtail
= &newlist
;
565 struct ref
*ref
, *next
;
569 for (ref
= *refs
; ref
; ref
= next
) {
573 if (starts_with(ref
->name
, "refs/") &&
574 check_refname_format(ref
->name
, 0))
577 while (i
< nr_sought
) {
578 int cmp
= strcmp(ref
->name
, sought
[i
]->name
);
580 break; /* definitely do not have it */
582 keep
= 1; /* definitely have it */
583 sought
[i
]->matched
= 1;
589 if (!keep
&& args
->fetch_all
&&
590 (!args
->deepen
|| !starts_with(ref
->name
, "refs/tags/")))
596 newtail
= &ref
->next
;
602 /* Append unmatched requests to the list */
603 if ((allow_unadvertised_object_request
&
604 (ALLOW_TIP_SHA1
| ALLOW_REACHABLE_SHA1
))) {
605 for (i
= 0; i
< nr_sought
; i
++) {
606 unsigned char sha1
[20];
611 if (get_sha1_hex(ref
->name
, sha1
) ||
612 ref
->name
[40] != '\0' ||
613 hashcmp(sha1
, ref
->old_oid
.hash
))
617 *newtail
= copy_ref(ref
);
618 newtail
= &(*newtail
)->next
;
624 static void mark_alternate_complete(const char *refname
,
625 const struct object_id
*oid
,
628 mark_complete(oid
->hash
);
631 static int everything_local(struct fetch_pack_args
*args
,
633 struct ref
**sought
, int nr_sought
)
637 unsigned long cutoff
= 0;
639 save_commit_buffer
= 0;
641 for (ref
= *refs
; ref
; ref
= ref
->next
) {
644 if (!has_object_file(&ref
->old_oid
))
647 o
= parse_object(ref
->old_oid
.hash
);
651 /* We already have it -- which may mean that we were
652 * in sync with the other side at some time after
653 * that (it is OK if we guess wrong here).
655 if (o
->type
== OBJ_COMMIT
) {
656 struct commit
*commit
= (struct commit
*)o
;
657 if (!cutoff
|| cutoff
< commit
->date
)
658 cutoff
= commit
->date
;
663 for_each_ref(mark_complete_oid
, NULL
);
664 for_each_alternate_ref(mark_alternate_complete
, NULL
);
665 commit_list_sort_by_date(&complete
);
667 mark_recent_complete_commits(args
, cutoff
);
671 * Mark all complete remote refs as common refs.
672 * Don't mark them common yet; the server has to be told so first.
674 for (ref
= *refs
; ref
; ref
= ref
->next
) {
675 struct object
*o
= deref_tag(lookup_object(ref
->old_oid
.hash
),
678 if (!o
|| o
->type
!= OBJ_COMMIT
|| !(o
->flags
& COMPLETE
))
681 if (!(o
->flags
& SEEN
)) {
682 rev_list_push((struct commit
*)o
, COMMON_REF
| SEEN
);
684 mark_common((struct commit
*)o
, 1, 1);
688 filter_refs(args
, refs
, sought
, nr_sought
);
690 for (retval
= 1, ref
= *refs
; ref
; ref
= ref
->next
) {
691 const unsigned char *remote
= ref
->old_oid
.hash
;
694 o
= lookup_object(remote
);
695 if (!o
|| !(o
->flags
& COMPLETE
)) {
697 print_verbose(args
, "want %s (%s)", sha1_to_hex(remote
),
701 print_verbose(args
, _("already have %s (%s)"), sha1_to_hex(remote
),
707 static int sideband_demux(int in
, int out
, void *data
)
712 ret
= recv_sideband("fetch-pack", xd
[0], out
);
717 static int get_pack(struct fetch_pack_args
*args
,
718 int xd
[2], char **pack_lockfile
)
721 int do_keep
= args
->keep_pack
;
722 const char *cmd_name
;
723 struct pack_header header
;
725 struct child_process cmd
= CHILD_PROCESS_INIT
;
728 memset(&demux
, 0, sizeof(demux
));
730 /* xd[] is talking with upload-pack; subprocess reads from
731 * xd[0], spits out band#2 to stderr, and feeds us band#1
732 * through demux->out.
734 demux
.proc
= sideband_demux
;
737 demux
.isolate_sigpipe
= 1;
738 if (start_async(&demux
))
739 die(_("fetch-pack: unable to fork off sideband demultiplexer"));
744 if (!args
->keep_pack
&& unpack_limit
) {
746 if (read_pack_header(demux
.out
, &header
))
747 die(_("protocol error: bad pack header"));
749 if (ntohl(header
.hdr_entries
) < unpack_limit
)
755 if (alternate_shallow_file
) {
756 argv_array_push(&cmd
.args
, "--shallow-file");
757 argv_array_push(&cmd
.args
, alternate_shallow_file
);
763 cmd_name
= "index-pack";
764 argv_array_push(&cmd
.args
, cmd_name
);
765 argv_array_push(&cmd
.args
, "--stdin");
766 if (!args
->quiet
&& !args
->no_progress
)
767 argv_array_push(&cmd
.args
, "-v");
768 if (args
->use_thin_pack
)
769 argv_array_push(&cmd
.args
, "--fix-thin");
770 if (args
->lock_pack
|| unpack_limit
) {
772 if (gethostname(hostname
, sizeof(hostname
)))
773 xsnprintf(hostname
, sizeof(hostname
), "localhost");
774 argv_array_pushf(&cmd
.args
,
775 "--keep=fetch-pack %"PRIuMAX
" on %s",
776 (uintmax_t)getpid(), hostname
);
778 if (args
->check_self_contained_and_connected
)
779 argv_array_push(&cmd
.args
, "--check-self-contained-and-connected");
782 cmd_name
= "unpack-objects";
783 argv_array_push(&cmd
.args
, cmd_name
);
784 if (args
->quiet
|| args
->no_progress
)
785 argv_array_push(&cmd
.args
, "-q");
786 args
->check_self_contained_and_connected
= 0;
790 argv_array_pushf(&cmd
.args
, "--pack_header=%"PRIu32
",%"PRIu32
,
791 ntohl(header
.hdr_version
),
792 ntohl(header
.hdr_entries
));
793 if (fetch_fsck_objects
>= 0
795 : transfer_fsck_objects
>= 0
796 ? transfer_fsck_objects
798 argv_array_push(&cmd
.args
, "--strict");
802 if (start_command(&cmd
))
803 die(_("fetch-pack: unable to fork off %s"), cmd_name
);
804 if (do_keep
&& pack_lockfile
) {
805 *pack_lockfile
= index_pack_lockfile(cmd
.out
);
810 /* Closed by start_command() */
813 ret
= finish_command(&cmd
);
814 if (!ret
|| (args
->check_self_contained_and_connected
&& ret
== 1))
815 args
->self_contained_and_connected
=
816 args
->check_self_contained_and_connected
&&
819 die(_("%s failed"), cmd_name
);
820 if (use_sideband
&& finish_async(&demux
))
821 die(_("error in sideband demultiplexer"));
825 static int cmp_ref_by_name(const void *a_
, const void *b_
)
827 const struct ref
*a
= *((const struct ref
**)a_
);
828 const struct ref
*b
= *((const struct ref
**)b_
);
829 return strcmp(a
->name
, b
->name
);
832 static struct ref
*do_fetch_pack(struct fetch_pack_args
*args
,
834 const struct ref
*orig_ref
,
835 struct ref
**sought
, int nr_sought
,
836 struct shallow_info
*si
,
837 char **pack_lockfile
)
839 struct ref
*ref
= copy_ref_list(orig_ref
);
840 unsigned char sha1
[20];
841 const char *agent_feature
;
844 sort_ref_list(&ref
, ref_compare_name
);
845 QSORT(sought
, nr_sought
, cmp_ref_by_name
);
847 if ((args
->depth
> 0 || is_repository_shallow()) && !server_supports("shallow"))
848 die(_("Server does not support shallow clients"));
849 if (args
->depth
> 0 || args
->deepen_since
|| args
->deepen_not
)
851 if (server_supports("multi_ack_detailed")) {
852 print_verbose(args
, _("Server supports multi_ack_detailed"));
854 if (server_supports("no-done")) {
855 print_verbose(args
, _("Server supports no-done"));
856 if (args
->stateless_rpc
)
860 else if (server_supports("multi_ack")) {
861 print_verbose(args
, _("Server supports multi_ack"));
864 if (server_supports("side-band-64k")) {
865 print_verbose(args
, _("Server supports side-band-64k"));
868 else if (server_supports("side-band")) {
869 print_verbose(args
, _("Server supports side-band"));
872 if (server_supports("allow-tip-sha1-in-want")) {
873 print_verbose(args
, _("Server supports allow-tip-sha1-in-want"));
874 allow_unadvertised_object_request
|= ALLOW_TIP_SHA1
;
876 if (server_supports("allow-reachable-sha1-in-want")) {
877 print_verbose(args
, _("Server supports allow-reachable-sha1-in-want"));
878 allow_unadvertised_object_request
|= ALLOW_REACHABLE_SHA1
;
880 if (!server_supports("thin-pack"))
881 args
->use_thin_pack
= 0;
882 if (!server_supports("no-progress"))
883 args
->no_progress
= 0;
884 if (!server_supports("include-tag"))
885 args
->include_tag
= 0;
886 if (server_supports("ofs-delta"))
887 print_verbose(args
, _("Server supports ofs-delta"));
889 prefer_ofs_delta
= 0;
891 if ((agent_feature
= server_feature_value("agent", &agent_len
))) {
894 print_verbose(args
, _("Server version is %.*s"),
895 agent_len
, agent_feature
);
897 if (server_supports("deepen-since"))
899 else if (args
->deepen_since
)
900 die(_("Server does not support --shallow-since"));
901 if (server_supports("deepen-not"))
903 else if (args
->deepen_not
)
904 die(_("Server does not support --shallow-exclude"));
905 if (!server_supports("deepen-relative") && args
->deepen_relative
)
906 die(_("Server does not support --deepen"));
908 if (everything_local(args
, &ref
, sought
, nr_sought
)) {
912 if (find_common(args
, fd
, sha1
, ref
) < 0)
913 if (!args
->keep_pack
)
914 /* When cloning, it is not unusual to have
917 warning(_("no common commits"));
919 if (args
->stateless_rpc
)
922 setup_alternate_shallow(&shallow_lock
, &alternate_shallow_file
,
924 else if (si
->nr_ours
|| si
->nr_theirs
)
925 alternate_shallow_file
= setup_temporary_shallow(si
->shallow
);
927 alternate_shallow_file
= NULL
;
928 if (get_pack(args
, fd
, pack_lockfile
))
929 die(_("git fetch-pack: fetch failed."));
935 static void fetch_pack_config(void)
937 git_config_get_int("fetch.unpacklimit", &fetch_unpack_limit
);
938 git_config_get_int("transfer.unpacklimit", &transfer_unpack_limit
);
939 git_config_get_bool("repack.usedeltabaseoffset", &prefer_ofs_delta
);
940 git_config_get_bool("fetch.fsckobjects", &fetch_fsck_objects
);
941 git_config_get_bool("transfer.fsckobjects", &transfer_fsck_objects
);
943 git_config(git_default_config
, NULL
);
946 static void fetch_pack_setup(void)
948 static int did_setup
;
952 if (0 <= transfer_unpack_limit
)
953 unpack_limit
= transfer_unpack_limit
;
954 else if (0 <= fetch_unpack_limit
)
955 unpack_limit
= fetch_unpack_limit
;
959 static int remove_duplicates_in_refs(struct ref
**ref
, int nr
)
961 struct string_list names
= STRING_LIST_INIT_NODUP
;
964 for (src
= dst
= 0; src
< nr
; src
++) {
965 struct string_list_item
*item
;
966 item
= string_list_insert(&names
, ref
[src
]->name
);
968 continue; /* already have it */
969 item
->util
= ref
[src
];
974 for (src
= dst
; src
< nr
; src
++)
976 string_list_clear(&names
, 0);
980 static void update_shallow(struct fetch_pack_args
*args
,
981 struct ref
**sought
, int nr_sought
,
982 struct shallow_info
*si
)
984 struct sha1_array ref
= SHA1_ARRAY_INIT
;
988 if (args
->deepen
&& alternate_shallow_file
) {
989 if (*alternate_shallow_file
== '\0') { /* --unshallow */
990 unlink_or_warn(git_path_shallow());
991 rollback_lock_file(&shallow_lock
);
993 commit_lock_file(&shallow_lock
);
997 if (!si
->shallow
|| !si
->shallow
->nr
)
1000 if (args
->cloning
) {
1002 * remote is shallow, but this is a clone, there are
1003 * no objects in repo to worry about. Accept any
1004 * shallow points that exist in the pack (iow in repo
1005 * after get_pack() and reprepare_packed_git())
1007 struct sha1_array extra
= SHA1_ARRAY_INIT
;
1008 unsigned char (*sha1
)[20] = si
->shallow
->sha1
;
1009 for (i
= 0; i
< si
->shallow
->nr
; i
++)
1010 if (has_sha1_file(sha1
[i
]))
1011 sha1_array_append(&extra
, sha1
[i
]);
1013 setup_alternate_shallow(&shallow_lock
,
1014 &alternate_shallow_file
,
1016 commit_lock_file(&shallow_lock
);
1018 sha1_array_clear(&extra
);
1022 if (!si
->nr_ours
&& !si
->nr_theirs
)
1025 remove_nonexistent_theirs_shallow(si
);
1026 if (!si
->nr_ours
&& !si
->nr_theirs
)
1028 for (i
= 0; i
< nr_sought
; i
++)
1029 sha1_array_append(&ref
, sought
[i
]->old_oid
.hash
);
1032 if (args
->update_shallow
) {
1034 * remote is also shallow, .git/shallow may be updated
1035 * so all refs can be accepted. Make sure we only add
1036 * shallow roots that are actually reachable from new
1039 struct sha1_array extra
= SHA1_ARRAY_INIT
;
1040 unsigned char (*sha1
)[20] = si
->shallow
->sha1
;
1041 assign_shallow_commits_to_refs(si
, NULL
, NULL
);
1042 if (!si
->nr_ours
&& !si
->nr_theirs
) {
1043 sha1_array_clear(&ref
);
1046 for (i
= 0; i
< si
->nr_ours
; i
++)
1047 sha1_array_append(&extra
, sha1
[si
->ours
[i
]]);
1048 for (i
= 0; i
< si
->nr_theirs
; i
++)
1049 sha1_array_append(&extra
, sha1
[si
->theirs
[i
]]);
1050 setup_alternate_shallow(&shallow_lock
,
1051 &alternate_shallow_file
,
1053 commit_lock_file(&shallow_lock
);
1054 sha1_array_clear(&extra
);
1055 sha1_array_clear(&ref
);
1060 * remote is also shallow, check what ref is safe to update
1061 * without updating .git/shallow
1063 status
= xcalloc(nr_sought
, sizeof(*status
));
1064 assign_shallow_commits_to_refs(si
, NULL
, status
);
1065 if (si
->nr_ours
|| si
->nr_theirs
) {
1066 for (i
= 0; i
< nr_sought
; i
++)
1068 sought
[i
]->status
= REF_STATUS_REJECT_SHALLOW
;
1071 sha1_array_clear(&ref
);
1074 struct ref
*fetch_pack(struct fetch_pack_args
*args
,
1075 int fd
[], struct child_process
*conn
,
1076 const struct ref
*ref
,
1078 struct ref
**sought
, int nr_sought
,
1079 struct sha1_array
*shallow
,
1080 char **pack_lockfile
)
1082 struct ref
*ref_cpy
;
1083 struct shallow_info si
;
1087 nr_sought
= remove_duplicates_in_refs(sought
, nr_sought
);
1090 packet_flush(fd
[1]);
1091 die(_("no matching remote head"));
1093 prepare_shallow_info(&si
, shallow
);
1094 ref_cpy
= do_fetch_pack(args
, fd
, ref
, sought
, nr_sought
,
1095 &si
, pack_lockfile
);
1096 reprepare_packed_git();
1097 update_shallow(args
, sought
, nr_sought
, &si
);
1098 clear_shallow_info(&si
);