9 #include "fetch-pack.h"
11 #include "run-command.h"
12 #include "transport.h"
14 static int transfer_unpack_limit
= -1;
15 static int fetch_unpack_limit
= -1;
16 static int unpack_limit
= 100;
17 static int prefer_ofs_delta
= 1;
19 static int fetch_fsck_objects
= -1;
20 static int transfer_fsck_objects
= -1;
21 static struct fetch_pack_args args
= {
22 /* .uploadpack = */ "git-upload-pack",
25 static const char fetch_pack_usage
[] =
26 "git fetch-pack [--all] [--quiet|-q] [--keep|-k] [--thin] [--include-tag] [--upload-pack=<git-upload-pack>] [--depth=<n>] [--no-progress] [-v] [<host>:]<directory> [<refs>...]";
28 #define COMPLETE (1U << 0)
29 #define COMMON (1U << 1)
30 #define COMMON_REF (1U << 2)
31 #define SEEN (1U << 3)
32 #define POPPED (1U << 4)
37 * After sending this many "have"s if we do not get any new ACK , we
38 * give up traversing our history.
40 #define MAX_IN_VAIN 256
42 static struct commit_list
*rev_list
;
43 static int non_common_revs
, multi_ack
, use_sideband
;
45 static void rev_list_push(struct commit
*commit
, int mark
)
47 if (!(commit
->object
.flags
& mark
)) {
48 commit
->object
.flags
|= mark
;
50 if (!(commit
->object
.parsed
))
51 if (parse_commit(commit
))
54 commit_list_insert_by_date(commit
, &rev_list
);
56 if (!(commit
->object
.flags
& COMMON
))
61 static int rev_list_insert_ref(const char *refname
, const unsigned char *sha1
, int flag
, void *cb_data
)
63 struct object
*o
= deref_tag(parse_object(sha1
), refname
, 0);
65 if (o
&& o
->type
== OBJ_COMMIT
)
66 rev_list_push((struct commit
*)o
, SEEN
);
71 static int clear_marks(const char *refname
, const unsigned char *sha1
, int flag
, void *cb_data
)
73 struct object
*o
= deref_tag(parse_object(sha1
), refname
, 0);
75 if (o
&& o
->type
== OBJ_COMMIT
)
76 clear_commit_marks((struct commit
*)o
,
77 COMMON
| COMMON_REF
| SEEN
| POPPED
);
82 This function marks a rev and its ancestors as common.
83 In some cases, it is desirable to mark only the ancestors (for example
84 when only the server does not yet know that they are common).
87 static void mark_common(struct commit
*commit
,
88 int ancestors_only
, int dont_parse
)
90 if (commit
!= NULL
&& !(commit
->object
.flags
& COMMON
)) {
91 struct object
*o
= (struct object
*)commit
;
96 if (!(o
->flags
& SEEN
))
97 rev_list_push(commit
, SEEN
);
99 struct commit_list
*parents
;
101 if (!ancestors_only
&& !(o
->flags
& POPPED
))
103 if (!o
->parsed
&& !dont_parse
)
104 if (parse_commit(commit
))
107 for (parents
= commit
->parents
;
109 parents
= parents
->next
)
110 mark_common(parents
->item
, 0, dont_parse
);
116 Get the next rev to send, ignoring the common.
119 static const unsigned char *get_rev(void)
121 struct commit
*commit
= NULL
;
123 while (commit
== NULL
) {
125 struct commit_list
*parents
;
127 if (rev_list
== NULL
|| non_common_revs
== 0)
130 commit
= rev_list
->item
;
131 if (!commit
->object
.parsed
)
132 parse_commit(commit
);
133 parents
= commit
->parents
;
135 commit
->object
.flags
|= POPPED
;
136 if (!(commit
->object
.flags
& COMMON
))
139 if (commit
->object
.flags
& COMMON
) {
140 /* do not send "have", and ignore ancestors */
142 mark
= COMMON
| SEEN
;
143 } else if (commit
->object
.flags
& COMMON_REF
)
144 /* send "have", and ignore ancestors */
145 mark
= COMMON
| SEEN
;
147 /* send "have", also for its ancestors */
151 if (!(parents
->item
->object
.flags
& SEEN
))
152 rev_list_push(parents
->item
, mark
);
154 mark_common(parents
->item
, 1, 0);
155 parents
= parents
->next
;
158 rev_list
= rev_list
->next
;
161 return commit
->object
.sha1
;
172 static void consume_shallow_list(int fd
)
174 if (args
.stateless_rpc
&& args
.depth
> 0) {
175 /* If we sent a depth we will get back "duplicate"
176 * shallow and unshallow commands every time there
177 * is a block of have lines exchanged.
180 while (packet_read_line(fd
, line
, sizeof(line
))) {
181 if (!prefixcmp(line
, "shallow "))
183 if (!prefixcmp(line
, "unshallow "))
185 die("git fetch-pack: expected shallow list");
190 struct write_shallow_data
{
192 int use_pack_protocol
;
196 static int write_one_shallow(const struct commit_graft
*graft
, void *cb_data
)
198 struct write_shallow_data
*data
= cb_data
;
199 const char *hex
= sha1_to_hex(graft
->sha1
);
201 if (data
->use_pack_protocol
)
202 packet_buf_write(data
->out
, "shallow %s", hex
);
204 strbuf_addstr(data
->out
, hex
);
205 strbuf_addch(data
->out
, '\n');
210 static int write_shallow_commits(struct strbuf
*out
, int use_pack_protocol
)
212 struct write_shallow_data data
;
214 data
.use_pack_protocol
= use_pack_protocol
;
216 for_each_commit_graft(write_one_shallow
, &data
);
220 static enum ack_type
get_ack(int fd
, unsigned char *result_sha1
)
222 static char line
[1000];
223 int len
= packet_read_line(fd
, line
, sizeof(line
));
226 die("git fetch-pack: expected ACK/NAK, got EOF");
227 if (line
[len
-1] == '\n')
229 if (!strcmp(line
, "NAK"))
231 if (!prefixcmp(line
, "ACK ")) {
232 if (!get_sha1_hex(line
+4, result_sha1
)) {
233 if (strstr(line
+45, "continue"))
235 if (strstr(line
+45, "common"))
237 if (strstr(line
+45, "ready"))
242 die("git fetch_pack: expected ACK/NAK, got '%s'", line
);
245 static void send_request(int fd
, struct strbuf
*buf
)
247 if (args
.stateless_rpc
) {
248 send_sideband(fd
, -1, buf
->buf
, buf
->len
, LARGE_PACKET_MAX
);
251 safe_write(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(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(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 packet_buf_write(&req_buf
, "want %s%s\n", remote_hex
, c
.buf
);
331 packet_buf_write(&req_buf
, "want %s\n", remote_hex
);
336 strbuf_release(&req_buf
);
341 if (is_repository_shallow())
342 write_shallow_commits(&req_buf
, 1);
344 packet_buf_write(&req_buf
, "deepen %d", args
.depth
);
345 packet_buf_flush(&req_buf
);
346 state_len
= req_buf
.len
;
348 if (args
.depth
> 0) {
350 unsigned char sha1
[20];
352 send_request(fd
[1], &req_buf
);
353 while (packet_read_line(fd
[0], line
, sizeof(line
))) {
354 if (!prefixcmp(line
, "shallow ")) {
355 if (get_sha1_hex(line
+ 8, sha1
))
356 die("invalid shallow line: %s", line
);
357 register_shallow(sha1
);
360 if (!prefixcmp(line
, "unshallow ")) {
361 if (get_sha1_hex(line
+ 10, sha1
))
362 die("invalid unshallow line: %s", line
);
363 if (!lookup_object(sha1
))
364 die("object not found: %s", line
);
365 /* make sure that it is parsed as shallow */
366 if (!parse_object(sha1
))
367 die("error in object: %s", line
);
368 if (unregister_shallow(sha1
))
369 die("no shallow found: %s", line
);
372 die("expected shallow/unshallow, got %s", line
);
374 } else if (!args
.stateless_rpc
)
375 send_request(fd
[1], &req_buf
);
377 if (!args
.stateless_rpc
) {
378 /* If we aren't using the stateless-rpc interface
379 * we don't need to retain the headers.
381 strbuf_setlen(&req_buf
, 0);
387 while ((sha1
= get_rev())) {
388 packet_buf_write(&req_buf
, "have %s\n", sha1_to_hex(sha1
));
390 fprintf(stderr
, "have %s\n", sha1_to_hex(sha1
));
392 if (flush_at
<= ++count
) {
395 packet_buf_flush(&req_buf
);
396 send_request(fd
[1], &req_buf
);
397 strbuf_setlen(&req_buf
, state_len
);
399 flush_at
= next_flush(count
);
402 * We keep one window "ahead" of the other side, and
403 * will wait for an ACK only on the next one
405 if (!args
.stateless_rpc
&& count
== INITIAL_FLUSH
)
408 consume_shallow_list(fd
[0]);
410 ack
= get_ack(fd
[0], result_sha1
);
411 if (args
.verbose
&& ack
)
412 fprintf(stderr
, "got ack %d %s\n", ack
,
413 sha1_to_hex(result_sha1
));
423 struct commit
*commit
=
424 lookup_commit(result_sha1
);
426 die("invalid commit %s", sha1_to_hex(result_sha1
));
427 if (args
.stateless_rpc
429 && !(commit
->object
.flags
& COMMON
)) {
430 /* We need to replay the have for this object
431 * on the next RPC request so the peer knows
432 * it is in common with us.
434 const char *hex
= sha1_to_hex(result_sha1
);
435 packet_buf_write(&req_buf
, "have %s\n", hex
);
436 state_len
= req_buf
.len
;
438 mark_common(commit
, 0, 1);
442 if (ack
== ACK_ready
) {
451 if (got_continue
&& MAX_IN_VAIN
< in_vain
) {
453 fprintf(stderr
, "giving up\n");
459 if (!got_ready
|| !no_done
) {
460 packet_buf_write(&req_buf
, "done\n");
461 send_request(fd
[1], &req_buf
);
464 fprintf(stderr
, "done\n");
469 strbuf_release(&req_buf
);
471 consume_shallow_list(fd
[0]);
472 while (flushes
|| multi_ack
) {
473 int ack
= get_ack(fd
[0], result_sha1
);
476 fprintf(stderr
, "got ack (%d) %s\n", ack
,
477 sha1_to_hex(result_sha1
));
485 /* it is no error to fetch into a completely empty repo */
486 return count
? retval
: 0;
489 static struct commit_list
*complete
;
491 static int mark_complete(const char *refname
, const unsigned char *sha1
, int flag
, void *cb_data
)
493 struct object
*o
= parse_object(sha1
);
495 while (o
&& o
->type
== OBJ_TAG
) {
496 struct tag
*t
= (struct tag
*) o
;
498 break; /* broken repository */
499 o
->flags
|= COMPLETE
;
500 o
= parse_object(t
->tagged
->sha1
);
502 if (o
&& o
->type
== OBJ_COMMIT
) {
503 struct commit
*commit
= (struct commit
*)o
;
504 if (!(commit
->object
.flags
& COMPLETE
)) {
505 commit
->object
.flags
|= COMPLETE
;
506 commit_list_insert_by_date(commit
, &complete
);
512 static void mark_recent_complete_commits(unsigned long cutoff
)
514 while (complete
&& cutoff
<= complete
->item
->date
) {
516 fprintf(stderr
, "Marking %s as complete\n",
517 sha1_to_hex(complete
->item
->object
.sha1
));
518 pop_most_recent_commit(&complete
, COMPLETE
);
522 static void filter_refs(struct ref
**refs
, int nr_match
, char **match
)
524 struct ref
**return_refs
;
525 struct ref
*newlist
= NULL
;
526 struct ref
**newtail
= &newlist
;
527 struct ref
*ref
, *next
;
528 struct ref
*fastarray
[32];
530 if (nr_match
&& !args
.fetch_all
) {
531 if (ARRAY_SIZE(fastarray
) < nr_match
)
532 return_refs
= xcalloc(nr_match
, sizeof(struct ref
*));
534 return_refs
= fastarray
;
535 memset(return_refs
, 0, sizeof(struct ref
*) * nr_match
);
541 for (ref
= *refs
; ref
; ref
= next
) {
543 if (!memcmp(ref
->name
, "refs/", 5) &&
544 check_refname_format(ref
->name
+ 5, 0))
546 else if (args
.fetch_all
&&
547 (!args
.depth
|| prefixcmp(ref
->name
, "refs/tags/") )) {
550 newtail
= &ref
->next
;
555 for (i
= 0; i
< nr_match
; i
++) {
556 if (!strcmp(ref
->name
, match
[i
])) {
558 return_refs
[i
] = ref
;
563 continue; /* we will link it later */
568 if (!args
.fetch_all
) {
570 for (i
= 0; i
< nr_match
; i
++) {
571 ref
= return_refs
[i
];
575 newtail
= &ref
->next
;
578 if (return_refs
!= fastarray
)
584 static int everything_local(struct ref
**refs
, int nr_match
, char **match
)
588 unsigned long cutoff
= 0;
590 save_commit_buffer
= 0;
592 for (ref
= *refs
; ref
; ref
= ref
->next
) {
595 o
= parse_object(ref
->old_sha1
);
599 /* We already have it -- which may mean that we were
600 * in sync with the other side at some time after
601 * that (it is OK if we guess wrong here).
603 if (o
->type
== OBJ_COMMIT
) {
604 struct commit
*commit
= (struct commit
*)o
;
605 if (!cutoff
|| cutoff
< commit
->date
)
606 cutoff
= commit
->date
;
611 for_each_ref(mark_complete
, NULL
);
613 mark_recent_complete_commits(cutoff
);
617 * Mark all complete remote refs as common refs.
618 * Don't mark them common yet; the server has to be told so first.
620 for (ref
= *refs
; ref
; ref
= ref
->next
) {
621 struct object
*o
= deref_tag(lookup_object(ref
->old_sha1
),
624 if (!o
|| o
->type
!= OBJ_COMMIT
|| !(o
->flags
& COMPLETE
))
627 if (!(o
->flags
& SEEN
)) {
628 rev_list_push((struct commit
*)o
, COMMON_REF
| SEEN
);
630 mark_common((struct commit
*)o
, 1, 1);
634 filter_refs(refs
, nr_match
, match
);
636 for (retval
= 1, ref
= *refs
; ref
; ref
= ref
->next
) {
637 const unsigned char *remote
= ref
->old_sha1
;
638 unsigned char local
[20];
641 o
= lookup_object(remote
);
642 if (!o
|| !(o
->flags
& COMPLETE
)) {
647 "want %s (%s)\n", sha1_to_hex(remote
),
652 hashcpy(ref
->new_sha1
, local
);
656 "already have %s (%s)\n", sha1_to_hex(remote
),
662 static int sideband_demux(int in
, int out
, void *data
)
666 int ret
= recv_sideband("fetch-pack", xd
[0], out
);
671 static int get_pack(int xd
[2], char **pack_lockfile
)
674 const char *argv
[20];
678 int do_keep
= args
.keep_pack
;
679 struct child_process cmd
;
681 memset(&demux
, 0, sizeof(demux
));
683 /* xd[] is talking with upload-pack; subprocess reads from
684 * xd[0], spits out band#2 to stderr, and feeds us band#1
685 * through demux->out.
687 demux
.proc
= sideband_demux
;
690 if (start_async(&demux
))
691 die("fetch-pack: unable to fork off sideband"
697 memset(&cmd
, 0, sizeof(cmd
));
701 if (!args
.keep_pack
&& unpack_limit
) {
702 struct pack_header header
;
704 if (read_pack_header(demux
.out
, &header
))
705 die("protocol error: bad pack header");
706 snprintf(hdr_arg
, sizeof(hdr_arg
),
707 "--pack_header=%"PRIu32
",%"PRIu32
,
708 ntohl(header
.hdr_version
), ntohl(header
.hdr_entries
));
709 if (ntohl(header
.hdr_entries
) < unpack_limit
)
718 *av
++ = "index-pack";
720 if (!args
.quiet
&& !args
.no_progress
)
722 if (args
.use_thin_pack
)
723 *av
++ = "--fix-thin";
724 if (args
.lock_pack
|| unpack_limit
) {
725 int s
= sprintf(keep_arg
,
726 "--keep=fetch-pack %"PRIuMAX
" on ", (uintmax_t) getpid());
727 if (gethostname(keep_arg
+ s
, sizeof(keep_arg
) - s
))
728 strcpy(keep_arg
+ s
, "localhost");
733 *av
++ = "unpack-objects";
739 if (fetch_fsck_objects
>= 0
741 : transfer_fsck_objects
>= 0
742 ? transfer_fsck_objects
749 if (start_command(&cmd
))
750 die("fetch-pack: unable to fork off %s", argv
[0]);
751 if (do_keep
&& pack_lockfile
) {
752 *pack_lockfile
= index_pack_lockfile(cmd
.out
);
756 if (finish_command(&cmd
))
757 die("%s failed", argv
[0]);
758 if (use_sideband
&& finish_async(&demux
))
759 die("error in sideband demultiplexer");
763 static struct ref
*do_fetch_pack(int fd
[2],
764 const struct ref
*orig_ref
,
767 char **pack_lockfile
)
769 struct ref
*ref
= copy_ref_list(orig_ref
);
770 unsigned char sha1
[20];
772 if (is_repository_shallow() && !server_supports("shallow"))
773 die("Server does not support shallow clients");
774 if (server_supports("multi_ack_detailed")) {
776 fprintf(stderr
, "Server supports multi_ack_detailed\n");
778 if (server_supports("no-done")) {
780 fprintf(stderr
, "Server supports no-done\n");
781 if (args
.stateless_rpc
)
785 else if (server_supports("multi_ack")) {
787 fprintf(stderr
, "Server supports multi_ack\n");
790 if (server_supports("side-band-64k")) {
792 fprintf(stderr
, "Server supports side-band-64k\n");
795 else if (server_supports("side-band")) {
797 fprintf(stderr
, "Server supports side-band\n");
800 if (server_supports("ofs-delta")) {
802 fprintf(stderr
, "Server supports ofs-delta\n");
804 prefer_ofs_delta
= 0;
805 if (everything_local(&ref
, nr_match
, match
)) {
809 if (find_common(fd
, sha1
, ref
) < 0)
811 /* When cloning, it is not unusual to have
814 warning("no common commits");
816 if (args
.stateless_rpc
)
818 if (get_pack(fd
, pack_lockfile
))
819 die("git fetch-pack: fetch failed.");
825 static int remove_duplicates(int nr_heads
, char **heads
)
829 for (src
= dst
= 0; src
< nr_heads
; src
++) {
830 /* If heads[src] is different from any of
831 * heads[0..dst], push it in.
834 for (i
= 0; i
< dst
; i
++) {
835 if (!strcmp(heads
[i
], heads
[src
]))
841 heads
[dst
] = heads
[src
];
847 static int fetch_pack_config(const char *var
, const char *value
, void *cb
)
849 if (strcmp(var
, "fetch.unpacklimit") == 0) {
850 fetch_unpack_limit
= git_config_int(var
, value
);
854 if (strcmp(var
, "transfer.unpacklimit") == 0) {
855 transfer_unpack_limit
= git_config_int(var
, value
);
859 if (strcmp(var
, "repack.usedeltabaseoffset") == 0) {
860 prefer_ofs_delta
= git_config_bool(var
, value
);
864 if (!strcmp(var
, "fetch.fsckobjects")) {
865 fetch_fsck_objects
= git_config_bool(var
, value
);
869 if (!strcmp(var
, "transfer.fsckobjects")) {
870 transfer_fsck_objects
= git_config_bool(var
, value
);
874 return git_default_config(var
, value
, cb
);
877 static struct lock_file lock
;
879 static void fetch_pack_setup(void)
881 static int did_setup
;
884 git_config(fetch_pack_config
, NULL
);
885 if (0 <= transfer_unpack_limit
)
886 unpack_limit
= transfer_unpack_limit
;
887 else if (0 <= fetch_unpack_limit
)
888 unpack_limit
= fetch_unpack_limit
;
892 int cmd_fetch_pack(int argc
, const char **argv
, const char *prefix
)
894 int i
, ret
, nr_heads
;
895 struct ref
*ref
= NULL
;
896 char *dest
= NULL
, **heads
;
898 char *pack_lockfile
= NULL
;
899 char **pack_lockfile_ptr
= NULL
;
900 struct child_process
*conn
;
902 packet_trace_identity("fetch-pack");
906 for (i
= 1; i
< argc
; i
++) {
907 const char *arg
= argv
[i
];
910 if (!prefixcmp(arg
, "--upload-pack=")) {
911 args
.uploadpack
= arg
+ 14;
914 if (!prefixcmp(arg
, "--exec=")) {
915 args
.uploadpack
= arg
+ 7;
918 if (!strcmp("--quiet", arg
) || !strcmp("-q", arg
)) {
922 if (!strcmp("--keep", arg
) || !strcmp("-k", arg
)) {
923 args
.lock_pack
= args
.keep_pack
;
927 if (!strcmp("--thin", arg
)) {
928 args
.use_thin_pack
= 1;
931 if (!strcmp("--include-tag", arg
)) {
932 args
.include_tag
= 1;
935 if (!strcmp("--all", arg
)) {
939 if (!strcmp("-v", arg
)) {
943 if (!prefixcmp(arg
, "--depth=")) {
944 args
.depth
= strtol(arg
+ 8, NULL
, 0);
947 if (!strcmp("--no-progress", arg
)) {
948 args
.no_progress
= 1;
951 if (!strcmp("--stateless-rpc", arg
)) {
952 args
.stateless_rpc
= 1;
955 if (!strcmp("--lock-pack", arg
)) {
957 pack_lockfile_ptr
= &pack_lockfile
;
960 usage(fetch_pack_usage
);
963 heads
= (char **)(argv
+ i
+ 1);
964 nr_heads
= argc
- i
- 1;
968 usage(fetch_pack_usage
);
970 if (args
.stateless_rpc
) {
975 conn
= git_connect(fd
, (char *)dest
, args
.uploadpack
,
976 args
.verbose
? CONNECT_VERBOSE
: 0);
979 get_remote_heads(fd
[0], &ref
, 0, NULL
);
981 ref
= fetch_pack(&args
, fd
, conn
, ref
, dest
,
982 nr_heads
, heads
, pack_lockfile_ptr
);
984 printf("lock %s\n", pack_lockfile
);
989 if (finish_connect(conn
))
993 if (!ret
&& nr_heads
) {
994 /* If the heads to pull were given, we should have
995 * consumed all of them by matching the remote.
996 * Otherwise, 'git fetch remote no-such-ref' would
997 * silently succeed without issuing an error.
999 for (i
= 0; i
< nr_heads
; i
++)
1000 if (heads
[i
] && heads
[i
][0]) {
1001 error("no such remote ref %s", heads
[i
]);
1007 sha1_to_hex(ref
->old_sha1
), ref
->name
);
1014 struct ref
*fetch_pack(struct fetch_pack_args
*my_args
,
1015 int fd
[], struct child_process
*conn
,
1016 const struct ref
*ref
,
1020 char **pack_lockfile
)
1023 struct ref
*ref_cpy
;
1026 if (&args
!= my_args
)
1027 memcpy(&args
, my_args
, sizeof(args
));
1028 if (args
.depth
> 0) {
1029 if (stat(git_path("shallow"), &st
))
1033 if (heads
&& nr_heads
)
1034 nr_heads
= remove_duplicates(nr_heads
, heads
);
1036 packet_flush(fd
[1]);
1037 die("no matching remote head");
1039 ref_cpy
= do_fetch_pack(fd
, ref
, nr_heads
, heads
, pack_lockfile
);
1041 if (args
.depth
> 0) {
1042 struct cache_time mtime
;
1043 struct strbuf sb
= STRBUF_INIT
;
1044 char *shallow
= git_path("shallow");
1047 mtime
.sec
= st
.st_mtime
;
1048 mtime
.nsec
= ST_MTIME_NSEC(st
);
1049 if (stat(shallow
, &st
)) {
1051 die("shallow file was removed during fetch");
1052 } else if (st
.st_mtime
!= mtime
.sec
1054 || ST_MTIME_NSEC(st
) != mtime
.nsec
1057 die("shallow file was changed during fetch");
1059 fd
= hold_lock_file_for_update(&lock
, shallow
,
1061 if (!write_shallow_commits(&sb
, 0)
1062 || write_in_full(fd
, sb
.buf
, sb
.len
) != sb
.len
) {
1063 unlink_or_warn(shallow
);
1064 rollback_lock_file(&lock
);
1066 commit_lock_file(&lock
);
1068 strbuf_release(&sb
);
1071 reprepare_packed_git();