9 #include "fetch-pack.h"
11 #include "run-command.h"
13 #include "transport.h"
16 static int transfer_unpack_limit
= -1;
17 static int fetch_unpack_limit
= -1;
18 static int unpack_limit
= 100;
19 static int prefer_ofs_delta
= 1;
21 static int fetch_fsck_objects
= -1;
22 static int transfer_fsck_objects
= -1;
23 static int agent_supported
;
24 static struct lock_file shallow_lock
;
25 static const char *alternate_shallow_file
;
27 #define COMPLETE (1U << 0)
28 #define COMMON (1U << 1)
29 #define COMMON_REF (1U << 2)
30 #define SEEN (1U << 3)
31 #define POPPED (1U << 4)
36 * After sending this many "have"s if we do not get any new ACK , we
37 * give up traversing our history.
39 #define MAX_IN_VAIN 256
41 static struct commit_list
*rev_list
;
42 static int non_common_revs
, multi_ack
, use_sideband
, allow_tip_sha1_in_want
;
44 static void rev_list_push(struct commit
*commit
, int mark
)
46 if (!(commit
->object
.flags
& mark
)) {
47 commit
->object
.flags
|= mark
;
49 if (!(commit
->object
.parsed
))
50 if (parse_commit(commit
))
53 commit_list_insert_by_date(commit
, &rev_list
);
55 if (!(commit
->object
.flags
& COMMON
))
60 static int rev_list_insert_ref(const char *refname
, const unsigned char *sha1
, int flag
, void *cb_data
)
62 struct object
*o
= deref_tag(parse_object(sha1
), refname
, 0);
64 if (o
&& o
->type
== OBJ_COMMIT
)
65 rev_list_push((struct commit
*)o
, SEEN
);
70 static int clear_marks(const char *refname
, const unsigned char *sha1
, int flag
, void *cb_data
)
72 struct object
*o
= deref_tag(parse_object(sha1
), refname
, 0);
74 if (o
&& o
->type
== OBJ_COMMIT
)
75 clear_commit_marks((struct commit
*)o
,
76 COMMON
| COMMON_REF
| SEEN
| POPPED
);
81 This function marks a rev and its ancestors as common.
82 In some cases, it is desirable to mark only the ancestors (for example
83 when only the server does not yet know that they are common).
86 static void mark_common(struct commit
*commit
,
87 int ancestors_only
, int dont_parse
)
89 if (commit
!= NULL
&& !(commit
->object
.flags
& COMMON
)) {
90 struct object
*o
= (struct object
*)commit
;
95 if (!(o
->flags
& SEEN
))
96 rev_list_push(commit
, SEEN
);
98 struct commit_list
*parents
;
100 if (!ancestors_only
&& !(o
->flags
& POPPED
))
102 if (!o
->parsed
&& !dont_parse
)
103 if (parse_commit(commit
))
106 for (parents
= commit
->parents
;
108 parents
= parents
->next
)
109 mark_common(parents
->item
, 0, dont_parse
);
115 Get the next rev to send, ignoring the common.
118 static const unsigned char *get_rev(void)
120 struct commit
*commit
= NULL
;
122 while (commit
== NULL
) {
124 struct commit_list
*parents
;
126 if (rev_list
== NULL
|| non_common_revs
== 0)
129 commit
= rev_list
->item
;
130 if (!commit
->object
.parsed
)
131 parse_commit(commit
);
132 parents
= commit
->parents
;
134 commit
->object
.flags
|= POPPED
;
135 if (!(commit
->object
.flags
& COMMON
))
138 if (commit
->object
.flags
& COMMON
) {
139 /* do not send "have", and ignore ancestors */
141 mark
= COMMON
| SEEN
;
142 } else if (commit
->object
.flags
& COMMON_REF
)
143 /* send "have", and ignore ancestors */
144 mark
= COMMON
| SEEN
;
146 /* send "have", also for its ancestors */
150 if (!(parents
->item
->object
.flags
& SEEN
))
151 rev_list_push(parents
->item
, mark
);
153 mark_common(parents
->item
, 1, 0);
154 parents
= parents
->next
;
157 rev_list
= rev_list
->next
;
160 return commit
->object
.sha1
;
171 static void consume_shallow_list(struct fetch_pack_args
*args
, int fd
)
173 if (args
->stateless_rpc
&& args
->depth
> 0) {
174 /* If we sent a depth we will get back "duplicate"
175 * shallow and unshallow commands every time there
176 * is a block of have lines exchanged.
179 while ((line
= packet_read_line(fd
, NULL
))) {
180 if (!prefixcmp(line
, "shallow "))
182 if (!prefixcmp(line
, "unshallow "))
184 die("git fetch-pack: expected shallow list");
189 struct write_shallow_data
{
191 int use_pack_protocol
;
195 static int write_one_shallow(const struct commit_graft
*graft
, void *cb_data
)
197 struct write_shallow_data
*data
= cb_data
;
198 const char *hex
= sha1_to_hex(graft
->sha1
);
200 if (data
->use_pack_protocol
)
201 packet_buf_write(data
->out
, "shallow %s", hex
);
203 strbuf_addstr(data
->out
, hex
);
204 strbuf_addch(data
->out
, '\n');
209 static int write_shallow_commits(struct strbuf
*out
, int use_pack_protocol
)
211 struct write_shallow_data data
;
213 data
.use_pack_protocol
= use_pack_protocol
;
215 for_each_commit_graft(write_one_shallow
, &data
);
219 static enum ack_type
get_ack(int fd
, unsigned char *result_sha1
)
222 char *line
= packet_read_line(fd
, &len
);
225 die("git fetch-pack: expected ACK/NAK, got EOF");
226 if (!strcmp(line
, "NAK"))
228 if (!prefixcmp(line
, "ACK ")) {
229 if (!get_sha1_hex(line
+4, result_sha1
)) {
232 if (strstr(line
+45, "continue"))
234 if (strstr(line
+45, "common"))
236 if (strstr(line
+45, "ready"))
241 die("git fetch_pack: expected ACK/NAK, got '%s'", line
);
244 static void send_request(struct fetch_pack_args
*args
,
245 int fd
, struct strbuf
*buf
)
247 if (args
->stateless_rpc
) {
248 send_sideband(fd
, -1, buf
->buf
, buf
->len
, LARGE_PACKET_MAX
);
251 write_or_die(fd
, buf
->buf
, buf
->len
);
254 static void insert_one_alternate_ref(const struct ref
*ref
, void *unused
)
256 rev_list_insert_ref(NULL
, ref
->old_sha1
, 0, NULL
);
259 #define INITIAL_FLUSH 16
260 #define PIPESAFE_FLUSH 32
261 #define LARGE_FLUSH 1024
263 static int next_flush(struct fetch_pack_args
*args
, int count
)
265 int flush_limit
= args
->stateless_rpc
? LARGE_FLUSH
: PIPESAFE_FLUSH
;
267 if (count
< flush_limit
)
270 count
+= flush_limit
;
274 static int find_common(struct fetch_pack_args
*args
,
275 int fd
[2], unsigned char *result_sha1
,
279 int count
= 0, flushes
= 0, flush_at
= INITIAL_FLUSH
, retval
;
280 const unsigned char *sha1
;
281 unsigned in_vain
= 0;
282 int got_continue
= 0;
284 struct strbuf req_buf
= STRBUF_INIT
;
285 size_t state_len
= 0;
287 if (args
->stateless_rpc
&& multi_ack
== 1)
288 die("--stateless-rpc requires multi_ack_detailed");
290 for_each_ref(clear_marks
, NULL
);
293 for_each_ref(rev_list_insert_ref
, NULL
);
294 for_each_alternate_ref(insert_one_alternate_ref
, NULL
);
297 for ( ; refs
; refs
= refs
->next
) {
298 unsigned char *remote
= refs
->old_sha1
;
299 const char *remote_hex
;
303 * If that object is complete (i.e. it is an ancestor of a
304 * local ref), we tell them we have it but do not have to
305 * tell them about its ancestors, which they already know
308 * We use lookup_object here because we are only
309 * interested in the case we *know* the object is
310 * reachable and we have already scanned it.
312 if (((o
= lookup_object(remote
)) != NULL
) &&
313 (o
->flags
& COMPLETE
)) {
317 remote_hex
= sha1_to_hex(remote
);
319 struct strbuf c
= STRBUF_INIT
;
320 if (multi_ack
== 2) strbuf_addstr(&c
, " multi_ack_detailed");
321 if (multi_ack
== 1) strbuf_addstr(&c
, " multi_ack");
322 if (no_done
) strbuf_addstr(&c
, " no-done");
323 if (use_sideband
== 2) strbuf_addstr(&c
, " side-band-64k");
324 if (use_sideband
== 1) strbuf_addstr(&c
, " side-band");
325 if (args
->use_thin_pack
) strbuf_addstr(&c
, " thin-pack");
326 if (args
->no_progress
) strbuf_addstr(&c
, " no-progress");
327 if (args
->include_tag
) strbuf_addstr(&c
, " include-tag");
328 if (prefer_ofs_delta
) strbuf_addstr(&c
, " ofs-delta");
329 if (agent_supported
) strbuf_addf(&c
, " agent=%s",
330 git_user_agent_sanitized());
331 packet_buf_write(&req_buf
, "want %s%s\n", remote_hex
, c
.buf
);
334 packet_buf_write(&req_buf
, "want %s\n", remote_hex
);
339 strbuf_release(&req_buf
);
344 if (is_repository_shallow())
345 write_shallow_commits(&req_buf
, 1);
347 packet_buf_write(&req_buf
, "deepen %d", args
->depth
);
348 packet_buf_flush(&req_buf
);
349 state_len
= req_buf
.len
;
351 if (args
->depth
> 0) {
353 unsigned char sha1
[20];
355 send_request(args
, fd
[1], &req_buf
);
356 while ((line
= packet_read_line(fd
[0], NULL
))) {
357 if (!prefixcmp(line
, "shallow ")) {
358 if (get_sha1_hex(line
+ 8, sha1
))
359 die("invalid shallow line: %s", line
);
360 register_shallow(sha1
);
363 if (!prefixcmp(line
, "unshallow ")) {
364 if (get_sha1_hex(line
+ 10, sha1
))
365 die("invalid unshallow line: %s", line
);
366 if (!lookup_object(sha1
))
367 die("object not found: %s", line
);
368 /* make sure that it is parsed as shallow */
369 if (!parse_object(sha1
))
370 die("error in object: %s", line
);
371 if (unregister_shallow(sha1
))
372 die("no shallow found: %s", line
);
375 die("expected shallow/unshallow, got %s", line
);
377 } else if (!args
->stateless_rpc
)
378 send_request(args
, fd
[1], &req_buf
);
380 if (!args
->stateless_rpc
) {
381 /* If we aren't using the stateless-rpc interface
382 * we don't need to retain the headers.
384 strbuf_setlen(&req_buf
, 0);
390 while ((sha1
= get_rev())) {
391 packet_buf_write(&req_buf
, "have %s\n", sha1_to_hex(sha1
));
393 fprintf(stderr
, "have %s\n", sha1_to_hex(sha1
));
395 if (flush_at
<= ++count
) {
398 packet_buf_flush(&req_buf
);
399 send_request(args
, fd
[1], &req_buf
);
400 strbuf_setlen(&req_buf
, state_len
);
402 flush_at
= next_flush(args
, count
);
405 * We keep one window "ahead" of the other side, and
406 * will wait for an ACK only on the next one
408 if (!args
->stateless_rpc
&& count
== INITIAL_FLUSH
)
411 consume_shallow_list(args
, fd
[0]);
413 ack
= get_ack(fd
[0], result_sha1
);
414 if (args
->verbose
&& ack
)
415 fprintf(stderr
, "got ack %d %s\n", ack
,
416 sha1_to_hex(result_sha1
));
426 struct commit
*commit
=
427 lookup_commit(result_sha1
);
429 die("invalid commit %s", sha1_to_hex(result_sha1
));
430 if (args
->stateless_rpc
432 && !(commit
->object
.flags
& COMMON
)) {
433 /* We need to replay the have for this object
434 * on the next RPC request so the peer knows
435 * it is in common with us.
437 const char *hex
= sha1_to_hex(result_sha1
);
438 packet_buf_write(&req_buf
, "have %s\n", hex
);
439 state_len
= req_buf
.len
;
441 mark_common(commit
, 0, 1);
445 if (ack
== ACK_ready
) {
454 if (got_continue
&& MAX_IN_VAIN
< in_vain
) {
456 fprintf(stderr
, "giving up\n");
462 if (!got_ready
|| !no_done
) {
463 packet_buf_write(&req_buf
, "done\n");
464 send_request(args
, fd
[1], &req_buf
);
467 fprintf(stderr
, "done\n");
472 strbuf_release(&req_buf
);
474 consume_shallow_list(args
, fd
[0]);
475 while (flushes
|| multi_ack
) {
476 int ack
= get_ack(fd
[0], result_sha1
);
479 fprintf(stderr
, "got ack (%d) %s\n", ack
,
480 sha1_to_hex(result_sha1
));
488 /* it is no error to fetch into a completely empty repo */
489 return count
? retval
: 0;
492 static struct commit_list
*complete
;
494 static int mark_complete(const char *refname
, const unsigned char *sha1
, int flag
, void *cb_data
)
496 struct object
*o
= parse_object(sha1
);
498 while (o
&& o
->type
== OBJ_TAG
) {
499 struct tag
*t
= (struct tag
*) o
;
501 break; /* broken repository */
502 o
->flags
|= COMPLETE
;
503 o
= parse_object(t
->tagged
->sha1
);
505 if (o
&& o
->type
== OBJ_COMMIT
) {
506 struct commit
*commit
= (struct commit
*)o
;
507 if (!(commit
->object
.flags
& COMPLETE
)) {
508 commit
->object
.flags
|= COMPLETE
;
509 commit_list_insert_by_date(commit
, &complete
);
515 static void mark_recent_complete_commits(struct fetch_pack_args
*args
,
516 unsigned long cutoff
)
518 while (complete
&& cutoff
<= complete
->item
->date
) {
520 fprintf(stderr
, "Marking %s as complete\n",
521 sha1_to_hex(complete
->item
->object
.sha1
));
522 pop_most_recent_commit(&complete
, COMPLETE
);
526 static void filter_refs(struct fetch_pack_args
*args
,
528 struct ref
**sought
, int nr_sought
)
530 struct ref
*newlist
= NULL
;
531 struct ref
**newtail
= &newlist
;
532 struct ref
*ref
, *next
;
536 for (ref
= *refs
; ref
; ref
= next
) {
540 if (!memcmp(ref
->name
, "refs/", 5) &&
541 check_refname_format(ref
->name
+ 5, 0))
544 while (i
< nr_sought
) {
545 int cmp
= strcmp(ref
->name
, sought
[i
]->name
);
547 break; /* definitely do not have it */
549 keep
= 1; /* definitely have it */
550 sought
[i
]->matched
= 1;
556 if (!keep
&& args
->fetch_all
&&
557 (!args
->depth
|| prefixcmp(ref
->name
, "refs/tags/")))
563 newtail
= &ref
->next
;
569 /* Append unmatched requests to the list */
570 if (allow_tip_sha1_in_want
) {
571 for (i
= 0; i
< nr_sought
; i
++) {
575 if (get_sha1_hex(ref
->name
, ref
->old_sha1
))
581 newtail
= &ref
->next
;
587 static void mark_alternate_complete(const struct ref
*ref
, void *unused
)
589 mark_complete(NULL
, ref
->old_sha1
, 0, NULL
);
592 static int everything_local(struct fetch_pack_args
*args
,
594 struct ref
**sought
, int nr_sought
)
598 unsigned long cutoff
= 0;
600 save_commit_buffer
= 0;
602 for (ref
= *refs
; ref
; ref
= ref
->next
) {
605 if (!has_sha1_file(ref
->old_sha1
))
608 o
= parse_object(ref
->old_sha1
);
612 /* We already have it -- which may mean that we were
613 * in sync with the other side at some time after
614 * that (it is OK if we guess wrong here).
616 if (o
->type
== OBJ_COMMIT
) {
617 struct commit
*commit
= (struct commit
*)o
;
618 if (!cutoff
|| cutoff
< commit
->date
)
619 cutoff
= commit
->date
;
624 for_each_ref(mark_complete
, NULL
);
625 for_each_alternate_ref(mark_alternate_complete
, NULL
);
627 mark_recent_complete_commits(args
, cutoff
);
631 * Mark all complete remote refs as common refs.
632 * Don't mark them common yet; the server has to be told so first.
634 for (ref
= *refs
; ref
; ref
= ref
->next
) {
635 struct object
*o
= deref_tag(lookup_object(ref
->old_sha1
),
638 if (!o
|| o
->type
!= OBJ_COMMIT
|| !(o
->flags
& COMPLETE
))
641 if (!(o
->flags
& SEEN
)) {
642 rev_list_push((struct commit
*)o
, COMMON_REF
| SEEN
);
644 mark_common((struct commit
*)o
, 1, 1);
648 filter_refs(args
, refs
, sought
, nr_sought
);
650 for (retval
= 1, ref
= *refs
; ref
; ref
= ref
->next
) {
651 const unsigned char *remote
= ref
->old_sha1
;
652 unsigned char local
[20];
655 o
= lookup_object(remote
);
656 if (!o
|| !(o
->flags
& COMPLETE
)) {
661 "want %s (%s)\n", sha1_to_hex(remote
),
666 hashcpy(ref
->new_sha1
, local
);
670 "already have %s (%s)\n", sha1_to_hex(remote
),
676 static int sideband_demux(int in
, int out
, void *data
)
680 int ret
= recv_sideband("fetch-pack", xd
[0], out
);
685 static int get_pack(struct fetch_pack_args
*args
,
686 int xd
[2], char **pack_lockfile
)
689 const char *argv
[22];
693 int do_keep
= args
->keep_pack
;
694 struct child_process cmd
;
697 memset(&demux
, 0, sizeof(demux
));
699 /* xd[] is talking with upload-pack; subprocess reads from
700 * xd[0], spits out band#2 to stderr, and feeds us band#1
701 * through demux->out.
703 demux
.proc
= sideband_demux
;
706 if (start_async(&demux
))
707 die("fetch-pack: unable to fork off sideband"
713 memset(&cmd
, 0, sizeof(cmd
));
717 if (!args
->keep_pack
&& unpack_limit
) {
718 struct pack_header header
;
720 if (read_pack_header(demux
.out
, &header
))
721 die("protocol error: bad pack header");
722 snprintf(hdr_arg
, sizeof(hdr_arg
),
723 "--pack_header=%"PRIu32
",%"PRIu32
,
724 ntohl(header
.hdr_version
), ntohl(header
.hdr_entries
));
725 if (ntohl(header
.hdr_entries
) < unpack_limit
)
731 if (alternate_shallow_file
) {
732 *av
++ = "--shallow-file";
733 *av
++ = alternate_shallow_file
;
739 *av
++ = "index-pack";
741 if (!args
->quiet
&& !args
->no_progress
)
743 if (args
->use_thin_pack
)
744 *av
++ = "--fix-thin";
745 if (args
->lock_pack
|| unpack_limit
) {
746 int s
= sprintf(keep_arg
,
747 "--keep=fetch-pack %"PRIuMAX
" on ", (uintmax_t) getpid());
748 if (gethostname(keep_arg
+ s
, sizeof(keep_arg
) - s
))
749 strcpy(keep_arg
+ s
, "localhost");
752 if (args
->check_self_contained_and_connected
)
753 *av
++ = "--check-self-contained-and-connected";
756 *av
++ = "unpack-objects";
757 if (args
->quiet
|| args
->no_progress
)
759 args
->check_self_contained_and_connected
= 0;
763 if (fetch_fsck_objects
>= 0
765 : transfer_fsck_objects
>= 0
766 ? transfer_fsck_objects
773 if (start_command(&cmd
))
774 die("fetch-pack: unable to fork off %s", argv
[0]);
775 if (do_keep
&& pack_lockfile
) {
776 *pack_lockfile
= index_pack_lockfile(cmd
.out
);
780 ret
= finish_command(&cmd
);
781 if (!ret
|| (args
->check_self_contained_and_connected
&& ret
== 1))
782 args
->self_contained_and_connected
=
783 args
->check_self_contained_and_connected
&&
786 die("%s failed", argv
[0]);
787 if (use_sideband
&& finish_async(&demux
))
788 die("error in sideband demultiplexer");
792 static int cmp_ref_by_name(const void *a_
, const void *b_
)
794 const struct ref
*a
= *((const struct ref
**)a_
);
795 const struct ref
*b
= *((const struct ref
**)b_
);
796 return strcmp(a
->name
, b
->name
);
799 static void setup_alternate_shallow(void)
801 struct strbuf sb
= STRBUF_INIT
;
804 check_shallow_file_for_update();
805 fd
= hold_lock_file_for_update(&shallow_lock
, git_path("shallow"),
807 if (write_shallow_commits(&sb
, 0)) {
808 if (write_in_full(fd
, sb
.buf
, sb
.len
) != sb
.len
)
809 die_errno("failed to write to %s", shallow_lock
.filename
);
810 alternate_shallow_file
= shallow_lock
.filename
;
813 * is_repository_shallow() sees empty string as "no
816 alternate_shallow_file
= "";
820 static struct ref
*do_fetch_pack(struct fetch_pack_args
*args
,
822 const struct ref
*orig_ref
,
823 struct ref
**sought
, int nr_sought
,
824 char **pack_lockfile
)
826 struct ref
*ref
= copy_ref_list(orig_ref
);
827 unsigned char sha1
[20];
828 const char *agent_feature
;
831 sort_ref_list(&ref
, ref_compare_name
);
832 qsort(sought
, nr_sought
, sizeof(*sought
), cmp_ref_by_name
);
834 if (is_repository_shallow() && !server_supports("shallow"))
835 die("Server does not support shallow clients");
836 if (server_supports("multi_ack_detailed")) {
838 fprintf(stderr
, "Server supports multi_ack_detailed\n");
840 if (server_supports("no-done")) {
842 fprintf(stderr
, "Server supports no-done\n");
843 if (args
->stateless_rpc
)
847 else if (server_supports("multi_ack")) {
849 fprintf(stderr
, "Server supports multi_ack\n");
852 if (server_supports("side-band-64k")) {
854 fprintf(stderr
, "Server supports side-band-64k\n");
857 else if (server_supports("side-band")) {
859 fprintf(stderr
, "Server supports side-band\n");
862 if (server_supports("allow-tip-sha1-in-want")) {
864 fprintf(stderr
, "Server supports allow-tip-sha1-in-want\n");
865 allow_tip_sha1_in_want
= 1;
867 if (!server_supports("thin-pack"))
868 args
->use_thin_pack
= 0;
869 if (!server_supports("no-progress"))
870 args
->no_progress
= 0;
871 if (!server_supports("include-tag"))
872 args
->include_tag
= 0;
873 if (server_supports("ofs-delta")) {
875 fprintf(stderr
, "Server supports ofs-delta\n");
877 prefer_ofs_delta
= 0;
879 if ((agent_feature
= server_feature_value("agent", &agent_len
))) {
881 if (args
->verbose
&& agent_len
)
882 fprintf(stderr
, "Server version is %.*s\n",
883 agent_len
, agent_feature
);
886 if (everything_local(args
, &ref
, sought
, nr_sought
)) {
890 if (find_common(args
, fd
, sha1
, ref
) < 0)
891 if (!args
->keep_pack
)
892 /* When cloning, it is not unusual to have
895 warning("no common commits");
897 if (args
->stateless_rpc
)
900 setup_alternate_shallow();
901 if (get_pack(args
, fd
, pack_lockfile
))
902 die("git fetch-pack: fetch failed.");
908 static int fetch_pack_config(const char *var
, const char *value
, void *cb
)
910 if (strcmp(var
, "fetch.unpacklimit") == 0) {
911 fetch_unpack_limit
= git_config_int(var
, value
);
915 if (strcmp(var
, "transfer.unpacklimit") == 0) {
916 transfer_unpack_limit
= git_config_int(var
, value
);
920 if (strcmp(var
, "repack.usedeltabaseoffset") == 0) {
921 prefer_ofs_delta
= git_config_bool(var
, value
);
925 if (!strcmp(var
, "fetch.fsckobjects")) {
926 fetch_fsck_objects
= git_config_bool(var
, value
);
930 if (!strcmp(var
, "transfer.fsckobjects")) {
931 transfer_fsck_objects
= git_config_bool(var
, value
);
935 return git_default_config(var
, value
, cb
);
938 static void fetch_pack_setup(void)
940 static int did_setup
;
943 git_config(fetch_pack_config
, NULL
);
944 if (0 <= transfer_unpack_limit
)
945 unpack_limit
= transfer_unpack_limit
;
946 else if (0 <= fetch_unpack_limit
)
947 unpack_limit
= fetch_unpack_limit
;
951 static int remove_duplicates_in_refs(struct ref
**ref
, int nr
)
953 struct string_list names
= STRING_LIST_INIT_NODUP
;
956 for (src
= dst
= 0; src
< nr
; src
++) {
957 struct string_list_item
*item
;
958 item
= string_list_insert(&names
, ref
[src
]->name
);
960 continue; /* already have it */
961 item
->util
= ref
[src
];
966 for (src
= dst
; src
< nr
; src
++)
968 string_list_clear(&names
, 0);
972 struct ref
*fetch_pack(struct fetch_pack_args
*args
,
973 int fd
[], struct child_process
*conn
,
974 const struct ref
*ref
,
976 struct ref
**sought
, int nr_sought
,
977 char **pack_lockfile
)
983 nr_sought
= remove_duplicates_in_refs(sought
, nr_sought
);
987 die("no matching remote head");
989 ref_cpy
= do_fetch_pack(args
, fd
, ref
, sought
, nr_sought
, pack_lockfile
);
991 if (alternate_shallow_file
) {
992 if (*alternate_shallow_file
== '\0') { /* --unshallow */
993 unlink_or_warn(git_path("shallow"));
994 rollback_lock_file(&shallow_lock
);
996 commit_lock_file(&shallow_lock
);
999 reprepare_packed_git();