2 #include "repository.h"
12 #include "fetch-pack.h"
14 #include "run-command.h"
16 #include "transport.h"
18 #include "prio-queue.h"
19 #include "sha1-array.h"
22 #include "object-store.h"
23 #include "connected.h"
26 static int transfer_unpack_limit
= -1;
27 static int fetch_unpack_limit
= -1;
28 static int unpack_limit
= 100;
29 static int prefer_ofs_delta
= 1;
31 static int deepen_since_ok
;
32 static int deepen_not_ok
;
33 static int fetch_fsck_objects
= -1;
34 static int transfer_fsck_objects
= -1;
35 static int agent_supported
;
36 static int server_supports_filtering
;
37 static struct lock_file shallow_lock
;
38 static const char *alternate_shallow_file
;
39 static struct strbuf fsck_msg_types
= STRBUF_INIT
;
41 /* Remember to update object flag allocation in object.h */
42 #define COMPLETE (1U << 0)
43 #define COMMON (1U << 1)
44 #define COMMON_REF (1U << 2)
45 #define SEEN (1U << 3)
46 #define POPPED (1U << 4)
47 #define ALTERNATE (1U << 5)
52 * After sending this many "have"s if we do not get any new ACK , we
53 * give up traversing our history.
55 #define MAX_IN_VAIN 256
57 static struct prio_queue rev_list
= { compare_commits_by_commit_date
};
58 static int non_common_revs
, multi_ack
, use_sideband
;
59 /* Allow specifying sha1 if it is a ref tip. */
60 #define ALLOW_TIP_SHA1 01
61 /* Allow request of a sha1 if it is reachable from a ref (possibly hidden ref). */
62 #define ALLOW_REACHABLE_SHA1 02
63 static unsigned int allow_unadvertised_object_request
;
65 __attribute__((format (printf
, 2, 3)))
66 static inline void print_verbose(const struct fetch_pack_args
*args
,
74 va_start(params
, fmt
);
75 vfprintf(stderr
, fmt
, params
);
80 struct alternate_object_cache
{
81 struct object
**items
;
85 static void cache_one_alternate(const char *refname
,
86 const struct object_id
*oid
,
89 struct alternate_object_cache
*cache
= vcache
;
90 struct object
*obj
= parse_object(oid
);
92 if (!obj
|| (obj
->flags
& ALTERNATE
))
95 obj
->flags
|= ALTERNATE
;
96 ALLOC_GROW(cache
->items
, cache
->nr
+ 1, cache
->alloc
);
97 cache
->items
[cache
->nr
++] = obj
;
100 static void for_each_cached_alternate(void (*cb
)(struct object
*))
102 static int initialized
;
103 static struct alternate_object_cache cache
;
107 for_each_alternate_ref(cache_one_alternate
, &cache
);
111 for (i
= 0; i
< cache
.nr
; i
++)
115 static void rev_list_push(struct commit
*commit
, int mark
)
117 if (!(commit
->object
.flags
& mark
)) {
118 commit
->object
.flags
|= mark
;
120 if (parse_commit(commit
))
123 prio_queue_put(&rev_list
, commit
);
125 if (!(commit
->object
.flags
& COMMON
))
130 static int rev_list_insert_ref(const char *refname
, const struct object_id
*oid
)
132 struct object
*o
= deref_tag(parse_object(oid
), refname
, 0);
134 if (o
&& o
->type
== OBJ_COMMIT
)
135 rev_list_push((struct commit
*)o
, SEEN
);
140 static int rev_list_insert_ref_oid(const char *refname
, const struct object_id
*oid
,
141 int flag
, void *cb_data
)
143 return rev_list_insert_ref(refname
, oid
);
146 static int clear_marks(const char *refname
, const struct object_id
*oid
,
147 int flag
, void *cb_data
)
149 struct object
*o
= deref_tag(parse_object(oid
), refname
, 0);
151 if (o
&& o
->type
== OBJ_COMMIT
)
152 clear_commit_marks((struct commit
*)o
,
153 COMMON
| COMMON_REF
| SEEN
| POPPED
);
158 This function marks a rev and its ancestors as common.
159 In some cases, it is desirable to mark only the ancestors (for example
160 when only the server does not yet know that they are common).
163 static void mark_common(struct commit
*commit
,
164 int ancestors_only
, int dont_parse
)
166 if (commit
!= NULL
&& !(commit
->object
.flags
& COMMON
)) {
167 struct object
*o
= (struct object
*)commit
;
172 if (!(o
->flags
& SEEN
))
173 rev_list_push(commit
, SEEN
);
175 struct commit_list
*parents
;
177 if (!ancestors_only
&& !(o
->flags
& POPPED
))
179 if (!o
->parsed
&& !dont_parse
)
180 if (parse_commit(commit
))
183 for (parents
= commit
->parents
;
185 parents
= parents
->next
)
186 mark_common(parents
->item
, 0, dont_parse
);
192 Get the next rev to send, ignoring the common.
195 static const struct object_id
*get_rev(void)
197 struct commit
*commit
= NULL
;
199 while (commit
== NULL
) {
201 struct commit_list
*parents
;
203 if (rev_list
.nr
== 0 || non_common_revs
== 0)
206 commit
= prio_queue_get(&rev_list
);
207 parse_commit(commit
);
208 parents
= commit
->parents
;
210 commit
->object
.flags
|= POPPED
;
211 if (!(commit
->object
.flags
& COMMON
))
214 if (commit
->object
.flags
& COMMON
) {
215 /* do not send "have", and ignore ancestors */
217 mark
= COMMON
| SEEN
;
218 } else if (commit
->object
.flags
& COMMON_REF
)
219 /* send "have", and ignore ancestors */
220 mark
= COMMON
| SEEN
;
222 /* send "have", also for its ancestors */
226 if (!(parents
->item
->object
.flags
& SEEN
))
227 rev_list_push(parents
->item
, mark
);
229 mark_common(parents
->item
, 1, 0);
230 parents
= parents
->next
;
234 return &commit
->object
.oid
;
245 static void consume_shallow_list(struct fetch_pack_args
*args
, int fd
)
247 if (args
->stateless_rpc
&& args
->deepen
) {
248 /* If we sent a depth we will get back "duplicate"
249 * shallow and unshallow commands every time there
250 * is a block of have lines exchanged.
253 while ((line
= packet_read_line(fd
, NULL
))) {
254 if (starts_with(line
, "shallow "))
256 if (starts_with(line
, "unshallow "))
258 die(_("git fetch-pack: expected shallow list"));
263 static enum ack_type
get_ack(int fd
, struct object_id
*result_oid
)
266 char *line
= packet_read_line(fd
, &len
);
270 die(_("git fetch-pack: expected ACK/NAK, got a flush packet"));
271 if (!strcmp(line
, "NAK"))
273 if (skip_prefix(line
, "ACK ", &arg
)) {
274 if (!get_oid_hex(arg
, result_oid
)) {
279 if (strstr(arg
, "continue"))
281 if (strstr(arg
, "common"))
283 if (strstr(arg
, "ready"))
288 if (skip_prefix(line
, "ERR ", &arg
))
289 die(_("remote error: %s"), arg
);
290 die(_("git fetch-pack: expected ACK/NAK, got '%s'"), line
);
293 static void send_request(struct fetch_pack_args
*args
,
294 int fd
, struct strbuf
*buf
)
296 if (args
->stateless_rpc
) {
297 send_sideband(fd
, -1, buf
->buf
, buf
->len
, LARGE_PACKET_MAX
);
300 write_or_die(fd
, buf
->buf
, buf
->len
);
303 static void insert_one_alternate_object(struct object
*obj
)
305 rev_list_insert_ref(NULL
, &obj
->oid
);
308 #define INITIAL_FLUSH 16
309 #define PIPESAFE_FLUSH 32
310 #define LARGE_FLUSH 16384
312 static int next_flush(int stateless_rpc
, int count
)
315 if (count
< LARGE_FLUSH
)
318 count
= count
* 11 / 10;
320 if (count
< PIPESAFE_FLUSH
)
323 count
+= PIPESAFE_FLUSH
;
328 static int find_common(struct fetch_pack_args
*args
,
329 int fd
[2], struct object_id
*result_oid
,
333 int count
= 0, flushes
= 0, flush_at
= INITIAL_FLUSH
, retval
;
334 const struct object_id
*oid
;
335 unsigned in_vain
= 0;
336 int got_continue
= 0;
338 struct strbuf req_buf
= STRBUF_INIT
;
339 size_t state_len
= 0;
341 if (args
->stateless_rpc
&& multi_ack
== 1)
342 die(_("--stateless-rpc requires multi_ack_detailed"));
344 for_each_ref(clear_marks
, NULL
);
347 for_each_ref(rev_list_insert_ref_oid
, NULL
);
348 for_each_cached_alternate(insert_one_alternate_object
);
351 for ( ; refs
; refs
= refs
->next
) {
352 struct object_id
*remote
= &refs
->old_oid
;
353 const char *remote_hex
;
357 * If that object is complete (i.e. it is an ancestor of a
358 * local ref), we tell them we have it but do not have to
359 * tell them about its ancestors, which they already know
362 * We use lookup_object here because we are only
363 * interested in the case we *know* the object is
364 * reachable and we have already scanned it.
366 if (((o
= lookup_object(remote
->hash
)) != NULL
) &&
367 (o
->flags
& COMPLETE
)) {
371 remote_hex
= oid_to_hex(remote
);
373 struct strbuf c
= STRBUF_INIT
;
374 if (multi_ack
== 2) strbuf_addstr(&c
, " multi_ack_detailed");
375 if (multi_ack
== 1) strbuf_addstr(&c
, " multi_ack");
376 if (no_done
) strbuf_addstr(&c
, " no-done");
377 if (use_sideband
== 2) strbuf_addstr(&c
, " side-band-64k");
378 if (use_sideband
== 1) strbuf_addstr(&c
, " side-band");
379 if (args
->deepen_relative
) strbuf_addstr(&c
, " deepen-relative");
380 if (args
->use_thin_pack
) strbuf_addstr(&c
, " thin-pack");
381 if (args
->no_progress
) strbuf_addstr(&c
, " no-progress");
382 if (args
->include_tag
) strbuf_addstr(&c
, " include-tag");
383 if (prefer_ofs_delta
) strbuf_addstr(&c
, " ofs-delta");
384 if (deepen_since_ok
) strbuf_addstr(&c
, " deepen-since");
385 if (deepen_not_ok
) strbuf_addstr(&c
, " deepen-not");
386 if (agent_supported
) strbuf_addf(&c
, " agent=%s",
387 git_user_agent_sanitized());
388 if (args
->filter_options
.choice
)
389 strbuf_addstr(&c
, " filter");
390 packet_buf_write(&req_buf
, "want %s%s\n", remote_hex
, c
.buf
);
393 packet_buf_write(&req_buf
, "want %s\n", remote_hex
);
398 strbuf_release(&req_buf
);
403 if (is_repository_shallow(the_repository
))
404 write_shallow_commits(&req_buf
, 1, NULL
);
406 packet_buf_write(&req_buf
, "deepen %d", args
->depth
);
407 if (args
->deepen_since
) {
408 timestamp_t max_age
= approxidate(args
->deepen_since
);
409 packet_buf_write(&req_buf
, "deepen-since %"PRItime
, max_age
);
411 if (args
->deepen_not
) {
413 for (i
= 0; i
< args
->deepen_not
->nr
; i
++) {
414 struct string_list_item
*s
= args
->deepen_not
->items
+ i
;
415 packet_buf_write(&req_buf
, "deepen-not %s", s
->string
);
418 if (server_supports_filtering
&& args
->filter_options
.choice
)
419 packet_buf_write(&req_buf
, "filter %s",
420 args
->filter_options
.filter_spec
);
421 packet_buf_flush(&req_buf
);
422 state_len
= req_buf
.len
;
427 struct object_id oid
;
429 send_request(args
, fd
[1], &req_buf
);
430 while ((line
= packet_read_line(fd
[0], NULL
))) {
431 if (skip_prefix(line
, "shallow ", &arg
)) {
432 if (get_oid_hex(arg
, &oid
))
433 die(_("invalid shallow line: %s"), line
);
434 register_shallow(the_repository
, &oid
);
437 if (skip_prefix(line
, "unshallow ", &arg
)) {
438 if (get_oid_hex(arg
, &oid
))
439 die(_("invalid unshallow line: %s"), line
);
440 if (!lookup_object(oid
.hash
))
441 die(_("object not found: %s"), line
);
442 /* make sure that it is parsed as shallow */
443 if (!parse_object(&oid
))
444 die(_("error in object: %s"), line
);
445 if (unregister_shallow(&oid
))
446 die(_("no shallow found: %s"), line
);
449 die(_("expected shallow/unshallow, got %s"), line
);
451 } else if (!args
->stateless_rpc
)
452 send_request(args
, fd
[1], &req_buf
);
454 if (!args
->stateless_rpc
) {
455 /* If we aren't using the stateless-rpc interface
456 * we don't need to retain the headers.
458 strbuf_setlen(&req_buf
, 0);
464 if (args
->no_dependents
)
466 while ((oid
= get_rev())) {
467 packet_buf_write(&req_buf
, "have %s\n", oid_to_hex(oid
));
468 print_verbose(args
, "have %s", oid_to_hex(oid
));
470 if (flush_at
<= ++count
) {
473 packet_buf_flush(&req_buf
);
474 send_request(args
, fd
[1], &req_buf
);
475 strbuf_setlen(&req_buf
, state_len
);
477 flush_at
= next_flush(args
->stateless_rpc
, count
);
480 * We keep one window "ahead" of the other side, and
481 * will wait for an ACK only on the next one
483 if (!args
->stateless_rpc
&& count
== INITIAL_FLUSH
)
486 consume_shallow_list(args
, fd
[0]);
488 ack
= get_ack(fd
[0], result_oid
);
490 print_verbose(args
, _("got %s %d %s"), "ack",
491 ack
, oid_to_hex(result_oid
));
501 struct commit
*commit
=
502 lookup_commit(result_oid
);
504 die(_("invalid commit %s"), oid_to_hex(result_oid
));
505 if (args
->stateless_rpc
507 && !(commit
->object
.flags
& COMMON
)) {
508 /* We need to replay the have for this object
509 * on the next RPC request so the peer knows
510 * it is in common with us.
512 const char *hex
= oid_to_hex(result_oid
);
513 packet_buf_write(&req_buf
, "have %s\n", hex
);
514 state_len
= req_buf
.len
;
516 * Reset in_vain because an ack
517 * for this commit has not been
521 } else if (!args
->stateless_rpc
522 || ack
!= ACK_common
)
524 mark_common(commit
, 0, 1);
527 if (ack
== ACK_ready
) {
528 clear_prio_queue(&rev_list
);
536 if (got_continue
&& MAX_IN_VAIN
< in_vain
) {
537 print_verbose(args
, _("giving up"));
543 if (!got_ready
|| !no_done
) {
544 packet_buf_write(&req_buf
, "done\n");
545 send_request(args
, fd
[1], &req_buf
);
547 print_verbose(args
, _("done"));
552 strbuf_release(&req_buf
);
554 if (!got_ready
|| !no_done
)
555 consume_shallow_list(args
, fd
[0]);
556 while (flushes
|| multi_ack
) {
557 int ack
= get_ack(fd
[0], result_oid
);
559 print_verbose(args
, _("got %s (%d) %s"), "ack",
560 ack
, oid_to_hex(result_oid
));
568 /* it is no error to fetch into a completely empty repo */
569 return count
? retval
: 0;
572 static struct commit_list
*complete
;
574 static int mark_complete(const struct object_id
*oid
)
576 struct object
*o
= parse_object(oid
);
578 while (o
&& o
->type
== OBJ_TAG
) {
579 struct tag
*t
= (struct tag
*) o
;
581 break; /* broken repository */
582 o
->flags
|= COMPLETE
;
583 o
= parse_object(&t
->tagged
->oid
);
585 if (o
&& o
->type
== OBJ_COMMIT
) {
586 struct commit
*commit
= (struct commit
*)o
;
587 if (!(commit
->object
.flags
& COMPLETE
)) {
588 commit
->object
.flags
|= COMPLETE
;
589 commit_list_insert(commit
, &complete
);
595 static int mark_complete_oid(const char *refname
, const struct object_id
*oid
,
596 int flag
, void *cb_data
)
598 return mark_complete(oid
);
601 static void mark_recent_complete_commits(struct fetch_pack_args
*args
,
604 while (complete
&& cutoff
<= complete
->item
->date
) {
605 print_verbose(args
, _("Marking %s as complete"),
606 oid_to_hex(&complete
->item
->object
.oid
));
607 pop_most_recent_commit(&complete
, COMPLETE
);
611 static void add_refs_to_oidset(struct oidset
*oids
, struct ref
*refs
)
613 for (; refs
; refs
= refs
->next
)
614 oidset_insert(oids
, &refs
->old_oid
);
617 static int tip_oids_contain(struct oidset
*tip_oids
,
618 struct ref
*unmatched
, struct ref
*newlist
,
619 const struct object_id
*id
)
622 * Note that this only looks at the ref lists the first time it's
623 * called. This works out in filter_refs() because even though it may
624 * add to "newlist" between calls, the additions will always be for
625 * oids that are already in the set.
627 if (!tip_oids
->map
.map
.tablesize
) {
628 add_refs_to_oidset(tip_oids
, unmatched
);
629 add_refs_to_oidset(tip_oids
, newlist
);
631 return oidset_contains(tip_oids
, id
);
634 static void filter_refs(struct fetch_pack_args
*args
,
636 struct ref
**sought
, int nr_sought
)
638 struct ref
*newlist
= NULL
;
639 struct ref
**newtail
= &newlist
;
640 struct ref
*unmatched
= NULL
;
641 struct ref
*ref
, *next
;
642 struct oidset tip_oids
= OIDSET_INIT
;
646 for (ref
= *refs
; ref
; ref
= next
) {
650 if (starts_with(ref
->name
, "refs/") &&
651 check_refname_format(ref
->name
, 0))
654 while (i
< nr_sought
) {
655 int cmp
= strcmp(ref
->name
, sought
[i
]->name
);
657 break; /* definitely do not have it */
659 keep
= 1; /* definitely have it */
660 sought
[i
]->match_status
= REF_MATCHED
;
665 if (!keep
&& args
->fetch_all
&&
666 (!args
->deepen
|| !starts_with(ref
->name
, "refs/tags/")))
673 newtail
= &ref
->next
;
675 ref
->next
= unmatched
;
680 /* Append unmatched requests to the list */
681 for (i
= 0; i
< nr_sought
; i
++) {
682 struct object_id oid
;
686 if (ref
->match_status
!= REF_NOT_MATCHED
)
688 if (parse_oid_hex(ref
->name
, &oid
, &p
) ||
690 oidcmp(&oid
, &ref
->old_oid
))
693 if ((allow_unadvertised_object_request
&
694 (ALLOW_TIP_SHA1
| ALLOW_REACHABLE_SHA1
)) ||
695 tip_oids_contain(&tip_oids
, unmatched
, newlist
,
697 ref
->match_status
= REF_MATCHED
;
698 *newtail
= copy_ref(ref
);
699 newtail
= &(*newtail
)->next
;
701 ref
->match_status
= REF_UNADVERTISED_NOT_ALLOWED
;
705 oidset_clear(&tip_oids
);
706 for (ref
= unmatched
; ref
; ref
= next
) {
714 static void mark_alternate_complete(struct object
*obj
)
716 mark_complete(&obj
->oid
);
719 struct loose_object_iter
{
720 struct oidset
*loose_object_set
;
725 * If the number of refs is not larger than the number of loose objects,
726 * this function stops inserting.
728 static int add_loose_objects_to_set(const struct object_id
*oid
,
732 struct loose_object_iter
*iter
= data
;
733 oidset_insert(iter
->loose_object_set
, oid
);
734 if (iter
->refs
== NULL
)
737 iter
->refs
= iter
->refs
->next
;
741 static int everything_local(struct fetch_pack_args
*args
,
743 struct ref
**sought
, int nr_sought
)
747 int old_save_commit_buffer
= save_commit_buffer
;
748 timestamp_t cutoff
= 0;
749 struct oidset loose_oid_set
= OIDSET_INIT
;
751 struct loose_object_iter iter
= {&loose_oid_set
, *refs
};
753 /* Enumerate all loose objects or know refs are not so many. */
754 use_oidset
= !for_each_loose_object(add_loose_objects_to_set
,
757 save_commit_buffer
= 0;
759 for (ref
= *refs
; ref
; ref
= ref
->next
) {
761 unsigned int flags
= OBJECT_INFO_QUICK
;
764 !oidset_contains(&loose_oid_set
, &ref
->old_oid
)) {
766 * I know this does not exist in the loose form,
767 * so check if it exists in a non-loose form.
769 flags
|= OBJECT_INFO_IGNORE_LOOSE
;
772 if (!has_object_file_with_flags(&ref
->old_oid
, flags
))
774 o
= parse_object(&ref
->old_oid
);
778 /* We already have it -- which may mean that we were
779 * in sync with the other side at some time after
780 * that (it is OK if we guess wrong here).
782 if (o
->type
== OBJ_COMMIT
) {
783 struct commit
*commit
= (struct commit
*)o
;
784 if (!cutoff
|| cutoff
< commit
->date
)
785 cutoff
= commit
->date
;
789 oidset_clear(&loose_oid_set
);
791 if (!args
->no_dependents
) {
793 for_each_ref(mark_complete_oid
, NULL
);
794 for_each_cached_alternate(mark_alternate_complete
);
795 commit_list_sort_by_date(&complete
);
797 mark_recent_complete_commits(args
, cutoff
);
801 * Mark all complete remote refs as common refs.
802 * Don't mark them common yet; the server has to be told so first.
804 for (ref
= *refs
; ref
; ref
= ref
->next
) {
805 struct object
*o
= deref_tag(lookup_object(ref
->old_oid
.hash
),
808 if (!o
|| o
->type
!= OBJ_COMMIT
|| !(o
->flags
& COMPLETE
))
811 if (!(o
->flags
& SEEN
)) {
812 rev_list_push((struct commit
*)o
, COMMON_REF
| SEEN
);
814 mark_common((struct commit
*)o
, 1, 1);
819 filter_refs(args
, refs
, sought
, nr_sought
);
821 for (retval
= 1, ref
= *refs
; ref
; ref
= ref
->next
) {
822 const struct object_id
*remote
= &ref
->old_oid
;
825 o
= lookup_object(remote
->hash
);
826 if (!o
|| !(o
->flags
& COMPLETE
)) {
828 print_verbose(args
, "want %s (%s)", oid_to_hex(remote
),
832 print_verbose(args
, _("already have %s (%s)"), oid_to_hex(remote
),
836 save_commit_buffer
= old_save_commit_buffer
;
841 static int sideband_demux(int in
, int out
, void *data
)
846 ret
= recv_sideband("fetch-pack", xd
[0], out
);
851 static int get_pack(struct fetch_pack_args
*args
,
852 int xd
[2], char **pack_lockfile
)
855 int do_keep
= args
->keep_pack
;
856 const char *cmd_name
;
857 struct pack_header header
;
859 struct child_process cmd
= CHILD_PROCESS_INIT
;
862 memset(&demux
, 0, sizeof(demux
));
864 /* xd[] is talking with upload-pack; subprocess reads from
865 * xd[0], spits out band#2 to stderr, and feeds us band#1
866 * through demux->out.
868 demux
.proc
= sideband_demux
;
871 demux
.isolate_sigpipe
= 1;
872 if (start_async(&demux
))
873 die(_("fetch-pack: unable to fork off sideband demultiplexer"));
878 if (!args
->keep_pack
&& unpack_limit
) {
880 if (read_pack_header(demux
.out
, &header
))
881 die(_("protocol error: bad pack header"));
883 if (ntohl(header
.hdr_entries
) < unpack_limit
)
889 if (alternate_shallow_file
) {
890 argv_array_push(&cmd
.args
, "--shallow-file");
891 argv_array_push(&cmd
.args
, alternate_shallow_file
);
894 if (do_keep
|| args
->from_promisor
) {
897 cmd_name
= "index-pack";
898 argv_array_push(&cmd
.args
, cmd_name
);
899 argv_array_push(&cmd
.args
, "--stdin");
900 if (!args
->quiet
&& !args
->no_progress
)
901 argv_array_push(&cmd
.args
, "-v");
902 if (args
->use_thin_pack
)
903 argv_array_push(&cmd
.args
, "--fix-thin");
904 if (do_keep
&& (args
->lock_pack
|| unpack_limit
)) {
905 char hostname
[HOST_NAME_MAX
+ 1];
906 if (xgethostname(hostname
, sizeof(hostname
)))
907 xsnprintf(hostname
, sizeof(hostname
), "localhost");
908 argv_array_pushf(&cmd
.args
,
909 "--keep=fetch-pack %"PRIuMAX
" on %s",
910 (uintmax_t)getpid(), hostname
);
912 if (args
->check_self_contained_and_connected
)
913 argv_array_push(&cmd
.args
, "--check-self-contained-and-connected");
914 if (args
->from_promisor
)
915 argv_array_push(&cmd
.args
, "--promisor");
918 cmd_name
= "unpack-objects";
919 argv_array_push(&cmd
.args
, cmd_name
);
920 if (args
->quiet
|| args
->no_progress
)
921 argv_array_push(&cmd
.args
, "-q");
922 args
->check_self_contained_and_connected
= 0;
926 argv_array_pushf(&cmd
.args
, "--pack_header=%"PRIu32
",%"PRIu32
,
927 ntohl(header
.hdr_version
),
928 ntohl(header
.hdr_entries
));
929 if (fetch_fsck_objects
>= 0
931 : transfer_fsck_objects
>= 0
932 ? transfer_fsck_objects
934 if (args
->from_promisor
)
936 * We cannot use --strict in index-pack because it
937 * checks both broken objects and links, but we only
938 * want to check for broken objects.
940 argv_array_push(&cmd
.args
, "--fsck-objects");
942 argv_array_pushf(&cmd
.args
, "--strict%s",
948 if (start_command(&cmd
))
949 die(_("fetch-pack: unable to fork off %s"), cmd_name
);
950 if (do_keep
&& pack_lockfile
) {
951 *pack_lockfile
= index_pack_lockfile(cmd
.out
);
956 /* Closed by start_command() */
959 ret
= finish_command(&cmd
);
960 if (!ret
|| (args
->check_self_contained_and_connected
&& ret
== 1))
961 args
->self_contained_and_connected
=
962 args
->check_self_contained_and_connected
&&
965 die(_("%s failed"), cmd_name
);
966 if (use_sideband
&& finish_async(&demux
))
967 die(_("error in sideband demultiplexer"));
971 static int cmp_ref_by_name(const void *a_
, const void *b_
)
973 const struct ref
*a
= *((const struct ref
**)a_
);
974 const struct ref
*b
= *((const struct ref
**)b_
);
975 return strcmp(a
->name
, b
->name
);
978 static struct ref
*do_fetch_pack(struct fetch_pack_args
*args
,
980 const struct ref
*orig_ref
,
981 struct ref
**sought
, int nr_sought
,
982 struct shallow_info
*si
,
983 char **pack_lockfile
)
985 struct ref
*ref
= copy_ref_list(orig_ref
);
986 struct object_id oid
;
987 const char *agent_feature
;
990 sort_ref_list(&ref
, ref_compare_name
);
991 QSORT(sought
, nr_sought
, cmp_ref_by_name
);
993 if ((args
->depth
> 0 || is_repository_shallow(the_repository
)) && !server_supports("shallow"))
994 die(_("Server does not support shallow clients"));
995 if (args
->depth
> 0 || args
->deepen_since
|| args
->deepen_not
)
997 if (server_supports("multi_ack_detailed")) {
998 print_verbose(args
, _("Server supports multi_ack_detailed"));
1000 if (server_supports("no-done")) {
1001 print_verbose(args
, _("Server supports no-done"));
1002 if (args
->stateless_rpc
)
1006 else if (server_supports("multi_ack")) {
1007 print_verbose(args
, _("Server supports multi_ack"));
1010 if (server_supports("side-band-64k")) {
1011 print_verbose(args
, _("Server supports side-band-64k"));
1014 else if (server_supports("side-band")) {
1015 print_verbose(args
, _("Server supports side-band"));
1018 if (server_supports("allow-tip-sha1-in-want")) {
1019 print_verbose(args
, _("Server supports allow-tip-sha1-in-want"));
1020 allow_unadvertised_object_request
|= ALLOW_TIP_SHA1
;
1022 if (server_supports("allow-reachable-sha1-in-want")) {
1023 print_verbose(args
, _("Server supports allow-reachable-sha1-in-want"));
1024 allow_unadvertised_object_request
|= ALLOW_REACHABLE_SHA1
;
1026 if (!server_supports("thin-pack"))
1027 args
->use_thin_pack
= 0;
1028 if (!server_supports("no-progress"))
1029 args
->no_progress
= 0;
1030 if (!server_supports("include-tag"))
1031 args
->include_tag
= 0;
1032 if (server_supports("ofs-delta"))
1033 print_verbose(args
, _("Server supports ofs-delta"));
1035 prefer_ofs_delta
= 0;
1037 if (server_supports("filter")) {
1038 server_supports_filtering
= 1;
1039 print_verbose(args
, _("Server supports filter"));
1040 } else if (args
->filter_options
.choice
) {
1041 warning("filtering not recognized by server, ignoring");
1044 if ((agent_feature
= server_feature_value("agent", &agent_len
))) {
1045 agent_supported
= 1;
1047 print_verbose(args
, _("Server version is %.*s"),
1048 agent_len
, agent_feature
);
1050 if (server_supports("deepen-since"))
1051 deepen_since_ok
= 1;
1052 else if (args
->deepen_since
)
1053 die(_("Server does not support --shallow-since"));
1054 if (server_supports("deepen-not"))
1056 else if (args
->deepen_not
)
1057 die(_("Server does not support --shallow-exclude"));
1058 if (!server_supports("deepen-relative") && args
->deepen_relative
)
1059 die(_("Server does not support --deepen"));
1061 if (everything_local(args
, &ref
, sought
, nr_sought
)) {
1062 packet_flush(fd
[1]);
1065 if (find_common(args
, fd
, &oid
, ref
) < 0)
1066 if (!args
->keep_pack
)
1067 /* When cloning, it is not unusual to have
1070 warning(_("no common commits"));
1072 if (args
->stateless_rpc
)
1073 packet_flush(fd
[1]);
1075 setup_alternate_shallow(&shallow_lock
, &alternate_shallow_file
,
1077 else if (si
->nr_ours
|| si
->nr_theirs
)
1078 alternate_shallow_file
= setup_temporary_shallow(si
->shallow
);
1080 alternate_shallow_file
= NULL
;
1081 if (get_pack(args
, fd
, pack_lockfile
))
1082 die(_("git fetch-pack: fetch failed."));
1088 static void add_shallow_requests(struct strbuf
*req_buf
,
1089 const struct fetch_pack_args
*args
)
1091 if (is_repository_shallow(the_repository
))
1092 write_shallow_commits(req_buf
, 1, NULL
);
1093 if (args
->depth
> 0)
1094 packet_buf_write(req_buf
, "deepen %d", args
->depth
);
1095 if (args
->deepen_since
) {
1096 timestamp_t max_age
= approxidate(args
->deepen_since
);
1097 packet_buf_write(req_buf
, "deepen-since %"PRItime
, max_age
);
1099 if (args
->deepen_not
) {
1101 for (i
= 0; i
< args
->deepen_not
->nr
; i
++) {
1102 struct string_list_item
*s
= args
->deepen_not
->items
+ i
;
1103 packet_buf_write(req_buf
, "deepen-not %s", s
->string
);
1108 static void add_wants(const struct ref
*wants
, struct strbuf
*req_buf
)
1110 int use_ref_in_want
= server_supports_feature("fetch", "ref-in-want", 0);
1112 for ( ; wants
; wants
= wants
->next
) {
1113 const struct object_id
*remote
= &wants
->old_oid
;
1117 * If that object is complete (i.e. it is an ancestor of a
1118 * local ref), we tell them we have it but do not have to
1119 * tell them about its ancestors, which they already know
1122 * We use lookup_object here because we are only
1123 * interested in the case we *know* the object is
1124 * reachable and we have already scanned it.
1126 if (((o
= lookup_object(remote
->hash
)) != NULL
) &&
1127 (o
->flags
& COMPLETE
)) {
1131 if (!use_ref_in_want
|| wants
->exact_oid
)
1132 packet_buf_write(req_buf
, "want %s\n", oid_to_hex(remote
));
1134 packet_buf_write(req_buf
, "want-ref %s\n", wants
->name
);
1138 static void add_common(struct strbuf
*req_buf
, struct oidset
*common
)
1140 struct oidset_iter iter
;
1141 const struct object_id
*oid
;
1142 oidset_iter_init(common
, &iter
);
1144 while ((oid
= oidset_iter_next(&iter
))) {
1145 packet_buf_write(req_buf
, "have %s\n", oid_to_hex(oid
));
1149 static int add_haves(struct strbuf
*req_buf
, int *haves_to_send
, int *in_vain
)
1152 int haves_added
= 0;
1153 const struct object_id
*oid
;
1155 while ((oid
= get_rev())) {
1156 packet_buf_write(req_buf
, "have %s\n", oid_to_hex(oid
));
1157 if (++haves_added
>= *haves_to_send
)
1161 *in_vain
+= haves_added
;
1162 if (!haves_added
|| *in_vain
>= MAX_IN_VAIN
) {
1164 packet_buf_write(req_buf
, "done\n");
1168 /* Increase haves to send on next round */
1169 *haves_to_send
= next_flush(1, *haves_to_send
);
1174 static int send_fetch_request(int fd_out
, const struct fetch_pack_args
*args
,
1175 const struct ref
*wants
, struct oidset
*common
,
1176 int *haves_to_send
, int *in_vain
)
1179 struct strbuf req_buf
= STRBUF_INIT
;
1181 if (server_supports_v2("fetch", 1))
1182 packet_buf_write(&req_buf
, "command=fetch");
1183 if (server_supports_v2("agent", 0))
1184 packet_buf_write(&req_buf
, "agent=%s", git_user_agent_sanitized());
1185 if (args
->server_options
&& args
->server_options
->nr
&&
1186 server_supports_v2("server-option", 1)) {
1188 for (i
= 0; i
< args
->server_options
->nr
; i
++)
1189 packet_write_fmt(fd_out
, "server-option=%s",
1190 args
->server_options
->items
[i
].string
);
1193 packet_buf_delim(&req_buf
);
1194 if (args
->use_thin_pack
)
1195 packet_buf_write(&req_buf
, "thin-pack");
1196 if (args
->no_progress
)
1197 packet_buf_write(&req_buf
, "no-progress");
1198 if (args
->include_tag
)
1199 packet_buf_write(&req_buf
, "include-tag");
1200 if (prefer_ofs_delta
)
1201 packet_buf_write(&req_buf
, "ofs-delta");
1203 /* Add shallow-info and deepen request */
1204 if (server_supports_feature("fetch", "shallow", 0))
1205 add_shallow_requests(&req_buf
, args
);
1206 else if (is_repository_shallow(the_repository
) || args
->deepen
)
1207 die(_("Server does not support shallow requests"));
1210 if (server_supports_feature("fetch", "filter", 0) &&
1211 args
->filter_options
.choice
) {
1212 print_verbose(args
, _("Server supports filter"));
1213 packet_buf_write(&req_buf
, "filter %s",
1214 args
->filter_options
.filter_spec
);
1215 } else if (args
->filter_options
.choice
) {
1216 warning("filtering not recognized by server, ignoring");
1220 add_wants(wants
, &req_buf
);
1222 if (args
->no_dependents
) {
1223 packet_buf_write(&req_buf
, "done");
1226 /* Add all of the common commits we've found in previous rounds */
1227 add_common(&req_buf
, common
);
1229 /* Add initial haves */
1230 ret
= add_haves(&req_buf
, haves_to_send
, in_vain
);
1234 packet_buf_flush(&req_buf
);
1235 write_or_die(fd_out
, req_buf
.buf
, req_buf
.len
);
1237 strbuf_release(&req_buf
);
1242 * Processes a section header in a server's response and checks if it matches
1243 * `section`. If the value of `peek` is 1, the header line will be peeked (and
1244 * not consumed); if 0, the line will be consumed and the function will die if
1245 * the section header doesn't match what was expected.
1247 static int process_section_header(struct packet_reader
*reader
,
1248 const char *section
, int peek
)
1252 if (packet_reader_peek(reader
) != PACKET_READ_NORMAL
)
1253 die("error reading section header '%s'", section
);
1255 ret
= !strcmp(reader
->line
, section
);
1259 die("expected '%s', received '%s'",
1260 section
, reader
->line
);
1261 packet_reader_read(reader
);
1267 static int process_acks(struct packet_reader
*reader
, struct oidset
*common
)
1270 int received_ready
= 0;
1271 int received_ack
= 0;
1273 process_section_header(reader
, "acknowledgments", 0);
1274 while (packet_reader_read(reader
) == PACKET_READ_NORMAL
) {
1277 if (!strcmp(reader
->line
, "NAK"))
1280 if (skip_prefix(reader
->line
, "ACK ", &arg
)) {
1281 struct object_id oid
;
1282 if (!get_oid_hex(arg
, &oid
)) {
1283 struct commit
*commit
;
1284 oidset_insert(common
, &oid
);
1285 commit
= lookup_commit(&oid
);
1286 mark_common(commit
, 0, 1);
1291 if (!strcmp(reader
->line
, "ready")) {
1292 clear_prio_queue(&rev_list
);
1297 die("unexpected acknowledgment line: '%s'", reader
->line
);
1300 if (reader
->status
!= PACKET_READ_FLUSH
&&
1301 reader
->status
!= PACKET_READ_DELIM
)
1302 die("error processing acks: %d", reader
->status
);
1304 /* return 0 if no common, 1 if there are common, or 2 if ready */
1305 return received_ready
? 2 : (received_ack
? 1 : 0);
1308 static void receive_shallow_info(struct fetch_pack_args
*args
,
1309 struct packet_reader
*reader
)
1311 process_section_header(reader
, "shallow-info", 0);
1312 while (packet_reader_read(reader
) == PACKET_READ_NORMAL
) {
1314 struct object_id oid
;
1316 if (skip_prefix(reader
->line
, "shallow ", &arg
)) {
1317 if (get_oid_hex(arg
, &oid
))
1318 die(_("invalid shallow line: %s"), reader
->line
);
1319 register_shallow(the_repository
, &oid
);
1322 if (skip_prefix(reader
->line
, "unshallow ", &arg
)) {
1323 if (get_oid_hex(arg
, &oid
))
1324 die(_("invalid unshallow line: %s"), reader
->line
);
1325 if (!lookup_object(oid
.hash
))
1326 die(_("object not found: %s"), reader
->line
);
1327 /* make sure that it is parsed as shallow */
1328 if (!parse_object(&oid
))
1329 die(_("error in object: %s"), reader
->line
);
1330 if (unregister_shallow(&oid
))
1331 die(_("no shallow found: %s"), reader
->line
);
1334 die(_("expected shallow/unshallow, got %s"), reader
->line
);
1337 if (reader
->status
!= PACKET_READ_FLUSH
&&
1338 reader
->status
!= PACKET_READ_DELIM
)
1339 die("error processing shallow info: %d", reader
->status
);
1341 setup_alternate_shallow(&shallow_lock
, &alternate_shallow_file
, NULL
);
1345 static void receive_wanted_refs(struct packet_reader
*reader
, struct ref
*refs
)
1347 process_section_header(reader
, "wanted-refs", 0);
1348 while (packet_reader_read(reader
) == PACKET_READ_NORMAL
) {
1349 struct object_id oid
;
1351 struct ref
*r
= NULL
;
1353 if (parse_oid_hex(reader
->line
, &oid
, &end
) || *end
++ != ' ')
1354 die("expected wanted-ref, got '%s'", reader
->line
);
1356 for (r
= refs
; r
; r
= r
->next
) {
1357 if (!strcmp(end
, r
->name
)) {
1358 oidcpy(&r
->old_oid
, &oid
);
1364 die("unexpected wanted-ref: '%s'", reader
->line
);
1367 if (reader
->status
!= PACKET_READ_DELIM
)
1368 die("error processing wanted refs: %d", reader
->status
);
1372 FETCH_CHECK_LOCAL
= 0,
1379 static struct ref
*do_fetch_pack_v2(struct fetch_pack_args
*args
,
1381 const struct ref
*orig_ref
,
1382 struct ref
**sought
, int nr_sought
,
1383 char **pack_lockfile
)
1385 struct ref
*ref
= copy_ref_list(orig_ref
);
1386 enum fetch_state state
= FETCH_CHECK_LOCAL
;
1387 struct oidset common
= OIDSET_INIT
;
1388 struct packet_reader reader
;
1390 int haves_to_send
= INITIAL_FLUSH
;
1391 packet_reader_init(&reader
, fd
[0], NULL
, 0,
1392 PACKET_READ_CHOMP_NEWLINE
);
1394 while (state
!= FETCH_DONE
) {
1396 case FETCH_CHECK_LOCAL
:
1397 sort_ref_list(&ref
, ref_compare_name
);
1398 QSORT(sought
, nr_sought
, cmp_ref_by_name
);
1400 /* v2 supports these by default */
1401 allow_unadvertised_object_request
|= ALLOW_REACHABLE_SHA1
;
1403 if (args
->depth
> 0 || args
->deepen_since
|| args
->deepen_not
)
1407 for_each_ref(clear_marks
, NULL
);
1410 for_each_ref(rev_list_insert_ref_oid
, NULL
);
1411 for_each_cached_alternate(insert_one_alternate_object
);
1413 /* Filter 'ref' by 'sought' and those that aren't local */
1414 if (everything_local(args
, &ref
, sought
, nr_sought
))
1417 state
= FETCH_SEND_REQUEST
;
1419 case FETCH_SEND_REQUEST
:
1420 if (send_fetch_request(fd
[1], args
, ref
, &common
,
1421 &haves_to_send
, &in_vain
))
1422 state
= FETCH_GET_PACK
;
1424 state
= FETCH_PROCESS_ACKS
;
1426 case FETCH_PROCESS_ACKS
:
1427 /* Process ACKs/NAKs */
1428 switch (process_acks(&reader
, &common
)) {
1430 state
= FETCH_GET_PACK
;
1436 state
= FETCH_SEND_REQUEST
;
1440 case FETCH_GET_PACK
:
1441 /* Check for shallow-info section */
1442 if (process_section_header(&reader
, "shallow-info", 1))
1443 receive_shallow_info(args
, &reader
);
1445 if (process_section_header(&reader
, "wanted-refs", 1))
1446 receive_wanted_refs(&reader
, ref
);
1449 process_section_header(&reader
, "packfile", 0);
1450 if (get_pack(args
, fd
, pack_lockfile
))
1451 die(_("git fetch-pack: fetch failed."));
1460 oidset_clear(&common
);
1464 static int fetch_pack_config_cb(const char *var
, const char *value
, void *cb
)
1466 if (strcmp(var
, "fetch.fsck.skiplist") == 0) {
1469 if (git_config_pathname(&path
, var
, value
))
1471 strbuf_addf(&fsck_msg_types
, "%cskiplist=%s",
1472 fsck_msg_types
.len
? ',' : '=', path
);
1477 if (skip_prefix(var
, "fetch.fsck.", &var
)) {
1478 if (is_valid_msg_type(var
, value
))
1479 strbuf_addf(&fsck_msg_types
, "%c%s=%s",
1480 fsck_msg_types
.len
? ',' : '=', var
, value
);
1482 warning("Skipping unknown msg id '%s'", var
);
1486 return git_default_config(var
, value
, cb
);
1489 static void fetch_pack_config(void)
1491 git_config_get_int("fetch.unpacklimit", &fetch_unpack_limit
);
1492 git_config_get_int("transfer.unpacklimit", &transfer_unpack_limit
);
1493 git_config_get_bool("repack.usedeltabaseoffset", &prefer_ofs_delta
);
1494 git_config_get_bool("fetch.fsckobjects", &fetch_fsck_objects
);
1495 git_config_get_bool("transfer.fsckobjects", &transfer_fsck_objects
);
1497 git_config(fetch_pack_config_cb
, NULL
);
1500 static void fetch_pack_setup(void)
1502 static int did_setup
;
1505 fetch_pack_config();
1506 if (0 <= transfer_unpack_limit
)
1507 unpack_limit
= transfer_unpack_limit
;
1508 else if (0 <= fetch_unpack_limit
)
1509 unpack_limit
= fetch_unpack_limit
;
1513 static int remove_duplicates_in_refs(struct ref
**ref
, int nr
)
1515 struct string_list names
= STRING_LIST_INIT_NODUP
;
1518 for (src
= dst
= 0; src
< nr
; src
++) {
1519 struct string_list_item
*item
;
1520 item
= string_list_insert(&names
, ref
[src
]->name
);
1522 continue; /* already have it */
1523 item
->util
= ref
[src
];
1525 ref
[dst
] = ref
[src
];
1528 for (src
= dst
; src
< nr
; src
++)
1530 string_list_clear(&names
, 0);
1534 static void update_shallow(struct fetch_pack_args
*args
,
1536 struct shallow_info
*si
)
1538 struct oid_array ref
= OID_ARRAY_INIT
;
1543 if (args
->deepen
&& alternate_shallow_file
) {
1544 if (*alternate_shallow_file
== '\0') { /* --unshallow */
1545 unlink_or_warn(git_path_shallow(the_repository
));
1546 rollback_lock_file(&shallow_lock
);
1548 commit_lock_file(&shallow_lock
);
1552 if (!si
->shallow
|| !si
->shallow
->nr
)
1555 if (args
->cloning
) {
1557 * remote is shallow, but this is a clone, there are
1558 * no objects in repo to worry about. Accept any
1559 * shallow points that exist in the pack (iow in repo
1560 * after get_pack() and reprepare_packed_git())
1562 struct oid_array extra
= OID_ARRAY_INIT
;
1563 struct object_id
*oid
= si
->shallow
->oid
;
1564 for (i
= 0; i
< si
->shallow
->nr
; i
++)
1565 if (has_object_file(&oid
[i
]))
1566 oid_array_append(&extra
, &oid
[i
]);
1568 setup_alternate_shallow(&shallow_lock
,
1569 &alternate_shallow_file
,
1571 commit_lock_file(&shallow_lock
);
1573 oid_array_clear(&extra
);
1577 if (!si
->nr_ours
&& !si
->nr_theirs
)
1580 remove_nonexistent_theirs_shallow(si
);
1581 if (!si
->nr_ours
&& !si
->nr_theirs
)
1583 for (r
= refs
; r
; r
= r
->next
)
1584 oid_array_append(&ref
, &r
->old_oid
);
1587 if (args
->update_shallow
) {
1589 * remote is also shallow, .git/shallow may be updated
1590 * so all refs can be accepted. Make sure we only add
1591 * shallow roots that are actually reachable from new
1594 struct oid_array extra
= OID_ARRAY_INIT
;
1595 struct object_id
*oid
= si
->shallow
->oid
;
1596 assign_shallow_commits_to_refs(si
, NULL
, NULL
);
1597 if (!si
->nr_ours
&& !si
->nr_theirs
) {
1598 oid_array_clear(&ref
);
1601 for (i
= 0; i
< si
->nr_ours
; i
++)
1602 oid_array_append(&extra
, &oid
[si
->ours
[i
]]);
1603 for (i
= 0; i
< si
->nr_theirs
; i
++)
1604 oid_array_append(&extra
, &oid
[si
->theirs
[i
]]);
1605 setup_alternate_shallow(&shallow_lock
,
1606 &alternate_shallow_file
,
1608 commit_lock_file(&shallow_lock
);
1609 oid_array_clear(&extra
);
1610 oid_array_clear(&ref
);
1615 * remote is also shallow, check what ref is safe to update
1616 * without updating .git/shallow
1618 status
= xcalloc(ref
.nr
, sizeof(*status
));
1619 assign_shallow_commits_to_refs(si
, NULL
, status
);
1620 if (si
->nr_ours
|| si
->nr_theirs
) {
1621 for (r
= refs
, i
= 0; r
; r
= r
->next
, i
++)
1623 r
->status
= REF_STATUS_REJECT_SHALLOW
;
1626 oid_array_clear(&ref
);
1629 static int iterate_ref_map(void *cb_data
, struct object_id
*oid
)
1631 struct ref
**rm
= cb_data
;
1632 struct ref
*ref
= *rm
;
1635 return -1; /* end of the list */
1637 oidcpy(oid
, &ref
->old_oid
);
1641 struct ref
*fetch_pack(struct fetch_pack_args
*args
,
1642 int fd
[], struct child_process
*conn
,
1643 const struct ref
*ref
,
1645 struct ref
**sought
, int nr_sought
,
1646 struct oid_array
*shallow
,
1647 char **pack_lockfile
,
1648 enum protocol_version version
)
1650 struct ref
*ref_cpy
;
1651 struct shallow_info si
;
1655 nr_sought
= remove_duplicates_in_refs(sought
, nr_sought
);
1658 packet_flush(fd
[1]);
1659 die(_("no matching remote head"));
1661 prepare_shallow_info(&si
, shallow
);
1662 if (version
== protocol_v2
)
1663 ref_cpy
= do_fetch_pack_v2(args
, fd
, ref
, sought
, nr_sought
,
1666 ref_cpy
= do_fetch_pack(args
, fd
, ref
, sought
, nr_sought
,
1667 &si
, pack_lockfile
);
1668 reprepare_packed_git(the_repository
);
1670 if (!args
->cloning
&& args
->deepen
) {
1671 struct check_connected_options opt
= CHECK_CONNECTED_INIT
;
1672 struct ref
*iterator
= ref_cpy
;
1673 opt
.shallow_file
= alternate_shallow_file
;
1675 opt
.is_deepening_fetch
= 1;
1676 if (check_connected(iterate_ref_map
, &iterator
, &opt
)) {
1677 error(_("remote did not send all necessary objects"));
1680 rollback_lock_file(&shallow_lock
);
1683 args
->connectivity_checked
= 1;
1686 update_shallow(args
, ref_cpy
, &si
);
1688 clear_shallow_info(&si
);
1692 int report_unmatched_refs(struct ref
**sought
, int nr_sought
)
1696 for (i
= 0; i
< nr_sought
; i
++) {
1699 switch (sought
[i
]->match_status
) {
1702 case REF_NOT_MATCHED
:
1703 error(_("no such remote ref %s"), sought
[i
]->name
);
1705 case REF_UNADVERTISED_NOT_ALLOWED
:
1706 error(_("Server does not allow request for unadvertised object %s"),