10 #include "fetch-pack.h"
12 #include "run-command.h"
14 #include "transport.h"
16 #include "prio-queue.h"
17 #include "sha1-array.h"
19 static int transfer_unpack_limit
= -1;
20 static int fetch_unpack_limit
= -1;
21 static int unpack_limit
= 100;
22 static int prefer_ofs_delta
= 1;
24 static int fetch_fsck_objects
= -1;
25 static int transfer_fsck_objects
= -1;
26 static int agent_supported
;
27 static struct lock_file shallow_lock
;
28 static const char *alternate_shallow_file
;
30 /* Remember to update object flag allocation in object.h */
31 #define COMPLETE (1U << 0)
32 #define COMMON (1U << 1)
33 #define COMMON_REF (1U << 2)
34 #define SEEN (1U << 3)
35 #define POPPED (1U << 4)
40 * After sending this many "have"s if we do not get any new ACK , we
41 * give up traversing our history.
43 #define MAX_IN_VAIN 256
45 static struct prio_queue rev_list
= { compare_commits_by_commit_date
};
46 static int non_common_revs
, multi_ack
, use_sideband
, allow_tip_sha1_in_want
;
48 static void rev_list_push(struct commit
*commit
, int mark
)
50 if (!(commit
->object
.flags
& mark
)) {
51 commit
->object
.flags
|= mark
;
53 if (parse_commit(commit
))
56 prio_queue_put(&rev_list
, commit
);
58 if (!(commit
->object
.flags
& COMMON
))
63 static int rev_list_insert_ref(const char *refname
, const unsigned char *sha1
, int flag
, void *cb_data
)
65 struct object
*o
= deref_tag(parse_object(sha1
), refname
, 0);
67 if (o
&& o
->type
== OBJ_COMMIT
)
68 rev_list_push((struct commit
*)o
, SEEN
);
73 static int clear_marks(const char *refname
, const struct object_id
*oid
,
74 int flag
, void *cb_data
)
76 struct object
*o
= deref_tag(parse_object(oid
->hash
), refname
, 0);
78 if (o
&& o
->type
== OBJ_COMMIT
)
79 clear_commit_marks((struct commit
*)o
,
80 COMMON
| COMMON_REF
| SEEN
| POPPED
);
85 This function marks a rev and its ancestors as common.
86 In some cases, it is desirable to mark only the ancestors (for example
87 when only the server does not yet know that they are common).
90 static void mark_common(struct commit
*commit
,
91 int ancestors_only
, int dont_parse
)
93 if (commit
!= NULL
&& !(commit
->object
.flags
& COMMON
)) {
94 struct object
*o
= (struct object
*)commit
;
99 if (!(o
->flags
& SEEN
))
100 rev_list_push(commit
, SEEN
);
102 struct commit_list
*parents
;
104 if (!ancestors_only
&& !(o
->flags
& POPPED
))
106 if (!o
->parsed
&& !dont_parse
)
107 if (parse_commit(commit
))
110 for (parents
= commit
->parents
;
112 parents
= parents
->next
)
113 mark_common(parents
->item
, 0, dont_parse
);
119 Get the next rev to send, ignoring the common.
122 static const unsigned char *get_rev(void)
124 struct commit
*commit
= NULL
;
126 while (commit
== NULL
) {
128 struct commit_list
*parents
;
130 if (rev_list
.nr
== 0 || non_common_revs
== 0)
133 commit
= prio_queue_get(&rev_list
);
134 parse_commit(commit
);
135 parents
= commit
->parents
;
137 commit
->object
.flags
|= POPPED
;
138 if (!(commit
->object
.flags
& COMMON
))
141 if (commit
->object
.flags
& COMMON
) {
142 /* do not send "have", and ignore ancestors */
144 mark
= COMMON
| SEEN
;
145 } else if (commit
->object
.flags
& COMMON_REF
)
146 /* send "have", and ignore ancestors */
147 mark
= COMMON
| SEEN
;
149 /* send "have", also for its ancestors */
153 if (!(parents
->item
->object
.flags
& SEEN
))
154 rev_list_push(parents
->item
, mark
);
156 mark_common(parents
->item
, 1, 0);
157 parents
= parents
->next
;
161 return commit
->object
.sha1
;
172 static void consume_shallow_list(struct fetch_pack_args
*args
, 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 ((line
= packet_read_line(fd
, NULL
))) {
181 if (starts_with(line
, "shallow "))
183 if (starts_with(line
, "unshallow "))
185 die("git fetch-pack: expected shallow list");
190 static enum ack_type
get_ack(int fd
, unsigned char *result_sha1
)
193 char *line
= packet_read_line(fd
, &len
);
197 die("git fetch-pack: expected ACK/NAK, got EOF");
198 if (!strcmp(line
, "NAK"))
200 if (skip_prefix(line
, "ACK ", &arg
)) {
201 if (!get_sha1_hex(arg
, result_sha1
)) {
206 if (strstr(arg
, "continue"))
208 if (strstr(arg
, "common"))
210 if (strstr(arg
, "ready"))
215 die("git fetch_pack: expected ACK/NAK, got '%s'", line
);
218 static void send_request(struct fetch_pack_args
*args
,
219 int fd
, struct strbuf
*buf
)
221 if (args
->stateless_rpc
) {
222 send_sideband(fd
, -1, buf
->buf
, buf
->len
, LARGE_PACKET_MAX
);
225 write_or_die(fd
, buf
->buf
, buf
->len
);
228 static void insert_one_alternate_ref(const struct ref
*ref
, void *unused
)
230 rev_list_insert_ref(NULL
, ref
->old_sha1
, 0, NULL
);
233 #define INITIAL_FLUSH 16
234 #define PIPESAFE_FLUSH 32
235 #define LARGE_FLUSH 1024
237 static int next_flush(struct fetch_pack_args
*args
, int count
)
239 int flush_limit
= args
->stateless_rpc
? LARGE_FLUSH
: PIPESAFE_FLUSH
;
241 if (count
< flush_limit
)
244 count
+= flush_limit
;
248 static int find_common(struct fetch_pack_args
*args
,
249 int fd
[2], unsigned char *result_sha1
,
253 int count
= 0, flushes
= 0, flush_at
= INITIAL_FLUSH
, retval
;
254 const unsigned char *sha1
;
255 unsigned in_vain
= 0;
256 int got_continue
= 0;
258 struct strbuf req_buf
= STRBUF_INIT
;
259 size_t state_len
= 0;
260 struct each_ref_fn_sha1_adapter wrapped_rev_list_insert_ref
=
261 {rev_list_insert_ref
, NULL
};
263 if (args
->stateless_rpc
&& multi_ack
== 1)
264 die("--stateless-rpc requires multi_ack_detailed");
266 for_each_ref(clear_marks
, NULL
);
269 for_each_ref(each_ref_fn_adapter
, &wrapped_rev_list_insert_ref
);
270 for_each_alternate_ref(insert_one_alternate_ref
, NULL
);
273 for ( ; refs
; refs
= refs
->next
) {
274 unsigned char *remote
= refs
->old_sha1
;
275 const char *remote_hex
;
279 * If that object is complete (i.e. it is an ancestor of a
280 * local ref), we tell them we have it but do not have to
281 * tell them about its ancestors, which they already know
284 * We use lookup_object here because we are only
285 * interested in the case we *know* the object is
286 * reachable and we have already scanned it.
288 if (((o
= lookup_object(remote
)) != NULL
) &&
289 (o
->flags
& COMPLETE
)) {
293 remote_hex
= sha1_to_hex(remote
);
295 struct strbuf c
= STRBUF_INIT
;
296 if (multi_ack
== 2) strbuf_addstr(&c
, " multi_ack_detailed");
297 if (multi_ack
== 1) strbuf_addstr(&c
, " multi_ack");
298 if (no_done
) strbuf_addstr(&c
, " no-done");
299 if (use_sideband
== 2) strbuf_addstr(&c
, " side-band-64k");
300 if (use_sideband
== 1) strbuf_addstr(&c
, " side-band");
301 if (args
->use_thin_pack
) strbuf_addstr(&c
, " thin-pack");
302 if (args
->no_progress
) strbuf_addstr(&c
, " no-progress");
303 if (args
->include_tag
) strbuf_addstr(&c
, " include-tag");
304 if (prefer_ofs_delta
) strbuf_addstr(&c
, " ofs-delta");
305 if (agent_supported
) strbuf_addf(&c
, " agent=%s",
306 git_user_agent_sanitized());
307 packet_buf_write(&req_buf
, "want %s%s\n", remote_hex
, c
.buf
);
310 packet_buf_write(&req_buf
, "want %s\n", remote_hex
);
315 strbuf_release(&req_buf
);
320 if (is_repository_shallow())
321 write_shallow_commits(&req_buf
, 1, NULL
);
323 packet_buf_write(&req_buf
, "deepen %d", args
->depth
);
324 packet_buf_flush(&req_buf
);
325 state_len
= req_buf
.len
;
327 if (args
->depth
> 0) {
330 unsigned char sha1
[20];
332 send_request(args
, fd
[1], &req_buf
);
333 while ((line
= packet_read_line(fd
[0], NULL
))) {
334 if (skip_prefix(line
, "shallow ", &arg
)) {
335 if (get_sha1_hex(arg
, sha1
))
336 die("invalid shallow line: %s", line
);
337 register_shallow(sha1
);
340 if (skip_prefix(line
, "unshallow ", &arg
)) {
341 if (get_sha1_hex(arg
, sha1
))
342 die("invalid unshallow line: %s", line
);
343 if (!lookup_object(sha1
))
344 die("object not found: %s", line
);
345 /* make sure that it is parsed as shallow */
346 if (!parse_object(sha1
))
347 die("error in object: %s", line
);
348 if (unregister_shallow(sha1
))
349 die("no shallow found: %s", line
);
352 die("expected shallow/unshallow, got %s", line
);
354 } else if (!args
->stateless_rpc
)
355 send_request(args
, fd
[1], &req_buf
);
357 if (!args
->stateless_rpc
) {
358 /* If we aren't using the stateless-rpc interface
359 * we don't need to retain the headers.
361 strbuf_setlen(&req_buf
, 0);
367 while ((sha1
= get_rev())) {
368 packet_buf_write(&req_buf
, "have %s\n", sha1_to_hex(sha1
));
370 fprintf(stderr
, "have %s\n", sha1_to_hex(sha1
));
372 if (flush_at
<= ++count
) {
375 packet_buf_flush(&req_buf
);
376 send_request(args
, fd
[1], &req_buf
);
377 strbuf_setlen(&req_buf
, state_len
);
379 flush_at
= next_flush(args
, count
);
382 * We keep one window "ahead" of the other side, and
383 * will wait for an ACK only on the next one
385 if (!args
->stateless_rpc
&& count
== INITIAL_FLUSH
)
388 consume_shallow_list(args
, fd
[0]);
390 ack
= get_ack(fd
[0], result_sha1
);
391 if (args
->verbose
&& ack
)
392 fprintf(stderr
, "got ack %d %s\n", ack
,
393 sha1_to_hex(result_sha1
));
403 struct commit
*commit
=
404 lookup_commit(result_sha1
);
406 die("invalid commit %s", sha1_to_hex(result_sha1
));
407 if (args
->stateless_rpc
409 && !(commit
->object
.flags
& COMMON
)) {
410 /* We need to replay the have for this object
411 * on the next RPC request so the peer knows
412 * it is in common with us.
414 const char *hex
= sha1_to_hex(result_sha1
);
415 packet_buf_write(&req_buf
, "have %s\n", hex
);
416 state_len
= req_buf
.len
;
418 mark_common(commit
, 0, 1);
422 if (ack
== ACK_ready
) {
423 clear_prio_queue(&rev_list
);
431 if (got_continue
&& MAX_IN_VAIN
< in_vain
) {
433 fprintf(stderr
, "giving up\n");
439 if (!got_ready
|| !no_done
) {
440 packet_buf_write(&req_buf
, "done\n");
441 send_request(args
, fd
[1], &req_buf
);
444 fprintf(stderr
, "done\n");
449 strbuf_release(&req_buf
);
451 if (!got_ready
|| !no_done
)
452 consume_shallow_list(args
, fd
[0]);
453 while (flushes
|| multi_ack
) {
454 int ack
= get_ack(fd
[0], result_sha1
);
457 fprintf(stderr
, "got ack (%d) %s\n", ack
,
458 sha1_to_hex(result_sha1
));
466 /* it is no error to fetch into a completely empty repo */
467 return count
? retval
: 0;
470 static struct commit_list
*complete
;
472 static int mark_complete(const char *refname
, const unsigned char *sha1
, int flag
, void *cb_data
)
474 struct object
*o
= parse_object(sha1
);
476 while (o
&& o
->type
== OBJ_TAG
) {
477 struct tag
*t
= (struct tag
*) o
;
479 break; /* broken repository */
480 o
->flags
|= COMPLETE
;
481 o
= parse_object(t
->tagged
->sha1
);
483 if (o
&& o
->type
== OBJ_COMMIT
) {
484 struct commit
*commit
= (struct commit
*)o
;
485 if (!(commit
->object
.flags
& COMPLETE
)) {
486 commit
->object
.flags
|= COMPLETE
;
487 commit_list_insert(commit
, &complete
);
493 static void mark_recent_complete_commits(struct fetch_pack_args
*args
,
494 unsigned long cutoff
)
496 while (complete
&& cutoff
<= complete
->item
->date
) {
498 fprintf(stderr
, "Marking %s as complete\n",
499 sha1_to_hex(complete
->item
->object
.sha1
));
500 pop_most_recent_commit(&complete
, COMPLETE
);
504 static void filter_refs(struct fetch_pack_args
*args
,
506 struct ref
**sought
, int nr_sought
)
508 struct ref
*newlist
= NULL
;
509 struct ref
**newtail
= &newlist
;
510 struct ref
*ref
, *next
;
514 for (ref
= *refs
; ref
; ref
= next
) {
518 if (starts_with(ref
->name
, "refs/") &&
519 check_refname_format(ref
->name
, 0))
522 while (i
< nr_sought
) {
523 int cmp
= strcmp(ref
->name
, sought
[i
]->name
);
525 break; /* definitely do not have it */
527 keep
= 1; /* definitely have it */
528 sought
[i
]->matched
= 1;
534 if (!keep
&& args
->fetch_all
&&
535 (!args
->depth
|| !starts_with(ref
->name
, "refs/tags/")))
541 newtail
= &ref
->next
;
547 /* Append unmatched requests to the list */
548 if (allow_tip_sha1_in_want
) {
549 for (i
= 0; i
< nr_sought
; i
++) {
550 unsigned char sha1
[20];
555 if (get_sha1_hex(ref
->name
, sha1
) ||
556 ref
->name
[40] != '\0' ||
557 hashcmp(sha1
, ref
->old_sha1
))
561 *newtail
= copy_ref(ref
);
562 newtail
= &(*newtail
)->next
;
568 static void mark_alternate_complete(const struct ref
*ref
, void *unused
)
570 mark_complete(NULL
, ref
->old_sha1
, 0, NULL
);
573 static int everything_local(struct fetch_pack_args
*args
,
575 struct ref
**sought
, int nr_sought
)
579 unsigned long cutoff
= 0;
581 save_commit_buffer
= 0;
583 for (ref
= *refs
; ref
; ref
= ref
->next
) {
586 if (!has_sha1_file(ref
->old_sha1
))
589 o
= parse_object(ref
->old_sha1
);
593 /* We already have it -- which may mean that we were
594 * in sync with the other side at some time after
595 * that (it is OK if we guess wrong here).
597 if (o
->type
== OBJ_COMMIT
) {
598 struct commit
*commit
= (struct commit
*)o
;
599 if (!cutoff
|| cutoff
< commit
->date
)
600 cutoff
= commit
->date
;
605 struct each_ref_fn_sha1_adapter wrapped_mark_complete
=
606 {mark_complete
, NULL
};
608 for_each_ref(each_ref_fn_adapter
, &wrapped_mark_complete
);
609 for_each_alternate_ref(mark_alternate_complete
, NULL
);
610 commit_list_sort_by_date(&complete
);
612 mark_recent_complete_commits(args
, cutoff
);
616 * Mark all complete remote refs as common refs.
617 * Don't mark them common yet; the server has to be told so first.
619 for (ref
= *refs
; ref
; ref
= ref
->next
) {
620 struct object
*o
= deref_tag(lookup_object(ref
->old_sha1
),
623 if (!o
|| o
->type
!= OBJ_COMMIT
|| !(o
->flags
& COMPLETE
))
626 if (!(o
->flags
& SEEN
)) {
627 rev_list_push((struct commit
*)o
, COMMON_REF
| SEEN
);
629 mark_common((struct commit
*)o
, 1, 1);
633 filter_refs(args
, refs
, sought
, nr_sought
);
635 for (retval
= 1, ref
= *refs
; ref
; ref
= ref
->next
) {
636 const unsigned char *remote
= ref
->old_sha1
;
639 o
= lookup_object(remote
);
640 if (!o
|| !(o
->flags
& COMPLETE
)) {
645 "want %s (%s)\n", sha1_to_hex(remote
),
652 "already have %s (%s)\n", sha1_to_hex(remote
),
658 static int sideband_demux(int in
, int out
, void *data
)
662 int ret
= recv_sideband("fetch-pack", xd
[0], out
);
667 static int get_pack(struct fetch_pack_args
*args
,
668 int xd
[2], char **pack_lockfile
)
671 const char *argv
[22];
674 const char **av
, *cmd_name
;
675 int do_keep
= args
->keep_pack
;
676 struct child_process cmd
= CHILD_PROCESS_INIT
;
679 memset(&demux
, 0, sizeof(demux
));
681 /* xd[] is talking with upload-pack; subprocess reads from
682 * xd[0], spits out band#2 to stderr, and feeds us band#1
683 * through demux->out.
685 demux
.proc
= sideband_demux
;
688 if (start_async(&demux
))
689 die("fetch-pack: unable to fork off sideband"
698 if (!args
->keep_pack
&& unpack_limit
) {
699 struct pack_header header
;
701 if (read_pack_header(demux
.out
, &header
))
702 die("protocol error: bad pack header");
703 snprintf(hdr_arg
, sizeof(hdr_arg
),
704 "--pack_header=%"PRIu32
",%"PRIu32
,
705 ntohl(header
.hdr_version
), ntohl(header
.hdr_entries
));
706 if (ntohl(header
.hdr_entries
) < unpack_limit
)
712 if (alternate_shallow_file
) {
713 *av
++ = "--shallow-file";
714 *av
++ = alternate_shallow_file
;
720 *av
++ = cmd_name
= "index-pack";
722 if (!args
->quiet
&& !args
->no_progress
)
724 if (args
->use_thin_pack
)
725 *av
++ = "--fix-thin";
726 if (args
->lock_pack
|| unpack_limit
) {
727 int s
= sprintf(keep_arg
,
728 "--keep=fetch-pack %"PRIuMAX
" on ", (uintmax_t) getpid());
729 if (gethostname(keep_arg
+ s
, sizeof(keep_arg
) - s
))
730 strcpy(keep_arg
+ s
, "localhost");
733 if (args
->check_self_contained_and_connected
)
734 *av
++ = "--check-self-contained-and-connected";
737 *av
++ = cmd_name
= "unpack-objects";
738 if (args
->quiet
|| args
->no_progress
)
740 args
->check_self_contained_and_connected
= 0;
744 if (fetch_fsck_objects
>= 0
746 : transfer_fsck_objects
>= 0
747 ? transfer_fsck_objects
754 if (start_command(&cmd
))
755 die("fetch-pack: unable to fork off %s", cmd_name
);
756 if (do_keep
&& pack_lockfile
) {
757 *pack_lockfile
= index_pack_lockfile(cmd
.out
);
762 /* Closed by start_command() */
765 ret
= finish_command(&cmd
);
766 if (!ret
|| (args
->check_self_contained_and_connected
&& ret
== 1))
767 args
->self_contained_and_connected
=
768 args
->check_self_contained_and_connected
&&
771 die("%s failed", cmd_name
);
772 if (use_sideband
&& finish_async(&demux
))
773 die("error in sideband demultiplexer");
777 static int cmp_ref_by_name(const void *a_
, const void *b_
)
779 const struct ref
*a
= *((const struct ref
**)a_
);
780 const struct ref
*b
= *((const struct ref
**)b_
);
781 return strcmp(a
->name
, b
->name
);
784 static struct ref
*do_fetch_pack(struct fetch_pack_args
*args
,
786 const struct ref
*orig_ref
,
787 struct ref
**sought
, int nr_sought
,
788 struct shallow_info
*si
,
789 char **pack_lockfile
)
791 struct ref
*ref
= copy_ref_list(orig_ref
);
792 unsigned char sha1
[20];
793 const char *agent_feature
;
796 sort_ref_list(&ref
, ref_compare_name
);
797 qsort(sought
, nr_sought
, sizeof(*sought
), cmp_ref_by_name
);
799 if (is_repository_shallow() && !server_supports("shallow"))
800 die("Server does not support shallow clients");
801 if (server_supports("multi_ack_detailed")) {
803 fprintf(stderr
, "Server supports multi_ack_detailed\n");
805 if (server_supports("no-done")) {
807 fprintf(stderr
, "Server supports no-done\n");
808 if (args
->stateless_rpc
)
812 else if (server_supports("multi_ack")) {
814 fprintf(stderr
, "Server supports multi_ack\n");
817 if (server_supports("side-band-64k")) {
819 fprintf(stderr
, "Server supports side-band-64k\n");
822 else if (server_supports("side-band")) {
824 fprintf(stderr
, "Server supports side-band\n");
827 if (server_supports("allow-tip-sha1-in-want")) {
829 fprintf(stderr
, "Server supports allow-tip-sha1-in-want\n");
830 allow_tip_sha1_in_want
= 1;
832 if (!server_supports("thin-pack"))
833 args
->use_thin_pack
= 0;
834 if (!server_supports("no-progress"))
835 args
->no_progress
= 0;
836 if (!server_supports("include-tag"))
837 args
->include_tag
= 0;
838 if (server_supports("ofs-delta")) {
840 fprintf(stderr
, "Server supports ofs-delta\n");
842 prefer_ofs_delta
= 0;
844 if ((agent_feature
= server_feature_value("agent", &agent_len
))) {
846 if (args
->verbose
&& agent_len
)
847 fprintf(stderr
, "Server version is %.*s\n",
848 agent_len
, agent_feature
);
851 if (everything_local(args
, &ref
, sought
, nr_sought
)) {
855 if (find_common(args
, fd
, sha1
, ref
) < 0)
856 if (!args
->keep_pack
)
857 /* When cloning, it is not unusual to have
860 warning("no common commits");
862 if (args
->stateless_rpc
)
865 setup_alternate_shallow(&shallow_lock
, &alternate_shallow_file
,
867 else if (si
->nr_ours
|| si
->nr_theirs
)
868 alternate_shallow_file
= setup_temporary_shallow(si
->shallow
);
870 alternate_shallow_file
= NULL
;
871 if (get_pack(args
, fd
, pack_lockfile
))
872 die("git fetch-pack: fetch failed.");
878 static void fetch_pack_config(void)
880 git_config_get_int("fetch.unpacklimit", &fetch_unpack_limit
);
881 git_config_get_int("transfer.unpacklimit", &transfer_unpack_limit
);
882 git_config_get_bool("repack.usedeltabaseoffset", &prefer_ofs_delta
);
883 git_config_get_bool("fetch.fsckobjects", &fetch_fsck_objects
);
884 git_config_get_bool("transfer.fsckobjects", &transfer_fsck_objects
);
886 git_config(git_default_config
, NULL
);
889 static void fetch_pack_setup(void)
891 static int did_setup
;
895 if (0 <= transfer_unpack_limit
)
896 unpack_limit
= transfer_unpack_limit
;
897 else if (0 <= fetch_unpack_limit
)
898 unpack_limit
= fetch_unpack_limit
;
902 static int remove_duplicates_in_refs(struct ref
**ref
, int nr
)
904 struct string_list names
= STRING_LIST_INIT_NODUP
;
907 for (src
= dst
= 0; src
< nr
; src
++) {
908 struct string_list_item
*item
;
909 item
= string_list_insert(&names
, ref
[src
]->name
);
911 continue; /* already have it */
912 item
->util
= ref
[src
];
917 for (src
= dst
; src
< nr
; src
++)
919 string_list_clear(&names
, 0);
923 static void update_shallow(struct fetch_pack_args
*args
,
924 struct ref
**sought
, int nr_sought
,
925 struct shallow_info
*si
)
927 struct sha1_array ref
= SHA1_ARRAY_INIT
;
931 if (args
->depth
> 0 && alternate_shallow_file
) {
932 if (*alternate_shallow_file
== '\0') { /* --unshallow */
933 unlink_or_warn(git_path("shallow"));
934 rollback_lock_file(&shallow_lock
);
936 commit_lock_file(&shallow_lock
);
940 if (!si
->shallow
|| !si
->shallow
->nr
)
945 * remote is shallow, but this is a clone, there are
946 * no objects in repo to worry about. Accept any
947 * shallow points that exist in the pack (iow in repo
948 * after get_pack() and reprepare_packed_git())
950 struct sha1_array extra
= SHA1_ARRAY_INIT
;
951 unsigned char (*sha1
)[20] = si
->shallow
->sha1
;
952 for (i
= 0; i
< si
->shallow
->nr
; i
++)
953 if (has_sha1_file(sha1
[i
]))
954 sha1_array_append(&extra
, sha1
[i
]);
956 setup_alternate_shallow(&shallow_lock
,
957 &alternate_shallow_file
,
959 commit_lock_file(&shallow_lock
);
961 sha1_array_clear(&extra
);
965 if (!si
->nr_ours
&& !si
->nr_theirs
)
968 remove_nonexistent_theirs_shallow(si
);
969 if (!si
->nr_ours
&& !si
->nr_theirs
)
971 for (i
= 0; i
< nr_sought
; i
++)
972 sha1_array_append(&ref
, sought
[i
]->old_sha1
);
975 if (args
->update_shallow
) {
977 * remote is also shallow, .git/shallow may be updated
978 * so all refs can be accepted. Make sure we only add
979 * shallow roots that are actually reachable from new
982 struct sha1_array extra
= SHA1_ARRAY_INIT
;
983 unsigned char (*sha1
)[20] = si
->shallow
->sha1
;
984 assign_shallow_commits_to_refs(si
, NULL
, NULL
);
985 if (!si
->nr_ours
&& !si
->nr_theirs
) {
986 sha1_array_clear(&ref
);
989 for (i
= 0; i
< si
->nr_ours
; i
++)
990 sha1_array_append(&extra
, sha1
[si
->ours
[i
]]);
991 for (i
= 0; i
< si
->nr_theirs
; i
++)
992 sha1_array_append(&extra
, sha1
[si
->theirs
[i
]]);
993 setup_alternate_shallow(&shallow_lock
,
994 &alternate_shallow_file
,
996 commit_lock_file(&shallow_lock
);
997 sha1_array_clear(&extra
);
998 sha1_array_clear(&ref
);
1003 * remote is also shallow, check what ref is safe to update
1004 * without updating .git/shallow
1006 status
= xcalloc(nr_sought
, sizeof(*status
));
1007 assign_shallow_commits_to_refs(si
, NULL
, status
);
1008 if (si
->nr_ours
|| si
->nr_theirs
) {
1009 for (i
= 0; i
< nr_sought
; i
++)
1011 sought
[i
]->status
= REF_STATUS_REJECT_SHALLOW
;
1014 sha1_array_clear(&ref
);
1017 struct ref
*fetch_pack(struct fetch_pack_args
*args
,
1018 int fd
[], struct child_process
*conn
,
1019 const struct ref
*ref
,
1021 struct ref
**sought
, int nr_sought
,
1022 struct sha1_array
*shallow
,
1023 char **pack_lockfile
)
1025 struct ref
*ref_cpy
;
1026 struct shallow_info si
;
1030 nr_sought
= remove_duplicates_in_refs(sought
, nr_sought
);
1033 packet_flush(fd
[1]);
1034 die("no matching remote head");
1036 prepare_shallow_info(&si
, shallow
);
1037 ref_cpy
= do_fetch_pack(args
, fd
, ref
, sought
, nr_sought
,
1038 &si
, pack_lockfile
);
1039 reprepare_packed_git();
1040 update_shallow(args
, sought
, nr_sought
, &si
);
1041 clear_shallow_info(&si
);