9 #include "fetch-pack.h"
11 #include "run-command.h"
12 #include "transport.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;
20 static int fetch_fsck_objects
= -1;
21 static int transfer_fsck_objects
= -1;
22 static int agent_supported
;
23 static struct lock_file shallow_lock
;
24 static const char *alternate_shallow_file
;
26 #define COMPLETE (1U << 0)
27 #define COMMON (1U << 1)
28 #define COMMON_REF (1U << 2)
29 #define SEEN (1U << 3)
30 #define POPPED (1U << 4)
35 * After sending this many "have"s if we do not get any new ACK , we
36 * give up traversing our history.
38 #define MAX_IN_VAIN 256
40 static struct commit_list
*rev_list
;
41 static int non_common_revs
, multi_ack
, use_sideband
, allow_tip_sha1_in_want
;
43 static void rev_list_push(struct commit
*commit
, int mark
)
45 if (!(commit
->object
.flags
& mark
)) {
46 commit
->object
.flags
|= mark
;
48 if (!(commit
->object
.parsed
))
49 if (parse_commit(commit
))
52 commit_list_insert_by_date(commit
, &rev_list
);
54 if (!(commit
->object
.flags
& COMMON
))
59 static int rev_list_insert_ref(const char *refname
, const unsigned char *sha1
, int flag
, void *cb_data
)
61 struct object
*o
= deref_tag(parse_object(sha1
), refname
, 0);
63 if (o
&& o
->type
== OBJ_COMMIT
)
64 rev_list_push((struct commit
*)o
, SEEN
);
69 static int clear_marks(const char *refname
, const unsigned char *sha1
, int flag
, void *cb_data
)
71 struct object
*o
= deref_tag(parse_object(sha1
), refname
, 0);
73 if (o
&& o
->type
== OBJ_COMMIT
)
74 clear_commit_marks((struct commit
*)o
,
75 COMMON
| COMMON_REF
| SEEN
| POPPED
);
80 This function marks a rev and its ancestors as common.
81 In some cases, it is desirable to mark only the ancestors (for example
82 when only the server does not yet know that they are common).
85 static void mark_common(struct commit
*commit
,
86 int ancestors_only
, int dont_parse
)
88 if (commit
!= NULL
&& !(commit
->object
.flags
& COMMON
)) {
89 struct object
*o
= (struct object
*)commit
;
94 if (!(o
->flags
& SEEN
))
95 rev_list_push(commit
, SEEN
);
97 struct commit_list
*parents
;
99 if (!ancestors_only
&& !(o
->flags
& POPPED
))
101 if (!o
->parsed
&& !dont_parse
)
102 if (parse_commit(commit
))
105 for (parents
= commit
->parents
;
107 parents
= parents
->next
)
108 mark_common(parents
->item
, 0, dont_parse
);
114 Get the next rev to send, ignoring the common.
117 static const unsigned char *get_rev(void)
119 struct commit
*commit
= NULL
;
121 while (commit
== NULL
) {
123 struct commit_list
*parents
;
125 if (rev_list
== NULL
|| non_common_revs
== 0)
128 commit
= rev_list
->item
;
129 if (!commit
->object
.parsed
)
130 parse_commit(commit
);
131 parents
= commit
->parents
;
133 commit
->object
.flags
|= POPPED
;
134 if (!(commit
->object
.flags
& COMMON
))
137 if (commit
->object
.flags
& COMMON
) {
138 /* do not send "have", and ignore ancestors */
140 mark
= COMMON
| SEEN
;
141 } else if (commit
->object
.flags
& COMMON_REF
)
142 /* send "have", and ignore ancestors */
143 mark
= COMMON
| SEEN
;
145 /* send "have", also for its ancestors */
149 if (!(parents
->item
->object
.flags
& SEEN
))
150 rev_list_push(parents
->item
, mark
);
152 mark_common(parents
->item
, 1, 0);
153 parents
= parents
->next
;
156 rev_list
= rev_list
->next
;
159 return commit
->object
.sha1
;
170 static void consume_shallow_list(struct fetch_pack_args
*args
, int fd
)
172 if (args
->stateless_rpc
&& args
->depth
> 0) {
173 /* If we sent a depth we will get back "duplicate"
174 * shallow and unshallow commands every time there
175 * is a block of have lines exchanged.
178 while ((line
= packet_read_line(fd
, NULL
))) {
179 if (!prefixcmp(line
, "shallow "))
181 if (!prefixcmp(line
, "unshallow "))
183 die("git fetch-pack: expected shallow list");
188 struct write_shallow_data
{
190 int use_pack_protocol
;
194 static int write_one_shallow(const struct commit_graft
*graft
, void *cb_data
)
196 struct write_shallow_data
*data
= cb_data
;
197 const char *hex
= sha1_to_hex(graft
->sha1
);
199 if (data
->use_pack_protocol
)
200 packet_buf_write(data
->out
, "shallow %s", hex
);
202 strbuf_addstr(data
->out
, hex
);
203 strbuf_addch(data
->out
, '\n');
208 static int write_shallow_commits(struct strbuf
*out
, int use_pack_protocol
)
210 struct write_shallow_data data
;
212 data
.use_pack_protocol
= use_pack_protocol
;
214 for_each_commit_graft(write_one_shallow
, &data
);
218 static enum ack_type
get_ack(int fd
, unsigned char *result_sha1
)
221 char *line
= packet_read_line(fd
, &len
);
224 die("git fetch-pack: expected ACK/NAK, got EOF");
225 if (!strcmp(line
, "NAK"))
227 if (!prefixcmp(line
, "ACK ")) {
228 if (!get_sha1_hex(line
+4, result_sha1
)) {
231 if (strstr(line
+45, "continue"))
233 if (strstr(line
+45, "common"))
235 if (strstr(line
+45, "ready"))
240 die("git fetch_pack: expected ACK/NAK, got '%s'", line
);
243 static void send_request(struct fetch_pack_args
*args
,
244 int fd
, struct strbuf
*buf
)
246 if (args
->stateless_rpc
) {
247 send_sideband(fd
, -1, buf
->buf
, buf
->len
, LARGE_PACKET_MAX
);
250 write_or_die(fd
, buf
->buf
, buf
->len
);
253 static void insert_one_alternate_ref(const struct ref
*ref
, void *unused
)
255 rev_list_insert_ref(NULL
, ref
->old_sha1
, 0, NULL
);
258 #define INITIAL_FLUSH 16
259 #define PIPESAFE_FLUSH 32
260 #define LARGE_FLUSH 1024
262 static int next_flush(struct fetch_pack_args
*args
, int count
)
264 int flush_limit
= args
->stateless_rpc
? LARGE_FLUSH
: PIPESAFE_FLUSH
;
266 if (count
< flush_limit
)
269 count
+= flush_limit
;
273 static int find_common(struct fetch_pack_args
*args
,
274 int fd
[2], unsigned char *result_sha1
,
278 int count
= 0, flushes
= 0, flush_at
= INITIAL_FLUSH
, retval
;
279 const unsigned char *sha1
;
280 unsigned in_vain
= 0;
281 int got_continue
= 0;
283 struct strbuf req_buf
= STRBUF_INIT
;
284 size_t state_len
= 0;
286 if (args
->stateless_rpc
&& multi_ack
== 1)
287 die("--stateless-rpc requires multi_ack_detailed");
289 for_each_ref(clear_marks
, NULL
);
292 for_each_ref(rev_list_insert_ref
, NULL
);
293 for_each_alternate_ref(insert_one_alternate_ref
, NULL
);
296 for ( ; refs
; refs
= refs
->next
) {
297 unsigned char *remote
= refs
->old_sha1
;
298 const char *remote_hex
;
302 * If that object is complete (i.e. it is an ancestor of a
303 * local ref), we tell them we have it but do not have to
304 * tell them about its ancestors, which they already know
307 * We use lookup_object here because we are only
308 * interested in the case we *know* the object is
309 * reachable and we have already scanned it.
311 if (((o
= lookup_object(remote
)) != NULL
) &&
312 (o
->flags
& COMPLETE
)) {
316 remote_hex
= sha1_to_hex(remote
);
318 struct strbuf c
= STRBUF_INIT
;
319 if (multi_ack
== 2) strbuf_addstr(&c
, " multi_ack_detailed");
320 if (multi_ack
== 1) strbuf_addstr(&c
, " multi_ack");
321 if (no_done
) strbuf_addstr(&c
, " no-done");
322 if (use_sideband
== 2) strbuf_addstr(&c
, " side-band-64k");
323 if (use_sideband
== 1) strbuf_addstr(&c
, " side-band");
324 if (args
->use_thin_pack
) strbuf_addstr(&c
, " thin-pack");
325 if (args
->no_progress
) strbuf_addstr(&c
, " no-progress");
326 if (args
->include_tag
) strbuf_addstr(&c
, " include-tag");
327 if (prefer_ofs_delta
) strbuf_addstr(&c
, " ofs-delta");
328 if (agent_supported
) strbuf_addf(&c
, " agent=%s",
329 git_user_agent_sanitized());
330 packet_buf_write(&req_buf
, "want %s%s\n", remote_hex
, c
.buf
);
333 packet_buf_write(&req_buf
, "want %s\n", remote_hex
);
338 strbuf_release(&req_buf
);
343 if (is_repository_shallow())
344 write_shallow_commits(&req_buf
, 1);
346 packet_buf_write(&req_buf
, "deepen %d", args
->depth
);
347 packet_buf_flush(&req_buf
);
348 state_len
= req_buf
.len
;
350 if (args
->depth
> 0) {
352 unsigned char sha1
[20];
354 send_request(args
, fd
[1], &req_buf
);
355 while ((line
= packet_read_line(fd
[0], NULL
))) {
356 if (!prefixcmp(line
, "shallow ")) {
357 if (get_sha1_hex(line
+ 8, sha1
))
358 die("invalid shallow line: %s", line
);
359 register_shallow(sha1
);
362 if (!prefixcmp(line
, "unshallow ")) {
363 if (get_sha1_hex(line
+ 10, sha1
))
364 die("invalid unshallow line: %s", line
);
365 if (!lookup_object(sha1
))
366 die("object not found: %s", line
);
367 /* make sure that it is parsed as shallow */
368 if (!parse_object(sha1
))
369 die("error in object: %s", line
);
370 if (unregister_shallow(sha1
))
371 die("no shallow found: %s", line
);
374 die("expected shallow/unshallow, got %s", line
);
376 } else if (!args
->stateless_rpc
)
377 send_request(args
, fd
[1], &req_buf
);
379 if (!args
->stateless_rpc
) {
380 /* If we aren't using the stateless-rpc interface
381 * we don't need to retain the headers.
383 strbuf_setlen(&req_buf
, 0);
389 while ((sha1
= get_rev())) {
390 packet_buf_write(&req_buf
, "have %s\n", sha1_to_hex(sha1
));
392 fprintf(stderr
, "have %s\n", sha1_to_hex(sha1
));
394 if (flush_at
<= ++count
) {
397 packet_buf_flush(&req_buf
);
398 send_request(args
, fd
[1], &req_buf
);
399 strbuf_setlen(&req_buf
, state_len
);
401 flush_at
= next_flush(args
, count
);
404 * We keep one window "ahead" of the other side, and
405 * will wait for an ACK only on the next one
407 if (!args
->stateless_rpc
&& count
== INITIAL_FLUSH
)
410 consume_shallow_list(args
, fd
[0]);
412 ack
= get_ack(fd
[0], result_sha1
);
413 if (args
->verbose
&& ack
)
414 fprintf(stderr
, "got ack %d %s\n", ack
,
415 sha1_to_hex(result_sha1
));
425 struct commit
*commit
=
426 lookup_commit(result_sha1
);
428 die("invalid commit %s", sha1_to_hex(result_sha1
));
429 if (args
->stateless_rpc
431 && !(commit
->object
.flags
& COMMON
)) {
432 /* We need to replay the have for this object
433 * on the next RPC request so the peer knows
434 * it is in common with us.
436 const char *hex
= sha1_to_hex(result_sha1
);
437 packet_buf_write(&req_buf
, "have %s\n", hex
);
438 state_len
= req_buf
.len
;
440 mark_common(commit
, 0, 1);
444 if (ack
== ACK_ready
) {
453 if (got_continue
&& MAX_IN_VAIN
< in_vain
) {
455 fprintf(stderr
, "giving up\n");
461 if (!got_ready
|| !no_done
) {
462 packet_buf_write(&req_buf
, "done\n");
463 send_request(args
, fd
[1], &req_buf
);
466 fprintf(stderr
, "done\n");
471 strbuf_release(&req_buf
);
473 consume_shallow_list(args
, fd
[0]);
474 while (flushes
|| multi_ack
) {
475 int ack
= get_ack(fd
[0], result_sha1
);
478 fprintf(stderr
, "got ack (%d) %s\n", ack
,
479 sha1_to_hex(result_sha1
));
487 /* it is no error to fetch into a completely empty repo */
488 return count
? retval
: 0;
491 static struct commit_list
*complete
;
493 static int mark_complete(const char *refname
, const unsigned char *sha1
, int flag
, void *cb_data
)
495 struct object
*o
= parse_object(sha1
);
497 while (o
&& o
->type
== OBJ_TAG
) {
498 struct tag
*t
= (struct tag
*) o
;
500 break; /* broken repository */
501 o
->flags
|= COMPLETE
;
502 o
= parse_object(t
->tagged
->sha1
);
504 if (o
&& o
->type
== OBJ_COMMIT
) {
505 struct commit
*commit
= (struct commit
*)o
;
506 if (!(commit
->object
.flags
& COMPLETE
)) {
507 commit
->object
.flags
|= COMPLETE
;
508 commit_list_insert_by_date(commit
, &complete
);
514 static void mark_recent_complete_commits(struct fetch_pack_args
*args
,
515 unsigned long cutoff
)
517 while (complete
&& cutoff
<= complete
->item
->date
) {
519 fprintf(stderr
, "Marking %s as complete\n",
520 sha1_to_hex(complete
->item
->object
.sha1
));
521 pop_most_recent_commit(&complete
, COMPLETE
);
525 static void filter_refs(struct fetch_pack_args
*args
,
527 struct ref
**sought
, int nr_sought
)
529 struct ref
*newlist
= NULL
;
530 struct ref
**newtail
= &newlist
;
531 struct ref
*ref
, *next
;
535 for (ref
= *refs
; ref
; ref
= next
) {
539 if (!memcmp(ref
->name
, "refs/", 5) &&
540 check_refname_format(ref
->name
+ 5, 0))
543 while (i
< nr_sought
) {
544 int cmp
= strcmp(ref
->name
, sought
[i
]->name
);
546 break; /* definitely do not have it */
548 keep
= 1; /* definitely have it */
549 sought
[i
]->matched
= 1;
555 if (!keep
&& args
->fetch_all
&&
556 (!args
->depth
|| prefixcmp(ref
->name
, "refs/tags/")))
562 newtail
= &ref
->next
;
568 /* Append unmatched requests to the list */
569 if (allow_tip_sha1_in_want
) {
570 for (i
= 0; i
< nr_sought
; i
++) {
574 if (get_sha1_hex(ref
->name
, ref
->old_sha1
))
580 newtail
= &ref
->next
;
586 static void mark_alternate_complete(const struct ref
*ref
, void *unused
)
588 mark_complete(NULL
, ref
->old_sha1
, 0, NULL
);
591 static int everything_local(struct fetch_pack_args
*args
,
593 struct ref
**sought
, int nr_sought
)
597 unsigned long cutoff
= 0;
599 save_commit_buffer
= 0;
601 for (ref
= *refs
; ref
; ref
= ref
->next
) {
604 if (!has_sha1_file(ref
->old_sha1
))
607 o
= parse_object(ref
->old_sha1
);
611 /* We already have it -- which may mean that we were
612 * in sync with the other side at some time after
613 * that (it is OK if we guess wrong here).
615 if (o
->type
== OBJ_COMMIT
) {
616 struct commit
*commit
= (struct commit
*)o
;
617 if (!cutoff
|| cutoff
< commit
->date
)
618 cutoff
= commit
->date
;
623 for_each_ref(mark_complete
, NULL
);
624 for_each_alternate_ref(mark_alternate_complete
, NULL
);
626 mark_recent_complete_commits(args
, cutoff
);
630 * Mark all complete remote refs as common refs.
631 * Don't mark them common yet; the server has to be told so first.
633 for (ref
= *refs
; ref
; ref
= ref
->next
) {
634 struct object
*o
= deref_tag(lookup_object(ref
->old_sha1
),
637 if (!o
|| o
->type
!= OBJ_COMMIT
|| !(o
->flags
& COMPLETE
))
640 if (!(o
->flags
& SEEN
)) {
641 rev_list_push((struct commit
*)o
, COMMON_REF
| SEEN
);
643 mark_common((struct commit
*)o
, 1, 1);
647 filter_refs(args
, refs
, sought
, nr_sought
);
649 for (retval
= 1, ref
= *refs
; ref
; ref
= ref
->next
) {
650 const unsigned char *remote
= ref
->old_sha1
;
651 unsigned char local
[20];
654 o
= lookup_object(remote
);
655 if (!o
|| !(o
->flags
& COMPLETE
)) {
660 "want %s (%s)\n", sha1_to_hex(remote
),
665 hashcpy(ref
->new_sha1
, local
);
669 "already have %s (%s)\n", sha1_to_hex(remote
),
675 static int sideband_demux(int in
, int out
, void *data
)
679 int ret
= recv_sideband("fetch-pack", xd
[0], out
);
684 static int get_pack(struct fetch_pack_args
*args
,
685 int xd
[2], char **pack_lockfile
)
688 const char *argv
[22];
692 int do_keep
= args
->keep_pack
;
693 struct child_process cmd
;
695 memset(&demux
, 0, sizeof(demux
));
697 /* xd[] is talking with upload-pack; subprocess reads from
698 * xd[0], spits out band#2 to stderr, and feeds us band#1
699 * through demux->out.
701 demux
.proc
= sideband_demux
;
704 if (start_async(&demux
))
705 die("fetch-pack: unable to fork off sideband"
711 memset(&cmd
, 0, sizeof(cmd
));
715 if (!args
->keep_pack
&& unpack_limit
) {
716 struct pack_header header
;
718 if (read_pack_header(demux
.out
, &header
))
719 die("protocol error: bad pack header");
720 snprintf(hdr_arg
, sizeof(hdr_arg
),
721 "--pack_header=%"PRIu32
",%"PRIu32
,
722 ntohl(header
.hdr_version
), ntohl(header
.hdr_entries
));
723 if (ntohl(header
.hdr_entries
) < unpack_limit
)
729 if (alternate_shallow_file
) {
730 *av
++ = "--shallow-file";
731 *av
++ = alternate_shallow_file
;
737 *av
++ = "index-pack";
739 if (!args
->quiet
&& !args
->no_progress
)
741 if (args
->use_thin_pack
)
742 *av
++ = "--fix-thin";
743 if (args
->lock_pack
|| unpack_limit
) {
744 int s
= sprintf(keep_arg
,
745 "--keep=fetch-pack %"PRIuMAX
" on ", (uintmax_t) getpid());
746 if (gethostname(keep_arg
+ s
, sizeof(keep_arg
) - s
))
747 strcpy(keep_arg
+ s
, "localhost");
752 *av
++ = "unpack-objects";
753 if (args
->quiet
|| args
->no_progress
)
758 if (fetch_fsck_objects
>= 0
760 : transfer_fsck_objects
>= 0
761 ? transfer_fsck_objects
768 if (start_command(&cmd
))
769 die("fetch-pack: unable to fork off %s", argv
[0]);
770 if (do_keep
&& pack_lockfile
) {
771 *pack_lockfile
= index_pack_lockfile(cmd
.out
);
775 if (finish_command(&cmd
))
776 die("%s failed", argv
[0]);
777 if (use_sideband
&& finish_async(&demux
))
778 die("error in sideband demultiplexer");
782 static int cmp_ref_by_name(const void *a_
, const void *b_
)
784 const struct ref
*a
= *((const struct ref
**)a_
);
785 const struct ref
*b
= *((const struct ref
**)b_
);
786 return strcmp(a
->name
, b
->name
);
789 static void setup_alternate_shallow(void)
791 struct strbuf sb
= STRBUF_INIT
;
794 check_shallow_file_for_update();
795 fd
= hold_lock_file_for_update(&shallow_lock
, git_path("shallow"),
797 if (write_shallow_commits(&sb
, 0)) {
798 if (write_in_full(fd
, sb
.buf
, sb
.len
) != sb
.len
)
799 die_errno("failed to write to %s", shallow_lock
.filename
);
800 alternate_shallow_file
= shallow_lock
.filename
;
803 * is_repository_shallow() sees empty string as "no
806 alternate_shallow_file
= "";
810 static struct ref
*do_fetch_pack(struct fetch_pack_args
*args
,
812 const struct ref
*orig_ref
,
813 struct ref
**sought
, int nr_sought
,
814 char **pack_lockfile
)
816 struct ref
*ref
= copy_ref_list(orig_ref
);
817 unsigned char sha1
[20];
818 const char *agent_feature
;
821 sort_ref_list(&ref
, ref_compare_name
);
822 qsort(sought
, nr_sought
, sizeof(*sought
), cmp_ref_by_name
);
824 if (is_repository_shallow() && !server_supports("shallow"))
825 die("Server does not support shallow clients");
826 if (server_supports("multi_ack_detailed")) {
828 fprintf(stderr
, "Server supports multi_ack_detailed\n");
830 if (server_supports("no-done")) {
832 fprintf(stderr
, "Server supports no-done\n");
833 if (args
->stateless_rpc
)
837 else if (server_supports("multi_ack")) {
839 fprintf(stderr
, "Server supports multi_ack\n");
842 if (server_supports("side-band-64k")) {
844 fprintf(stderr
, "Server supports side-band-64k\n");
847 else if (server_supports("side-band")) {
849 fprintf(stderr
, "Server supports side-band\n");
852 if (server_supports("allow-tip-sha1-in-want")) {
854 fprintf(stderr
, "Server supports allow-tip-sha1-in-want\n");
855 allow_tip_sha1_in_want
= 1;
857 if (!server_supports("thin-pack"))
858 args
->use_thin_pack
= 0;
859 if (!server_supports("no-progress"))
860 args
->no_progress
= 0;
861 if (!server_supports("include-tag"))
862 args
->include_tag
= 0;
863 if (server_supports("ofs-delta")) {
865 fprintf(stderr
, "Server supports ofs-delta\n");
867 prefer_ofs_delta
= 0;
869 if ((agent_feature
= server_feature_value("agent", &agent_len
))) {
871 if (args
->verbose
&& agent_len
)
872 fprintf(stderr
, "Server version is %.*s\n",
873 agent_len
, agent_feature
);
876 if (everything_local(args
, &ref
, sought
, nr_sought
)) {
880 if (find_common(args
, fd
, sha1
, ref
) < 0)
881 if (!args
->keep_pack
)
882 /* When cloning, it is not unusual to have
885 warning("no common commits");
887 if (args
->stateless_rpc
)
890 setup_alternate_shallow();
892 alternate_shallow_file
= NULL
;
893 if (get_pack(args
, fd
, pack_lockfile
))
894 die("git fetch-pack: fetch failed.");
900 static int fetch_pack_config(const char *var
, const char *value
, void *cb
)
902 if (strcmp(var
, "fetch.unpacklimit") == 0) {
903 fetch_unpack_limit
= git_config_int(var
, value
);
907 if (strcmp(var
, "transfer.unpacklimit") == 0) {
908 transfer_unpack_limit
= git_config_int(var
, value
);
912 if (strcmp(var
, "repack.usedeltabaseoffset") == 0) {
913 prefer_ofs_delta
= git_config_bool(var
, value
);
917 if (!strcmp(var
, "fetch.fsckobjects")) {
918 fetch_fsck_objects
= git_config_bool(var
, value
);
922 if (!strcmp(var
, "transfer.fsckobjects")) {
923 transfer_fsck_objects
= git_config_bool(var
, value
);
927 return git_default_config(var
, value
, cb
);
930 static void fetch_pack_setup(void)
932 static int did_setup
;
935 git_config(fetch_pack_config
, NULL
);
936 if (0 <= transfer_unpack_limit
)
937 unpack_limit
= transfer_unpack_limit
;
938 else if (0 <= fetch_unpack_limit
)
939 unpack_limit
= fetch_unpack_limit
;
943 static int remove_duplicates_in_refs(struct ref
**ref
, int nr
)
945 struct string_list names
= STRING_LIST_INIT_NODUP
;
948 for (src
= dst
= 0; src
< nr
; src
++) {
949 struct string_list_item
*item
;
950 item
= string_list_insert(&names
, ref
[src
]->name
);
952 continue; /* already have it */
953 item
->util
= ref
[src
];
958 for (src
= dst
; src
< nr
; src
++)
960 string_list_clear(&names
, 0);
964 struct ref
*fetch_pack(struct fetch_pack_args
*args
,
965 int fd
[], struct child_process
*conn
,
966 const struct ref
*ref
,
968 struct ref
**sought
, int nr_sought
,
969 char **pack_lockfile
)
975 nr_sought
= remove_duplicates_in_refs(sought
, nr_sought
);
979 die("no matching remote head");
981 ref_cpy
= do_fetch_pack(args
, fd
, ref
, sought
, nr_sought
, pack_lockfile
);
983 if (args
->depth
> 0 && alternate_shallow_file
) {
984 if (*alternate_shallow_file
== '\0') { /* --unshallow */
985 unlink_or_warn(git_path("shallow"));
986 rollback_lock_file(&shallow_lock
);
988 commit_lock_file(&shallow_lock
);
991 reprepare_packed_git();