9 #include "fetch-pack.h"
11 #include "run-command.h"
13 #include "transport.h"
15 #include "prio-queue.h"
16 #include "sha1-array.h"
18 static int transfer_unpack_limit
= -1;
19 static int fetch_unpack_limit
= -1;
20 static int unpack_limit
= 100;
21 static int prefer_ofs_delta
= 1;
23 static int fetch_fsck_objects
= -1;
24 static int transfer_fsck_objects
= -1;
25 static int agent_supported
;
26 static struct lock_file shallow_lock
;
27 static const char *alternate_shallow_file
;
29 /* Remember to update object flag allocation in object.h */
30 #define COMPLETE (1U << 0)
31 #define COMMON (1U << 1)
32 #define COMMON_REF (1U << 2)
33 #define SEEN (1U << 3)
34 #define POPPED (1U << 4)
39 * After sending this many "have"s if we do not get any new ACK , we
40 * give up traversing our history.
42 #define MAX_IN_VAIN 256
44 static struct prio_queue rev_list
= { compare_commits_by_commit_date
};
45 static int non_common_revs
, multi_ack
, use_sideband
, allow_tip_sha1_in_want
;
47 static void rev_list_push(struct commit
*commit
, int mark
)
49 if (!(commit
->object
.flags
& mark
)) {
50 commit
->object
.flags
|= mark
;
52 if (parse_commit(commit
))
55 prio_queue_put(&rev_list
, commit
);
57 if (!(commit
->object
.flags
& COMMON
))
62 static int rev_list_insert_ref(const char *refname
, const unsigned char *sha1
, int flag
, void *cb_data
)
64 struct object
*o
= deref_tag(parse_object(sha1
), refname
, 0);
66 if (o
&& o
->type
== OBJ_COMMIT
)
67 rev_list_push((struct commit
*)o
, SEEN
);
72 static int clear_marks(const char *refname
, const unsigned char *sha1
, int flag
, void *cb_data
)
74 struct object
*o
= deref_tag(parse_object(sha1
), refname
, 0);
76 if (o
&& o
->type
== OBJ_COMMIT
)
77 clear_commit_marks((struct commit
*)o
,
78 COMMON
| COMMON_REF
| SEEN
| POPPED
);
83 This function marks a rev and its ancestors as common.
84 In some cases, it is desirable to mark only the ancestors (for example
85 when only the server does not yet know that they are common).
88 static void mark_common(struct commit
*commit
,
89 int ancestors_only
, int dont_parse
)
91 if (commit
!= NULL
&& !(commit
->object
.flags
& COMMON
)) {
92 struct object
*o
= (struct object
*)commit
;
97 if (!(o
->flags
& SEEN
))
98 rev_list_push(commit
, SEEN
);
100 struct commit_list
*parents
;
102 if (!ancestors_only
&& !(o
->flags
& POPPED
))
104 if (!o
->parsed
&& !dont_parse
)
105 if (parse_commit(commit
))
108 for (parents
= commit
->parents
;
110 parents
= parents
->next
)
111 mark_common(parents
->item
, 0, dont_parse
);
117 Get the next rev to send, ignoring the common.
120 static const unsigned char *get_rev(void)
122 struct commit
*commit
= NULL
;
124 while (commit
== NULL
) {
126 struct commit_list
*parents
;
128 if (rev_list
.nr
== 0 || non_common_revs
== 0)
131 commit
= prio_queue_get(&rev_list
);
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
;
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 (starts_with(line
, "shallow "))
181 if (starts_with(line
, "unshallow "))
183 die("git fetch-pack: expected shallow list");
188 static enum ack_type
get_ack(int fd
, unsigned char *result_sha1
)
191 char *line
= packet_read_line(fd
, &len
);
195 die("git fetch-pack: expected ACK/NAK, got EOF");
196 if (!strcmp(line
, "NAK"))
198 if (skip_prefix(line
, "ACK ", &arg
)) {
199 if (!get_sha1_hex(arg
, result_sha1
)) {
204 if (strstr(arg
, "continue"))
206 if (strstr(arg
, "common"))
208 if (strstr(arg
, "ready"))
213 die("git fetch_pack: expected ACK/NAK, got '%s'", line
);
216 static void send_request(struct fetch_pack_args
*args
,
217 int fd
, struct strbuf
*buf
)
219 if (args
->stateless_rpc
) {
220 send_sideband(fd
, -1, buf
->buf
, buf
->len
, LARGE_PACKET_MAX
);
223 write_or_die(fd
, buf
->buf
, buf
->len
);
226 static void insert_one_alternate_ref(const struct ref
*ref
, void *unused
)
228 rev_list_insert_ref(NULL
, ref
->old_sha1
, 0, NULL
);
231 #define INITIAL_FLUSH 16
232 #define PIPESAFE_FLUSH 32
233 #define LARGE_FLUSH 1024
235 static int next_flush(struct fetch_pack_args
*args
, int count
)
237 int flush_limit
= args
->stateless_rpc
? LARGE_FLUSH
: PIPESAFE_FLUSH
;
239 if (count
< flush_limit
)
242 count
+= flush_limit
;
246 static int find_common(struct fetch_pack_args
*args
,
247 int fd
[2], unsigned char *result_sha1
,
251 int count
= 0, flushes
= 0, flush_at
= INITIAL_FLUSH
, retval
;
252 const unsigned char *sha1
;
253 unsigned in_vain
= 0;
254 int got_continue
= 0;
256 struct strbuf req_buf
= STRBUF_INIT
;
257 size_t state_len
= 0;
259 if (args
->stateless_rpc
&& multi_ack
== 1)
260 die("--stateless-rpc requires multi_ack_detailed");
262 for_each_ref(clear_marks
, NULL
);
265 for_each_ref(rev_list_insert_ref
, NULL
);
266 for_each_alternate_ref(insert_one_alternate_ref
, NULL
);
269 for ( ; refs
; refs
= refs
->next
) {
270 unsigned char *remote
= refs
->old_sha1
;
271 const char *remote_hex
;
275 * If that object is complete (i.e. it is an ancestor of a
276 * local ref), we tell them we have it but do not have to
277 * tell them about its ancestors, which they already know
280 * We use lookup_object here because we are only
281 * interested in the case we *know* the object is
282 * reachable and we have already scanned it.
284 if (((o
= lookup_object(remote
)) != NULL
) &&
285 (o
->flags
& COMPLETE
)) {
289 remote_hex
= sha1_to_hex(remote
);
291 struct strbuf c
= STRBUF_INIT
;
292 if (multi_ack
== 2) strbuf_addstr(&c
, " multi_ack_detailed");
293 if (multi_ack
== 1) strbuf_addstr(&c
, " multi_ack");
294 if (no_done
) strbuf_addstr(&c
, " no-done");
295 if (use_sideband
== 2) strbuf_addstr(&c
, " side-band-64k");
296 if (use_sideband
== 1) strbuf_addstr(&c
, " side-band");
297 if (args
->use_thin_pack
) strbuf_addstr(&c
, " thin-pack");
298 if (args
->no_progress
) strbuf_addstr(&c
, " no-progress");
299 if (args
->include_tag
) strbuf_addstr(&c
, " include-tag");
300 if (prefer_ofs_delta
) strbuf_addstr(&c
, " ofs-delta");
301 if (agent_supported
) strbuf_addf(&c
, " agent=%s",
302 git_user_agent_sanitized());
303 packet_buf_write(&req_buf
, "want %s%s\n", remote_hex
, c
.buf
);
306 packet_buf_write(&req_buf
, "want %s\n", remote_hex
);
311 strbuf_release(&req_buf
);
316 if (is_repository_shallow())
317 write_shallow_commits(&req_buf
, 1, NULL
);
319 packet_buf_write(&req_buf
, "deepen %d", args
->depth
);
320 packet_buf_flush(&req_buf
);
321 state_len
= req_buf
.len
;
323 if (args
->depth
> 0) {
326 unsigned char sha1
[20];
328 send_request(args
, fd
[1], &req_buf
);
329 while ((line
= packet_read_line(fd
[0], NULL
))) {
330 if (skip_prefix(line
, "shallow ", &arg
)) {
331 if (get_sha1_hex(arg
, sha1
))
332 die("invalid shallow line: %s", line
);
333 register_shallow(sha1
);
336 if (skip_prefix(line
, "unshallow ", &arg
)) {
337 if (get_sha1_hex(arg
, sha1
))
338 die("invalid unshallow line: %s", line
);
339 if (!lookup_object(sha1
))
340 die("object not found: %s", line
);
341 /* make sure that it is parsed as shallow */
342 if (!parse_object(sha1
))
343 die("error in object: %s", line
);
344 if (unregister_shallow(sha1
))
345 die("no shallow found: %s", line
);
348 die("expected shallow/unshallow, got %s", line
);
350 } else if (!args
->stateless_rpc
)
351 send_request(args
, fd
[1], &req_buf
);
353 if (!args
->stateless_rpc
) {
354 /* If we aren't using the stateless-rpc interface
355 * we don't need to retain the headers.
357 strbuf_setlen(&req_buf
, 0);
363 while ((sha1
= get_rev())) {
364 packet_buf_write(&req_buf
, "have %s\n", sha1_to_hex(sha1
));
366 fprintf(stderr
, "have %s\n", sha1_to_hex(sha1
));
368 if (flush_at
<= ++count
) {
371 packet_buf_flush(&req_buf
);
372 send_request(args
, fd
[1], &req_buf
);
373 strbuf_setlen(&req_buf
, state_len
);
375 flush_at
= next_flush(args
, count
);
378 * We keep one window "ahead" of the other side, and
379 * will wait for an ACK only on the next one
381 if (!args
->stateless_rpc
&& count
== INITIAL_FLUSH
)
384 consume_shallow_list(args
, fd
[0]);
386 ack
= get_ack(fd
[0], result_sha1
);
387 if (args
->verbose
&& ack
)
388 fprintf(stderr
, "got ack %d %s\n", ack
,
389 sha1_to_hex(result_sha1
));
399 struct commit
*commit
=
400 lookup_commit(result_sha1
);
402 die("invalid commit %s", sha1_to_hex(result_sha1
));
403 if (args
->stateless_rpc
405 && !(commit
->object
.flags
& COMMON
)) {
406 /* We need to replay the have for this object
407 * on the next RPC request so the peer knows
408 * it is in common with us.
410 const char *hex
= sha1_to_hex(result_sha1
);
411 packet_buf_write(&req_buf
, "have %s\n", hex
);
412 state_len
= req_buf
.len
;
414 mark_common(commit
, 0, 1);
418 if (ack
== ACK_ready
) {
419 clear_prio_queue(&rev_list
);
427 if (got_continue
&& MAX_IN_VAIN
< in_vain
) {
429 fprintf(stderr
, "giving up\n");
435 if (!got_ready
|| !no_done
) {
436 packet_buf_write(&req_buf
, "done\n");
437 send_request(args
, fd
[1], &req_buf
);
440 fprintf(stderr
, "done\n");
445 strbuf_release(&req_buf
);
447 if (!got_ready
|| !no_done
)
448 consume_shallow_list(args
, fd
[0]);
449 while (flushes
|| multi_ack
) {
450 int ack
= get_ack(fd
[0], result_sha1
);
453 fprintf(stderr
, "got ack (%d) %s\n", ack
,
454 sha1_to_hex(result_sha1
));
462 /* it is no error to fetch into a completely empty repo */
463 return count
? retval
: 0;
466 static struct commit_list
*complete
;
468 static int mark_complete(const char *refname
, const unsigned char *sha1
, int flag
, void *cb_data
)
470 struct object
*o
= parse_object(sha1
);
472 while (o
&& o
->type
== OBJ_TAG
) {
473 struct tag
*t
= (struct tag
*) o
;
475 break; /* broken repository */
476 o
->flags
|= COMPLETE
;
477 o
= parse_object(t
->tagged
->sha1
);
479 if (o
&& o
->type
== OBJ_COMMIT
) {
480 struct commit
*commit
= (struct commit
*)o
;
481 if (!(commit
->object
.flags
& COMPLETE
)) {
482 commit
->object
.flags
|= COMPLETE
;
483 commit_list_insert(commit
, &complete
);
489 static void mark_recent_complete_commits(struct fetch_pack_args
*args
,
490 unsigned long cutoff
)
492 while (complete
&& cutoff
<= complete
->item
->date
) {
494 fprintf(stderr
, "Marking %s as complete\n",
495 sha1_to_hex(complete
->item
->object
.sha1
));
496 pop_most_recent_commit(&complete
, COMPLETE
);
500 static void filter_refs(struct fetch_pack_args
*args
,
502 struct ref
**sought
, int nr_sought
)
504 struct ref
*newlist
= NULL
;
505 struct ref
**newtail
= &newlist
;
506 struct ref
*ref
, *next
;
510 for (ref
= *refs
; ref
; ref
= next
) {
514 if (starts_with(ref
->name
, "refs/") &&
515 check_refname_format(ref
->name
, 0))
518 while (i
< nr_sought
) {
519 int cmp
= strcmp(ref
->name
, sought
[i
]->name
);
521 break; /* definitely do not have it */
523 keep
= 1; /* definitely have it */
524 sought
[i
]->matched
= 1;
530 if (!keep
&& args
->fetch_all
&&
531 (!args
->depth
|| !starts_with(ref
->name
, "refs/tags/")))
537 newtail
= &ref
->next
;
543 /* Append unmatched requests to the list */
544 if (allow_tip_sha1_in_want
) {
545 for (i
= 0; i
< nr_sought
; i
++) {
549 if (get_sha1_hex(ref
->name
, ref
->old_sha1
))
555 newtail
= &ref
->next
;
561 static void mark_alternate_complete(const struct ref
*ref
, void *unused
)
563 mark_complete(NULL
, ref
->old_sha1
, 0, NULL
);
566 static int everything_local(struct fetch_pack_args
*args
,
568 struct ref
**sought
, int nr_sought
)
572 unsigned long cutoff
= 0;
574 save_commit_buffer
= 0;
576 for (ref
= *refs
; ref
; ref
= ref
->next
) {
579 if (!has_sha1_file(ref
->old_sha1
))
582 o
= parse_object(ref
->old_sha1
);
586 /* We already have it -- which may mean that we were
587 * in sync with the other side at some time after
588 * that (it is OK if we guess wrong here).
590 if (o
->type
== OBJ_COMMIT
) {
591 struct commit
*commit
= (struct commit
*)o
;
592 if (!cutoff
|| cutoff
< commit
->date
)
593 cutoff
= commit
->date
;
598 for_each_ref(mark_complete
, NULL
);
599 for_each_alternate_ref(mark_alternate_complete
, NULL
);
600 commit_list_sort_by_date(&complete
);
602 mark_recent_complete_commits(args
, cutoff
);
606 * Mark all complete remote refs as common refs.
607 * Don't mark them common yet; the server has to be told so first.
609 for (ref
= *refs
; ref
; ref
= ref
->next
) {
610 struct object
*o
= deref_tag(lookup_object(ref
->old_sha1
),
613 if (!o
|| o
->type
!= OBJ_COMMIT
|| !(o
->flags
& COMPLETE
))
616 if (!(o
->flags
& SEEN
)) {
617 rev_list_push((struct commit
*)o
, COMMON_REF
| SEEN
);
619 mark_common((struct commit
*)o
, 1, 1);
623 filter_refs(args
, refs
, sought
, nr_sought
);
625 for (retval
= 1, ref
= *refs
; ref
; ref
= ref
->next
) {
626 const unsigned char *remote
= ref
->old_sha1
;
627 unsigned char local
[20];
630 o
= lookup_object(remote
);
631 if (!o
|| !(o
->flags
& COMPLETE
)) {
636 "want %s (%s)\n", sha1_to_hex(remote
),
641 hashcpy(ref
->new_sha1
, local
);
645 "already have %s (%s)\n", sha1_to_hex(remote
),
651 static int sideband_demux(int in
, int out
, void *data
)
655 int ret
= recv_sideband("fetch-pack", xd
[0], out
);
660 static int get_pack(struct fetch_pack_args
*args
,
661 int xd
[2], char **pack_lockfile
)
664 const char *argv
[22];
667 const char **av
, *cmd_name
;
668 int do_keep
= args
->keep_pack
;
669 struct child_process cmd
= CHILD_PROCESS_INIT
;
672 memset(&demux
, 0, sizeof(demux
));
674 /* xd[] is talking with upload-pack; subprocess reads from
675 * xd[0], spits out band#2 to stderr, and feeds us band#1
676 * through demux->out.
678 demux
.proc
= sideband_demux
;
681 if (start_async(&demux
))
682 die("fetch-pack: unable to fork off sideband"
691 if (!args
->keep_pack
&& unpack_limit
) {
692 struct pack_header header
;
694 if (read_pack_header(demux
.out
, &header
))
695 die("protocol error: bad pack header");
696 snprintf(hdr_arg
, sizeof(hdr_arg
),
697 "--pack_header=%"PRIu32
",%"PRIu32
,
698 ntohl(header
.hdr_version
), ntohl(header
.hdr_entries
));
699 if (ntohl(header
.hdr_entries
) < unpack_limit
)
705 if (alternate_shallow_file
) {
706 *av
++ = "--shallow-file";
707 *av
++ = alternate_shallow_file
;
713 *av
++ = cmd_name
= "index-pack";
715 if (!args
->quiet
&& !args
->no_progress
)
717 if (args
->use_thin_pack
)
718 *av
++ = "--fix-thin";
719 if (args
->lock_pack
|| unpack_limit
) {
720 int s
= sprintf(keep_arg
,
721 "--keep=fetch-pack %"PRIuMAX
" on ", (uintmax_t) getpid());
722 if (gethostname(keep_arg
+ s
, sizeof(keep_arg
) - s
))
723 strcpy(keep_arg
+ s
, "localhost");
726 if (args
->check_self_contained_and_connected
)
727 *av
++ = "--check-self-contained-and-connected";
730 *av
++ = cmd_name
= "unpack-objects";
731 if (args
->quiet
|| args
->no_progress
)
733 args
->check_self_contained_and_connected
= 0;
737 if (fetch_fsck_objects
>= 0
739 : transfer_fsck_objects
>= 0
740 ? transfer_fsck_objects
747 if (start_command(&cmd
))
748 die("fetch-pack: unable to fork off %s", cmd_name
);
749 if (do_keep
&& pack_lockfile
) {
750 *pack_lockfile
= index_pack_lockfile(cmd
.out
);
755 /* Closed by start_command() */
758 ret
= finish_command(&cmd
);
759 if (!ret
|| (args
->check_self_contained_and_connected
&& ret
== 1))
760 args
->self_contained_and_connected
=
761 args
->check_self_contained_and_connected
&&
764 die("%s failed", cmd_name
);
765 if (use_sideband
&& finish_async(&demux
))
766 die("error in sideband demultiplexer");
770 static int cmp_ref_by_name(const void *a_
, const void *b_
)
772 const struct ref
*a
= *((const struct ref
**)a_
);
773 const struct ref
*b
= *((const struct ref
**)b_
);
774 return strcmp(a
->name
, b
->name
);
777 static struct ref
*do_fetch_pack(struct fetch_pack_args
*args
,
779 const struct ref
*orig_ref
,
780 struct ref
**sought
, int nr_sought
,
781 struct shallow_info
*si
,
782 char **pack_lockfile
)
784 struct ref
*ref
= copy_ref_list(orig_ref
);
785 unsigned char sha1
[20];
786 const char *agent_feature
;
789 sort_ref_list(&ref
, ref_compare_name
);
790 qsort(sought
, nr_sought
, sizeof(*sought
), cmp_ref_by_name
);
792 if (is_repository_shallow() && !server_supports("shallow"))
793 die("Server does not support shallow clients");
794 if (server_supports("multi_ack_detailed")) {
796 fprintf(stderr
, "Server supports multi_ack_detailed\n");
798 if (server_supports("no-done")) {
800 fprintf(stderr
, "Server supports no-done\n");
801 if (args
->stateless_rpc
)
805 else if (server_supports("multi_ack")) {
807 fprintf(stderr
, "Server supports multi_ack\n");
810 if (server_supports("side-band-64k")) {
812 fprintf(stderr
, "Server supports side-band-64k\n");
815 else if (server_supports("side-band")) {
817 fprintf(stderr
, "Server supports side-band\n");
820 if (server_supports("allow-tip-sha1-in-want")) {
822 fprintf(stderr
, "Server supports allow-tip-sha1-in-want\n");
823 allow_tip_sha1_in_want
= 1;
825 if (!server_supports("thin-pack"))
826 args
->use_thin_pack
= 0;
827 if (!server_supports("no-progress"))
828 args
->no_progress
= 0;
829 if (!server_supports("include-tag"))
830 args
->include_tag
= 0;
831 if (server_supports("ofs-delta")) {
833 fprintf(stderr
, "Server supports ofs-delta\n");
835 prefer_ofs_delta
= 0;
837 if ((agent_feature
= server_feature_value("agent", &agent_len
))) {
839 if (args
->verbose
&& agent_len
)
840 fprintf(stderr
, "Server version is %.*s\n",
841 agent_len
, agent_feature
);
844 if (everything_local(args
, &ref
, sought
, nr_sought
)) {
848 if (find_common(args
, fd
, sha1
, ref
) < 0)
849 if (!args
->keep_pack
)
850 /* When cloning, it is not unusual to have
853 warning("no common commits");
855 if (args
->stateless_rpc
)
858 setup_alternate_shallow(&shallow_lock
, &alternate_shallow_file
,
860 else if (si
->nr_ours
|| si
->nr_theirs
)
861 alternate_shallow_file
= setup_temporary_shallow(si
->shallow
);
863 alternate_shallow_file
= NULL
;
864 if (get_pack(args
, fd
, pack_lockfile
))
865 die("git fetch-pack: fetch failed.");
871 static int fetch_pack_config(const char *var
, const char *value
, void *cb
)
873 if (strcmp(var
, "fetch.unpacklimit") == 0) {
874 fetch_unpack_limit
= git_config_int(var
, value
);
878 if (strcmp(var
, "transfer.unpacklimit") == 0) {
879 transfer_unpack_limit
= git_config_int(var
, value
);
883 if (strcmp(var
, "repack.usedeltabaseoffset") == 0) {
884 prefer_ofs_delta
= git_config_bool(var
, value
);
888 if (!strcmp(var
, "fetch.fsckobjects")) {
889 fetch_fsck_objects
= git_config_bool(var
, value
);
893 if (!strcmp(var
, "transfer.fsckobjects")) {
894 transfer_fsck_objects
= git_config_bool(var
, value
);
898 return git_default_config(var
, value
, cb
);
901 static void fetch_pack_setup(void)
903 static int did_setup
;
906 git_config(fetch_pack_config
, NULL
);
907 if (0 <= transfer_unpack_limit
)
908 unpack_limit
= transfer_unpack_limit
;
909 else if (0 <= fetch_unpack_limit
)
910 unpack_limit
= fetch_unpack_limit
;
914 static int remove_duplicates_in_refs(struct ref
**ref
, int nr
)
916 struct string_list names
= STRING_LIST_INIT_NODUP
;
919 for (src
= dst
= 0; src
< nr
; src
++) {
920 struct string_list_item
*item
;
921 item
= string_list_insert(&names
, ref
[src
]->name
);
923 continue; /* already have it */
924 item
->util
= ref
[src
];
929 for (src
= dst
; src
< nr
; src
++)
931 string_list_clear(&names
, 0);
935 static void update_shallow(struct fetch_pack_args
*args
,
936 struct ref
**sought
, int nr_sought
,
937 struct shallow_info
*si
)
939 struct sha1_array ref
= SHA1_ARRAY_INIT
;
943 if (args
->depth
> 0 && alternate_shallow_file
) {
944 if (*alternate_shallow_file
== '\0') { /* --unshallow */
945 unlink_or_warn(git_path("shallow"));
946 rollback_lock_file(&shallow_lock
);
948 commit_lock_file(&shallow_lock
);
952 if (!si
->shallow
|| !si
->shallow
->nr
)
957 * remote is shallow, but this is a clone, there are
958 * no objects in repo to worry about. Accept any
959 * shallow points that exist in the pack (iow in repo
960 * after get_pack() and reprepare_packed_git())
962 struct sha1_array extra
= SHA1_ARRAY_INIT
;
963 unsigned char (*sha1
)[20] = si
->shallow
->sha1
;
964 for (i
= 0; i
< si
->shallow
->nr
; i
++)
965 if (has_sha1_file(sha1
[i
]))
966 sha1_array_append(&extra
, sha1
[i
]);
968 setup_alternate_shallow(&shallow_lock
,
969 &alternate_shallow_file
,
971 commit_lock_file(&shallow_lock
);
973 sha1_array_clear(&extra
);
977 if (!si
->nr_ours
&& !si
->nr_theirs
)
980 remove_nonexistent_theirs_shallow(si
);
981 if (!si
->nr_ours
&& !si
->nr_theirs
)
983 for (i
= 0; i
< nr_sought
; i
++)
984 sha1_array_append(&ref
, sought
[i
]->old_sha1
);
987 if (args
->update_shallow
) {
989 * remote is also shallow, .git/shallow may be updated
990 * so all refs can be accepted. Make sure we only add
991 * shallow roots that are actually reachable from new
994 struct sha1_array extra
= SHA1_ARRAY_INIT
;
995 unsigned char (*sha1
)[20] = si
->shallow
->sha1
;
996 assign_shallow_commits_to_refs(si
, NULL
, NULL
);
997 if (!si
->nr_ours
&& !si
->nr_theirs
) {
998 sha1_array_clear(&ref
);
1001 for (i
= 0; i
< si
->nr_ours
; i
++)
1002 sha1_array_append(&extra
, sha1
[si
->ours
[i
]]);
1003 for (i
= 0; i
< si
->nr_theirs
; i
++)
1004 sha1_array_append(&extra
, sha1
[si
->theirs
[i
]]);
1005 setup_alternate_shallow(&shallow_lock
,
1006 &alternate_shallow_file
,
1008 commit_lock_file(&shallow_lock
);
1009 sha1_array_clear(&extra
);
1010 sha1_array_clear(&ref
);
1015 * remote is also shallow, check what ref is safe to update
1016 * without updating .git/shallow
1018 status
= xcalloc(nr_sought
, sizeof(*status
));
1019 assign_shallow_commits_to_refs(si
, NULL
, status
);
1020 if (si
->nr_ours
|| si
->nr_theirs
) {
1021 for (i
= 0; i
< nr_sought
; i
++)
1023 sought
[i
]->status
= REF_STATUS_REJECT_SHALLOW
;
1026 sha1_array_clear(&ref
);
1029 struct ref
*fetch_pack(struct fetch_pack_args
*args
,
1030 int fd
[], struct child_process
*conn
,
1031 const struct ref
*ref
,
1033 struct ref
**sought
, int nr_sought
,
1034 struct sha1_array
*shallow
,
1035 char **pack_lockfile
)
1037 struct ref
*ref_cpy
;
1038 struct shallow_info si
;
1042 nr_sought
= remove_duplicates_in_refs(sought
, nr_sought
);
1045 packet_flush(fd
[1]);
1046 die("no matching remote head");
1048 prepare_shallow_info(&si
, shallow
);
1049 ref_cpy
= do_fetch_pack(args
, fd
, ref
, sought
, nr_sought
,
1050 &si
, pack_lockfile
);
1051 reprepare_packed_git();
1052 update_shallow(args
, sought
, nr_sought
, &si
);
1053 clear_shallow_info(&si
);