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 deepen_since_ok
;
25 static int fetch_fsck_objects
= -1;
26 static int transfer_fsck_objects
= -1;
27 static int agent_supported
;
28 static struct lock_file shallow_lock
;
29 static const char *alternate_shallow_file
;
31 /* Remember to update object flag allocation in object.h */
32 #define COMPLETE (1U << 0)
33 #define COMMON (1U << 1)
34 #define COMMON_REF (1U << 2)
35 #define SEEN (1U << 3)
36 #define POPPED (1U << 4)
41 * After sending this many "have"s if we do not get any new ACK , we
42 * give up traversing our history.
44 #define MAX_IN_VAIN 256
46 static struct prio_queue rev_list
= { compare_commits_by_commit_date
};
47 static int non_common_revs
, multi_ack
, use_sideband
;
48 /* Allow specifying sha1 if it is a ref tip. */
49 #define ALLOW_TIP_SHA1 01
50 /* Allow request of a sha1 if it is reachable from a ref (possibly hidden ref). */
51 #define ALLOW_REACHABLE_SHA1 02
52 static unsigned int allow_unadvertised_object_request
;
54 __attribute__((format (printf
, 2, 3)))
55 static inline void print_verbose(const struct fetch_pack_args
*args
,
63 va_start(params
, fmt
);
64 vfprintf(stderr
, fmt
, params
);
69 static void rev_list_push(struct commit
*commit
, int mark
)
71 if (!(commit
->object
.flags
& mark
)) {
72 commit
->object
.flags
|= mark
;
74 if (parse_commit(commit
))
77 prio_queue_put(&rev_list
, commit
);
79 if (!(commit
->object
.flags
& COMMON
))
84 static int rev_list_insert_ref(const char *refname
, const unsigned char *sha1
)
86 struct object
*o
= deref_tag(parse_object(sha1
), refname
, 0);
88 if (o
&& o
->type
== OBJ_COMMIT
)
89 rev_list_push((struct commit
*)o
, SEEN
);
94 static int rev_list_insert_ref_oid(const char *refname
, const struct object_id
*oid
,
95 int flag
, void *cb_data
)
97 return rev_list_insert_ref(refname
, oid
->hash
);
100 static int clear_marks(const char *refname
, const struct object_id
*oid
,
101 int flag
, void *cb_data
)
103 struct object
*o
= deref_tag(parse_object(oid
->hash
), refname
, 0);
105 if (o
&& o
->type
== OBJ_COMMIT
)
106 clear_commit_marks((struct commit
*)o
,
107 COMMON
| COMMON_REF
| SEEN
| POPPED
);
112 This function marks a rev and its ancestors as common.
113 In some cases, it is desirable to mark only the ancestors (for example
114 when only the server does not yet know that they are common).
117 static void mark_common(struct commit
*commit
,
118 int ancestors_only
, int dont_parse
)
120 if (commit
!= NULL
&& !(commit
->object
.flags
& COMMON
)) {
121 struct object
*o
= (struct object
*)commit
;
126 if (!(o
->flags
& SEEN
))
127 rev_list_push(commit
, SEEN
);
129 struct commit_list
*parents
;
131 if (!ancestors_only
&& !(o
->flags
& POPPED
))
133 if (!o
->parsed
&& !dont_parse
)
134 if (parse_commit(commit
))
137 for (parents
= commit
->parents
;
139 parents
= parents
->next
)
140 mark_common(parents
->item
, 0, dont_parse
);
146 Get the next rev to send, ignoring the common.
149 static const unsigned char *get_rev(void)
151 struct commit
*commit
= NULL
;
153 while (commit
== NULL
) {
155 struct commit_list
*parents
;
157 if (rev_list
.nr
== 0 || non_common_revs
== 0)
160 commit
= prio_queue_get(&rev_list
);
161 parse_commit(commit
);
162 parents
= commit
->parents
;
164 commit
->object
.flags
|= POPPED
;
165 if (!(commit
->object
.flags
& COMMON
))
168 if (commit
->object
.flags
& COMMON
) {
169 /* do not send "have", and ignore ancestors */
171 mark
= COMMON
| SEEN
;
172 } else if (commit
->object
.flags
& COMMON_REF
)
173 /* send "have", and ignore ancestors */
174 mark
= COMMON
| SEEN
;
176 /* send "have", also for its ancestors */
180 if (!(parents
->item
->object
.flags
& SEEN
))
181 rev_list_push(parents
->item
, mark
);
183 mark_common(parents
->item
, 1, 0);
184 parents
= parents
->next
;
188 return commit
->object
.oid
.hash
;
199 static void consume_shallow_list(struct fetch_pack_args
*args
, int fd
)
201 if (args
->stateless_rpc
&& args
->deepen
) {
202 /* If we sent a depth we will get back "duplicate"
203 * shallow and unshallow commands every time there
204 * is a block of have lines exchanged.
207 while ((line
= packet_read_line(fd
, NULL
))) {
208 if (starts_with(line
, "shallow "))
210 if (starts_with(line
, "unshallow "))
212 die(_("git fetch-pack: expected shallow list"));
217 static enum ack_type
get_ack(int fd
, unsigned char *result_sha1
)
220 char *line
= packet_read_line(fd
, &len
);
224 die(_("git fetch-pack: expected ACK/NAK, got EOF"));
225 if (!strcmp(line
, "NAK"))
227 if (skip_prefix(line
, "ACK ", &arg
)) {
228 if (!get_sha1_hex(arg
, result_sha1
)) {
233 if (strstr(arg
, "continue"))
235 if (strstr(arg
, "common"))
237 if (strstr(arg
, "ready"))
242 die(_("git fetch_pack: expected ACK/NAK, got '%s'"), line
);
245 static void send_request(struct fetch_pack_args
*args
,
246 int fd
, struct strbuf
*buf
)
248 if (args
->stateless_rpc
) {
249 send_sideband(fd
, -1, buf
->buf
, buf
->len
, LARGE_PACKET_MAX
);
252 write_or_die(fd
, buf
->buf
, buf
->len
);
255 static void insert_one_alternate_ref(const struct ref
*ref
, void *unused
)
257 rev_list_insert_ref(NULL
, ref
->old_oid
.hash
);
260 #define INITIAL_FLUSH 16
261 #define PIPESAFE_FLUSH 32
262 #define LARGE_FLUSH 1024
264 static int next_flush(struct fetch_pack_args
*args
, int count
)
266 int flush_limit
= args
->stateless_rpc
? LARGE_FLUSH
: PIPESAFE_FLUSH
;
268 if (count
< flush_limit
)
271 count
+= flush_limit
;
275 static int find_common(struct fetch_pack_args
*args
,
276 int fd
[2], unsigned char *result_sha1
,
280 int count
= 0, flushes
= 0, flush_at
= INITIAL_FLUSH
, retval
;
281 const unsigned char *sha1
;
282 unsigned in_vain
= 0;
283 int got_continue
= 0;
285 struct strbuf req_buf
= STRBUF_INIT
;
286 size_t state_len
= 0;
288 if (args
->stateless_rpc
&& multi_ack
== 1)
289 die(_("--stateless-rpc requires multi_ack_detailed"));
291 for_each_ref(clear_marks
, NULL
);
294 for_each_ref(rev_list_insert_ref_oid
, NULL
);
295 for_each_alternate_ref(insert_one_alternate_ref
, NULL
);
298 for ( ; refs
; refs
= refs
->next
) {
299 unsigned char *remote
= refs
->old_oid
.hash
;
300 const char *remote_hex
;
304 * If that object is complete (i.e. it is an ancestor of a
305 * local ref), we tell them we have it but do not have to
306 * tell them about its ancestors, which they already know
309 * We use lookup_object here because we are only
310 * interested in the case we *know* the object is
311 * reachable and we have already scanned it.
313 if (((o
= lookup_object(remote
)) != NULL
) &&
314 (o
->flags
& COMPLETE
)) {
318 remote_hex
= sha1_to_hex(remote
);
320 struct strbuf c
= STRBUF_INIT
;
321 if (multi_ack
== 2) strbuf_addstr(&c
, " multi_ack_detailed");
322 if (multi_ack
== 1) strbuf_addstr(&c
, " multi_ack");
323 if (no_done
) strbuf_addstr(&c
, " no-done");
324 if (use_sideband
== 2) strbuf_addstr(&c
, " side-band-64k");
325 if (use_sideband
== 1) strbuf_addstr(&c
, " side-band");
326 if (args
->use_thin_pack
) strbuf_addstr(&c
, " thin-pack");
327 if (args
->no_progress
) strbuf_addstr(&c
, " no-progress");
328 if (args
->include_tag
) strbuf_addstr(&c
, " include-tag");
329 if (prefer_ofs_delta
) strbuf_addstr(&c
, " ofs-delta");
330 if (deepen_since_ok
) strbuf_addstr(&c
, " deepen-since");
331 if (agent_supported
) strbuf_addf(&c
, " agent=%s",
332 git_user_agent_sanitized());
333 packet_buf_write(&req_buf
, "want %s%s\n", remote_hex
, c
.buf
);
336 packet_buf_write(&req_buf
, "want %s\n", remote_hex
);
341 strbuf_release(&req_buf
);
346 if (is_repository_shallow())
347 write_shallow_commits(&req_buf
, 1, NULL
);
349 packet_buf_write(&req_buf
, "deepen %d", args
->depth
);
350 if (args
->deepen_since
) {
351 unsigned long max_age
= approxidate(args
->deepen_since
);
352 packet_buf_write(&req_buf
, "deepen-since %lu", max_age
);
354 packet_buf_flush(&req_buf
);
355 state_len
= req_buf
.len
;
360 unsigned char sha1
[20];
362 send_request(args
, fd
[1], &req_buf
);
363 while ((line
= packet_read_line(fd
[0], NULL
))) {
364 if (skip_prefix(line
, "shallow ", &arg
)) {
365 if (get_sha1_hex(arg
, sha1
))
366 die(_("invalid shallow line: %s"), line
);
367 register_shallow(sha1
);
370 if (skip_prefix(line
, "unshallow ", &arg
)) {
371 if (get_sha1_hex(arg
, sha1
))
372 die(_("invalid unshallow line: %s"), line
);
373 if (!lookup_object(sha1
))
374 die(_("object not found: %s"), line
);
375 /* make sure that it is parsed as shallow */
376 if (!parse_object(sha1
))
377 die(_("error in object: %s"), line
);
378 if (unregister_shallow(sha1
))
379 die(_("no shallow found: %s"), line
);
382 die(_("expected shallow/unshallow, got %s"), line
);
384 } else if (!args
->stateless_rpc
)
385 send_request(args
, fd
[1], &req_buf
);
387 if (!args
->stateless_rpc
) {
388 /* If we aren't using the stateless-rpc interface
389 * we don't need to retain the headers.
391 strbuf_setlen(&req_buf
, 0);
397 while ((sha1
= get_rev())) {
398 packet_buf_write(&req_buf
, "have %s\n", sha1_to_hex(sha1
));
399 print_verbose(args
, "have %s", sha1_to_hex(sha1
));
401 if (flush_at
<= ++count
) {
404 packet_buf_flush(&req_buf
);
405 send_request(args
, fd
[1], &req_buf
);
406 strbuf_setlen(&req_buf
, state_len
);
408 flush_at
= next_flush(args
, count
);
411 * We keep one window "ahead" of the other side, and
412 * will wait for an ACK only on the next one
414 if (!args
->stateless_rpc
&& count
== INITIAL_FLUSH
)
417 consume_shallow_list(args
, fd
[0]);
419 ack
= get_ack(fd
[0], result_sha1
);
421 print_verbose(args
, _("got %s %d %s"), "ack",
422 ack
, sha1_to_hex(result_sha1
));
432 struct commit
*commit
=
433 lookup_commit(result_sha1
);
435 die(_("invalid commit %s"), sha1_to_hex(result_sha1
));
436 if (args
->stateless_rpc
438 && !(commit
->object
.flags
& COMMON
)) {
439 /* We need to replay the have for this object
440 * on the next RPC request so the peer knows
441 * it is in common with us.
443 const char *hex
= sha1_to_hex(result_sha1
);
444 packet_buf_write(&req_buf
, "have %s\n", hex
);
445 state_len
= req_buf
.len
;
447 mark_common(commit
, 0, 1);
451 if (ack
== ACK_ready
) {
452 clear_prio_queue(&rev_list
);
460 if (got_continue
&& MAX_IN_VAIN
< in_vain
) {
461 print_verbose(args
, _("giving up"));
467 if (!got_ready
|| !no_done
) {
468 packet_buf_write(&req_buf
, "done\n");
469 send_request(args
, fd
[1], &req_buf
);
471 print_verbose(args
, _("done"));
476 strbuf_release(&req_buf
);
478 if (!got_ready
|| !no_done
)
479 consume_shallow_list(args
, fd
[0]);
480 while (flushes
|| multi_ack
) {
481 int ack
= get_ack(fd
[0], result_sha1
);
483 print_verbose(args
, _("got %s (%d) %s"), "ack",
484 ack
, sha1_to_hex(result_sha1
));
492 /* it is no error to fetch into a completely empty repo */
493 return count
? retval
: 0;
496 static struct commit_list
*complete
;
498 static int mark_complete(const unsigned char *sha1
)
500 struct object
*o
= parse_object(sha1
);
502 while (o
&& o
->type
== OBJ_TAG
) {
503 struct tag
*t
= (struct tag
*) o
;
505 break; /* broken repository */
506 o
->flags
|= COMPLETE
;
507 o
= parse_object(t
->tagged
->oid
.hash
);
509 if (o
&& o
->type
== OBJ_COMMIT
) {
510 struct commit
*commit
= (struct commit
*)o
;
511 if (!(commit
->object
.flags
& COMPLETE
)) {
512 commit
->object
.flags
|= COMPLETE
;
513 commit_list_insert(commit
, &complete
);
519 static int mark_complete_oid(const char *refname
, const struct object_id
*oid
,
520 int flag
, void *cb_data
)
522 return mark_complete(oid
->hash
);
525 static void mark_recent_complete_commits(struct fetch_pack_args
*args
,
526 unsigned long cutoff
)
528 while (complete
&& cutoff
<= complete
->item
->date
) {
529 print_verbose(args
, _("Marking %s as complete"),
530 oid_to_hex(&complete
->item
->object
.oid
));
531 pop_most_recent_commit(&complete
, COMPLETE
);
535 static void filter_refs(struct fetch_pack_args
*args
,
537 struct ref
**sought
, int nr_sought
)
539 struct ref
*newlist
= NULL
;
540 struct ref
**newtail
= &newlist
;
541 struct ref
*ref
, *next
;
545 for (ref
= *refs
; ref
; ref
= next
) {
549 if (starts_with(ref
->name
, "refs/") &&
550 check_refname_format(ref
->name
, 0))
553 while (i
< nr_sought
) {
554 int cmp
= strcmp(ref
->name
, sought
[i
]->name
);
556 break; /* definitely do not have it */
558 keep
= 1; /* definitely have it */
559 sought
[i
]->matched
= 1;
565 if (!keep
&& args
->fetch_all
&&
566 (!args
->deepen
|| !starts_with(ref
->name
, "refs/tags/")))
572 newtail
= &ref
->next
;
578 /* Append unmatched requests to the list */
579 if ((allow_unadvertised_object_request
&
580 (ALLOW_TIP_SHA1
| ALLOW_REACHABLE_SHA1
))) {
581 for (i
= 0; i
< nr_sought
; i
++) {
582 unsigned char sha1
[20];
587 if (get_sha1_hex(ref
->name
, sha1
) ||
588 ref
->name
[40] != '\0' ||
589 hashcmp(sha1
, ref
->old_oid
.hash
))
593 *newtail
= copy_ref(ref
);
594 newtail
= &(*newtail
)->next
;
600 static void mark_alternate_complete(const struct ref
*ref
, void *unused
)
602 mark_complete(ref
->old_oid
.hash
);
605 static int everything_local(struct fetch_pack_args
*args
,
607 struct ref
**sought
, int nr_sought
)
611 unsigned long cutoff
= 0;
613 save_commit_buffer
= 0;
615 for (ref
= *refs
; ref
; ref
= ref
->next
) {
618 if (!has_object_file(&ref
->old_oid
))
621 o
= parse_object(ref
->old_oid
.hash
);
625 /* We already have it -- which may mean that we were
626 * in sync with the other side at some time after
627 * that (it is OK if we guess wrong here).
629 if (o
->type
== OBJ_COMMIT
) {
630 struct commit
*commit
= (struct commit
*)o
;
631 if (!cutoff
|| cutoff
< commit
->date
)
632 cutoff
= commit
->date
;
637 for_each_ref(mark_complete_oid
, NULL
);
638 for_each_alternate_ref(mark_alternate_complete
, NULL
);
639 commit_list_sort_by_date(&complete
);
641 mark_recent_complete_commits(args
, cutoff
);
645 * Mark all complete remote refs as common refs.
646 * Don't mark them common yet; the server has to be told so first.
648 for (ref
= *refs
; ref
; ref
= ref
->next
) {
649 struct object
*o
= deref_tag(lookup_object(ref
->old_oid
.hash
),
652 if (!o
|| o
->type
!= OBJ_COMMIT
|| !(o
->flags
& COMPLETE
))
655 if (!(o
->flags
& SEEN
)) {
656 rev_list_push((struct commit
*)o
, COMMON_REF
| SEEN
);
658 mark_common((struct commit
*)o
, 1, 1);
662 filter_refs(args
, refs
, sought
, nr_sought
);
664 for (retval
= 1, ref
= *refs
; ref
; ref
= ref
->next
) {
665 const unsigned char *remote
= ref
->old_oid
.hash
;
668 o
= lookup_object(remote
);
669 if (!o
|| !(o
->flags
& COMPLETE
)) {
671 print_verbose(args
, "want %s (%s)", sha1_to_hex(remote
),
675 print_verbose(args
, _("already have %s (%s)"), sha1_to_hex(remote
),
681 static int sideband_demux(int in
, int out
, void *data
)
685 int ret
= recv_sideband("fetch-pack", xd
[0], out
);
690 static int get_pack(struct fetch_pack_args
*args
,
691 int xd
[2], char **pack_lockfile
)
694 int do_keep
= args
->keep_pack
;
695 const char *cmd_name
;
696 struct pack_header header
;
698 struct child_process cmd
= CHILD_PROCESS_INIT
;
701 memset(&demux
, 0, sizeof(demux
));
703 /* xd[] is talking with upload-pack; subprocess reads from
704 * xd[0], spits out band#2 to stderr, and feeds us band#1
705 * through demux->out.
707 demux
.proc
= sideband_demux
;
710 if (start_async(&demux
))
711 die(_("fetch-pack: unable to fork off sideband demultiplexer"));
716 if (!args
->keep_pack
&& unpack_limit
) {
718 if (read_pack_header(demux
.out
, &header
))
719 die(_("protocol error: bad pack header"));
721 if (ntohl(header
.hdr_entries
) < unpack_limit
)
727 if (alternate_shallow_file
) {
728 argv_array_push(&cmd
.args
, "--shallow-file");
729 argv_array_push(&cmd
.args
, alternate_shallow_file
);
735 cmd_name
= "index-pack";
736 argv_array_push(&cmd
.args
, cmd_name
);
737 argv_array_push(&cmd
.args
, "--stdin");
738 if (!args
->quiet
&& !args
->no_progress
)
739 argv_array_push(&cmd
.args
, "-v");
740 if (args
->use_thin_pack
)
741 argv_array_push(&cmd
.args
, "--fix-thin");
742 if (args
->lock_pack
|| unpack_limit
) {
744 if (gethostname(hostname
, sizeof(hostname
)))
745 xsnprintf(hostname
, sizeof(hostname
), "localhost");
746 argv_array_pushf(&cmd
.args
,
747 "--keep=fetch-pack %"PRIuMAX
" on %s",
748 (uintmax_t)getpid(), hostname
);
750 if (args
->check_self_contained_and_connected
)
751 argv_array_push(&cmd
.args
, "--check-self-contained-and-connected");
754 cmd_name
= "unpack-objects";
755 argv_array_push(&cmd
.args
, cmd_name
);
756 if (args
->quiet
|| args
->no_progress
)
757 argv_array_push(&cmd
.args
, "-q");
758 args
->check_self_contained_and_connected
= 0;
762 argv_array_pushf(&cmd
.args
, "--pack_header=%"PRIu32
",%"PRIu32
,
763 ntohl(header
.hdr_version
),
764 ntohl(header
.hdr_entries
));
765 if (fetch_fsck_objects
>= 0
767 : transfer_fsck_objects
>= 0
768 ? transfer_fsck_objects
770 argv_array_push(&cmd
.args
, "--strict");
774 if (start_command(&cmd
))
775 die(_("fetch-pack: unable to fork off %s"), cmd_name
);
776 if (do_keep
&& pack_lockfile
) {
777 *pack_lockfile
= index_pack_lockfile(cmd
.out
);
782 /* Closed by start_command() */
785 ret
= finish_command(&cmd
);
786 if (!ret
|| (args
->check_self_contained_and_connected
&& ret
== 1))
787 args
->self_contained_and_connected
=
788 args
->check_self_contained_and_connected
&&
791 die(_("%s failed"), cmd_name
);
792 if (use_sideband
&& finish_async(&demux
))
793 die(_("error in sideband demultiplexer"));
797 static int cmp_ref_by_name(const void *a_
, const void *b_
)
799 const struct ref
*a
= *((const struct ref
**)a_
);
800 const struct ref
*b
= *((const struct ref
**)b_
);
801 return strcmp(a
->name
, b
->name
);
804 static struct ref
*do_fetch_pack(struct fetch_pack_args
*args
,
806 const struct ref
*orig_ref
,
807 struct ref
**sought
, int nr_sought
,
808 struct shallow_info
*si
,
809 char **pack_lockfile
)
811 struct ref
*ref
= copy_ref_list(orig_ref
);
812 unsigned char sha1
[20];
813 const char *agent_feature
;
816 sort_ref_list(&ref
, ref_compare_name
);
817 qsort(sought
, nr_sought
, sizeof(*sought
), cmp_ref_by_name
);
819 if ((args
->depth
> 0 || is_repository_shallow()) && !server_supports("shallow"))
820 die(_("Server does not support shallow clients"));
821 if (args
->depth
> 0 || args
->deepen_since
)
823 if (server_supports("multi_ack_detailed")) {
824 print_verbose(args
, _("Server supports multi_ack_detailed"));
826 if (server_supports("no-done")) {
827 print_verbose(args
, _("Server supports no-done"));
828 if (args
->stateless_rpc
)
832 else if (server_supports("multi_ack")) {
833 print_verbose(args
, _("Server supports multi_ack"));
836 if (server_supports("side-band-64k")) {
837 print_verbose(args
, _("Server supports side-band-64k"));
840 else if (server_supports("side-band")) {
841 print_verbose(args
, _("Server supports side-band"));
844 if (server_supports("allow-tip-sha1-in-want")) {
845 print_verbose(args
, _("Server supports allow-tip-sha1-in-want"));
846 allow_unadvertised_object_request
|= ALLOW_TIP_SHA1
;
848 if (server_supports("allow-reachable-sha1-in-want")) {
849 print_verbose(args
, _("Server supports allow-reachable-sha1-in-want"));
850 allow_unadvertised_object_request
|= ALLOW_REACHABLE_SHA1
;
852 if (!server_supports("thin-pack"))
853 args
->use_thin_pack
= 0;
854 if (!server_supports("no-progress"))
855 args
->no_progress
= 0;
856 if (!server_supports("include-tag"))
857 args
->include_tag
= 0;
858 if (server_supports("ofs-delta"))
859 print_verbose(args
, _("Server supports ofs-delta"));
861 prefer_ofs_delta
= 0;
863 if ((agent_feature
= server_feature_value("agent", &agent_len
))) {
866 print_verbose(args
, _("Server version is %.*s"),
867 agent_len
, agent_feature
);
869 if (server_supports("deepen-since"))
871 else if (args
->deepen_since
)
872 die(_("Server does not support --shallow-since"));
874 if (everything_local(args
, &ref
, sought
, nr_sought
)) {
878 if (find_common(args
, fd
, sha1
, ref
) < 0)
879 if (!args
->keep_pack
)
880 /* When cloning, it is not unusual to have
883 warning(_("no common commits"));
885 if (args
->stateless_rpc
)
888 setup_alternate_shallow(&shallow_lock
, &alternate_shallow_file
,
890 else if (si
->nr_ours
|| si
->nr_theirs
)
891 alternate_shallow_file
= setup_temporary_shallow(si
->shallow
);
893 alternate_shallow_file
= NULL
;
894 if (get_pack(args
, fd
, pack_lockfile
))
895 die(_("git fetch-pack: fetch failed."));
901 static void fetch_pack_config(void)
903 git_config_get_int("fetch.unpacklimit", &fetch_unpack_limit
);
904 git_config_get_int("transfer.unpacklimit", &transfer_unpack_limit
);
905 git_config_get_bool("repack.usedeltabaseoffset", &prefer_ofs_delta
);
906 git_config_get_bool("fetch.fsckobjects", &fetch_fsck_objects
);
907 git_config_get_bool("transfer.fsckobjects", &transfer_fsck_objects
);
909 git_config(git_default_config
, NULL
);
912 static void fetch_pack_setup(void)
914 static int did_setup
;
918 if (0 <= transfer_unpack_limit
)
919 unpack_limit
= transfer_unpack_limit
;
920 else if (0 <= fetch_unpack_limit
)
921 unpack_limit
= fetch_unpack_limit
;
925 static int remove_duplicates_in_refs(struct ref
**ref
, int nr
)
927 struct string_list names
= STRING_LIST_INIT_NODUP
;
930 for (src
= dst
= 0; src
< nr
; src
++) {
931 struct string_list_item
*item
;
932 item
= string_list_insert(&names
, ref
[src
]->name
);
934 continue; /* already have it */
935 item
->util
= ref
[src
];
940 for (src
= dst
; src
< nr
; src
++)
942 string_list_clear(&names
, 0);
946 static void update_shallow(struct fetch_pack_args
*args
,
947 struct ref
**sought
, int nr_sought
,
948 struct shallow_info
*si
)
950 struct sha1_array ref
= SHA1_ARRAY_INIT
;
954 if (args
->deepen
&& alternate_shallow_file
) {
955 if (*alternate_shallow_file
== '\0') { /* --unshallow */
956 unlink_or_warn(git_path_shallow());
957 rollback_lock_file(&shallow_lock
);
959 commit_lock_file(&shallow_lock
);
963 if (!si
->shallow
|| !si
->shallow
->nr
)
968 * remote is shallow, but this is a clone, there are
969 * no objects in repo to worry about. Accept any
970 * shallow points that exist in the pack (iow in repo
971 * after get_pack() and reprepare_packed_git())
973 struct sha1_array extra
= SHA1_ARRAY_INIT
;
974 unsigned char (*sha1
)[20] = si
->shallow
->sha1
;
975 for (i
= 0; i
< si
->shallow
->nr
; i
++)
976 if (has_sha1_file(sha1
[i
]))
977 sha1_array_append(&extra
, sha1
[i
]);
979 setup_alternate_shallow(&shallow_lock
,
980 &alternate_shallow_file
,
982 commit_lock_file(&shallow_lock
);
984 sha1_array_clear(&extra
);
988 if (!si
->nr_ours
&& !si
->nr_theirs
)
991 remove_nonexistent_theirs_shallow(si
);
992 if (!si
->nr_ours
&& !si
->nr_theirs
)
994 for (i
= 0; i
< nr_sought
; i
++)
995 sha1_array_append(&ref
, sought
[i
]->old_oid
.hash
);
998 if (args
->update_shallow
) {
1000 * remote is also shallow, .git/shallow may be updated
1001 * so all refs can be accepted. Make sure we only add
1002 * shallow roots that are actually reachable from new
1005 struct sha1_array extra
= SHA1_ARRAY_INIT
;
1006 unsigned char (*sha1
)[20] = si
->shallow
->sha1
;
1007 assign_shallow_commits_to_refs(si
, NULL
, NULL
);
1008 if (!si
->nr_ours
&& !si
->nr_theirs
) {
1009 sha1_array_clear(&ref
);
1012 for (i
= 0; i
< si
->nr_ours
; i
++)
1013 sha1_array_append(&extra
, sha1
[si
->ours
[i
]]);
1014 for (i
= 0; i
< si
->nr_theirs
; i
++)
1015 sha1_array_append(&extra
, sha1
[si
->theirs
[i
]]);
1016 setup_alternate_shallow(&shallow_lock
,
1017 &alternate_shallow_file
,
1019 commit_lock_file(&shallow_lock
);
1020 sha1_array_clear(&extra
);
1021 sha1_array_clear(&ref
);
1026 * remote is also shallow, check what ref is safe to update
1027 * without updating .git/shallow
1029 status
= xcalloc(nr_sought
, sizeof(*status
));
1030 assign_shallow_commits_to_refs(si
, NULL
, status
);
1031 if (si
->nr_ours
|| si
->nr_theirs
) {
1032 for (i
= 0; i
< nr_sought
; i
++)
1034 sought
[i
]->status
= REF_STATUS_REJECT_SHALLOW
;
1037 sha1_array_clear(&ref
);
1040 struct ref
*fetch_pack(struct fetch_pack_args
*args
,
1041 int fd
[], struct child_process
*conn
,
1042 const struct ref
*ref
,
1044 struct ref
**sought
, int nr_sought
,
1045 struct sha1_array
*shallow
,
1046 char **pack_lockfile
)
1048 struct ref
*ref_cpy
;
1049 struct shallow_info si
;
1053 nr_sought
= remove_duplicates_in_refs(sought
, nr_sought
);
1056 packet_flush(fd
[1]);
1057 die(_("no matching remote head"));
1059 prepare_shallow_info(&si
, shallow
);
1060 ref_cpy
= do_fetch_pack(args
, fd
, ref
, sought
, nr_sought
,
1061 &si
, pack_lockfile
);
1062 reprepare_packed_git();
1063 update_shallow(args
, sought
, nr_sought
, &si
);
1064 clear_shallow_info(&si
);