9 #include "fetch-pack.h"
11 #include "run-command.h"
12 #include "transport.h"
14 #include "prio-queue.h"
16 static int transfer_unpack_limit
= -1;
17 static int fetch_unpack_limit
= -1;
18 static int unpack_limit
= 100;
19 static int prefer_ofs_delta
= 1;
21 static int fetch_fsck_objects
= -1;
22 static int transfer_fsck_objects
= -1;
23 static int agent_supported
;
24 static struct lock_file shallow_lock
;
25 static const char *alternate_shallow_file
;
27 #define COMPLETE (1U << 0)
28 #define COMMON (1U << 1)
29 #define COMMON_REF (1U << 2)
30 #define SEEN (1U << 3)
31 #define POPPED (1U << 4)
36 * After sending this many "have"s if we do not get any new ACK , we
37 * give up traversing our history.
39 #define MAX_IN_VAIN 256
41 static struct prio_queue rev_list
= { compare_commits_by_commit_date
};
42 static int non_common_revs
, multi_ack
, use_sideband
, allow_tip_sha1_in_want
;
44 static void rev_list_push(struct commit
*commit
, int mark
)
46 if (!(commit
->object
.flags
& mark
)) {
47 commit
->object
.flags
|= mark
;
49 if (!(commit
->object
.parsed
))
50 if (parse_commit(commit
))
53 prio_queue_put(&rev_list
, commit
);
55 if (!(commit
->object
.flags
& COMMON
))
60 static int rev_list_insert_ref(const char *refname
, const unsigned char *sha1
, int flag
, void *cb_data
)
62 struct object
*o
= deref_tag(parse_object(sha1
), refname
, 0);
64 if (o
&& o
->type
== OBJ_COMMIT
)
65 rev_list_push((struct commit
*)o
, SEEN
);
70 static int clear_marks(const char *refname
, const unsigned char *sha1
, int flag
, void *cb_data
)
72 struct object
*o
= deref_tag(parse_object(sha1
), refname
, 0);
74 if (o
&& o
->type
== OBJ_COMMIT
)
75 clear_commit_marks((struct commit
*)o
,
76 COMMON
| COMMON_REF
| SEEN
| POPPED
);
81 This function marks a rev and its ancestors as common.
82 In some cases, it is desirable to mark only the ancestors (for example
83 when only the server does not yet know that they are common).
86 static void mark_common(struct commit
*commit
,
87 int ancestors_only
, int dont_parse
)
89 if (commit
!= NULL
&& !(commit
->object
.flags
& COMMON
)) {
90 struct object
*o
= (struct object
*)commit
;
95 if (!(o
->flags
& SEEN
))
96 rev_list_push(commit
, SEEN
);
98 struct commit_list
*parents
;
100 if (!ancestors_only
&& !(o
->flags
& POPPED
))
102 if (!o
->parsed
&& !dont_parse
)
103 if (parse_commit(commit
))
106 for (parents
= commit
->parents
;
108 parents
= parents
->next
)
109 mark_common(parents
->item
, 0, dont_parse
);
115 Get the next rev to send, ignoring the common.
118 static const unsigned char *get_rev(void)
120 struct commit
*commit
= NULL
;
122 while (commit
== NULL
) {
124 struct commit_list
*parents
;
126 if (rev_list
.nr
== 0 || non_common_revs
== 0)
129 commit
= prio_queue_get(&rev_list
);
130 if (!commit
->object
.parsed
)
131 parse_commit(commit
);
132 parents
= commit
->parents
;
134 commit
->object
.flags
|= POPPED
;
135 if (!(commit
->object
.flags
& COMMON
))
138 if (commit
->object
.flags
& COMMON
) {
139 /* do not send "have", and ignore ancestors */
141 mark
= COMMON
| SEEN
;
142 } else if (commit
->object
.flags
& COMMON_REF
)
143 /* send "have", and ignore ancestors */
144 mark
= COMMON
| SEEN
;
146 /* send "have", also for its ancestors */
150 if (!(parents
->item
->object
.flags
& SEEN
))
151 rev_list_push(parents
->item
, mark
);
153 mark_common(parents
->item
, 1, 0);
154 parents
= parents
->next
;
158 return commit
->object
.sha1
;
169 static void consume_shallow_list(struct fetch_pack_args
*args
, int fd
)
171 if (args
->stateless_rpc
&& args
->depth
> 0) {
172 /* If we sent a depth we will get back "duplicate"
173 * shallow and unshallow commands every time there
174 * is a block of have lines exchanged.
177 while ((line
= packet_read_line(fd
, NULL
))) {
178 if (!prefixcmp(line
, "shallow "))
180 if (!prefixcmp(line
, "unshallow "))
182 die("git fetch-pack: expected shallow list");
187 static enum ack_type
get_ack(int fd
, unsigned char *result_sha1
)
190 char *line
= packet_read_line(fd
, &len
);
193 die("git fetch-pack: expected ACK/NAK, got EOF");
194 if (!strcmp(line
, "NAK"))
196 if (!prefixcmp(line
, "ACK ")) {
197 if (!get_sha1_hex(line
+4, result_sha1
)) {
200 if (strstr(line
+45, "continue"))
202 if (strstr(line
+45, "common"))
204 if (strstr(line
+45, "ready"))
209 die("git fetch_pack: expected ACK/NAK, got '%s'", line
);
212 static void send_request(struct fetch_pack_args
*args
,
213 int fd
, struct strbuf
*buf
)
215 if (args
->stateless_rpc
) {
216 send_sideband(fd
, -1, buf
->buf
, buf
->len
, LARGE_PACKET_MAX
);
219 write_or_die(fd
, buf
->buf
, buf
->len
);
222 static void insert_one_alternate_ref(const struct ref
*ref
, void *unused
)
224 rev_list_insert_ref(NULL
, ref
->old_sha1
, 0, NULL
);
227 #define INITIAL_FLUSH 16
228 #define PIPESAFE_FLUSH 32
229 #define LARGE_FLUSH 1024
231 static int next_flush(struct fetch_pack_args
*args
, int count
)
233 int flush_limit
= args
->stateless_rpc
? LARGE_FLUSH
: PIPESAFE_FLUSH
;
235 if (count
< flush_limit
)
238 count
+= flush_limit
;
242 static int find_common(struct fetch_pack_args
*args
,
243 int fd
[2], unsigned char *result_sha1
,
247 int count
= 0, flushes
= 0, flush_at
= INITIAL_FLUSH
, retval
;
248 const unsigned char *sha1
;
249 unsigned in_vain
= 0;
250 int got_continue
= 0;
252 struct strbuf req_buf
= STRBUF_INIT
;
253 size_t state_len
= 0;
255 if (args
->stateless_rpc
&& multi_ack
== 1)
256 die("--stateless-rpc requires multi_ack_detailed");
258 for_each_ref(clear_marks
, NULL
);
261 for_each_ref(rev_list_insert_ref
, NULL
);
262 for_each_alternate_ref(insert_one_alternate_ref
, NULL
);
265 for ( ; refs
; refs
= refs
->next
) {
266 unsigned char *remote
= refs
->old_sha1
;
267 const char *remote_hex
;
271 * If that object is complete (i.e. it is an ancestor of a
272 * local ref), we tell them we have it but do not have to
273 * tell them about its ancestors, which they already know
276 * We use lookup_object here because we are only
277 * interested in the case we *know* the object is
278 * reachable and we have already scanned it.
280 if (((o
= lookup_object(remote
)) != NULL
) &&
281 (o
->flags
& COMPLETE
)) {
285 remote_hex
= sha1_to_hex(remote
);
287 struct strbuf c
= STRBUF_INIT
;
288 if (multi_ack
== 2) strbuf_addstr(&c
, " multi_ack_detailed");
289 if (multi_ack
== 1) strbuf_addstr(&c
, " multi_ack");
290 if (no_done
) strbuf_addstr(&c
, " no-done");
291 if (use_sideband
== 2) strbuf_addstr(&c
, " side-band-64k");
292 if (use_sideband
== 1) strbuf_addstr(&c
, " side-band");
293 if (args
->use_thin_pack
) strbuf_addstr(&c
, " thin-pack");
294 if (args
->no_progress
) strbuf_addstr(&c
, " no-progress");
295 if (args
->include_tag
) strbuf_addstr(&c
, " include-tag");
296 if (prefer_ofs_delta
) strbuf_addstr(&c
, " ofs-delta");
297 if (agent_supported
) strbuf_addf(&c
, " agent=%s",
298 git_user_agent_sanitized());
299 packet_buf_write(&req_buf
, "want %s%s\n", remote_hex
, c
.buf
);
302 packet_buf_write(&req_buf
, "want %s\n", remote_hex
);
307 strbuf_release(&req_buf
);
312 if (is_repository_shallow())
313 write_shallow_commits(&req_buf
, 1);
315 packet_buf_write(&req_buf
, "deepen %d", args
->depth
);
316 packet_buf_flush(&req_buf
);
317 state_len
= req_buf
.len
;
319 if (args
->depth
> 0) {
321 unsigned char sha1
[20];
323 send_request(args
, fd
[1], &req_buf
);
324 while ((line
= packet_read_line(fd
[0], NULL
))) {
325 if (!prefixcmp(line
, "shallow ")) {
326 if (get_sha1_hex(line
+ 8, sha1
))
327 die("invalid shallow line: %s", line
);
328 register_shallow(sha1
);
331 if (!prefixcmp(line
, "unshallow ")) {
332 if (get_sha1_hex(line
+ 10, sha1
))
333 die("invalid unshallow line: %s", line
);
334 if (!lookup_object(sha1
))
335 die("object not found: %s", line
);
336 /* make sure that it is parsed as shallow */
337 if (!parse_object(sha1
))
338 die("error in object: %s", line
);
339 if (unregister_shallow(sha1
))
340 die("no shallow found: %s", line
);
343 die("expected shallow/unshallow, got %s", line
);
345 } else if (!args
->stateless_rpc
)
346 send_request(args
, fd
[1], &req_buf
);
348 if (!args
->stateless_rpc
) {
349 /* If we aren't using the stateless-rpc interface
350 * we don't need to retain the headers.
352 strbuf_setlen(&req_buf
, 0);
358 while ((sha1
= get_rev())) {
359 packet_buf_write(&req_buf
, "have %s\n", sha1_to_hex(sha1
));
361 fprintf(stderr
, "have %s\n", sha1_to_hex(sha1
));
363 if (flush_at
<= ++count
) {
366 packet_buf_flush(&req_buf
);
367 send_request(args
, fd
[1], &req_buf
);
368 strbuf_setlen(&req_buf
, state_len
);
370 flush_at
= next_flush(args
, count
);
373 * We keep one window "ahead" of the other side, and
374 * will wait for an ACK only on the next one
376 if (!args
->stateless_rpc
&& count
== INITIAL_FLUSH
)
379 consume_shallow_list(args
, fd
[0]);
381 ack
= get_ack(fd
[0], result_sha1
);
382 if (args
->verbose
&& ack
)
383 fprintf(stderr
, "got ack %d %s\n", ack
,
384 sha1_to_hex(result_sha1
));
394 struct commit
*commit
=
395 lookup_commit(result_sha1
);
397 die("invalid commit %s", sha1_to_hex(result_sha1
));
398 if (args
->stateless_rpc
400 && !(commit
->object
.flags
& COMMON
)) {
401 /* We need to replay the have for this object
402 * on the next RPC request so the peer knows
403 * it is in common with us.
405 const char *hex
= sha1_to_hex(result_sha1
);
406 packet_buf_write(&req_buf
, "have %s\n", hex
);
407 state_len
= req_buf
.len
;
409 mark_common(commit
, 0, 1);
413 if (ack
== ACK_ready
) {
414 clear_prio_queue(&rev_list
);
422 if (got_continue
&& MAX_IN_VAIN
< in_vain
) {
424 fprintf(stderr
, "giving up\n");
430 if (!got_ready
|| !no_done
) {
431 packet_buf_write(&req_buf
, "done\n");
432 send_request(args
, fd
[1], &req_buf
);
435 fprintf(stderr
, "done\n");
440 strbuf_release(&req_buf
);
442 consume_shallow_list(args
, fd
[0]);
443 while (flushes
|| multi_ack
) {
444 int ack
= get_ack(fd
[0], result_sha1
);
447 fprintf(stderr
, "got ack (%d) %s\n", ack
,
448 sha1_to_hex(result_sha1
));
456 /* it is no error to fetch into a completely empty repo */
457 return count
? retval
: 0;
460 static struct commit_list
*complete
;
462 static int mark_complete(const char *refname
, const unsigned char *sha1
, int flag
, void *cb_data
)
464 struct object
*o
= parse_object(sha1
);
466 while (o
&& o
->type
== OBJ_TAG
) {
467 struct tag
*t
= (struct tag
*) o
;
469 break; /* broken repository */
470 o
->flags
|= COMPLETE
;
471 o
= parse_object(t
->tagged
->sha1
);
473 if (o
&& o
->type
== OBJ_COMMIT
) {
474 struct commit
*commit
= (struct commit
*)o
;
475 if (!(commit
->object
.flags
& COMPLETE
)) {
476 commit
->object
.flags
|= COMPLETE
;
477 commit_list_insert(commit
, &complete
);
483 static void mark_recent_complete_commits(struct fetch_pack_args
*args
,
484 unsigned long cutoff
)
486 while (complete
&& cutoff
<= complete
->item
->date
) {
488 fprintf(stderr
, "Marking %s as complete\n",
489 sha1_to_hex(complete
->item
->object
.sha1
));
490 pop_most_recent_commit(&complete
, COMPLETE
);
494 static void filter_refs(struct fetch_pack_args
*args
,
496 struct ref
**sought
, int nr_sought
)
498 struct ref
*newlist
= NULL
;
499 struct ref
**newtail
= &newlist
;
500 struct ref
*ref
, *next
;
504 for (ref
= *refs
; ref
; ref
= next
) {
508 if (!memcmp(ref
->name
, "refs/", 5) &&
509 check_refname_format(ref
->name
+ 5, 0))
512 while (i
< nr_sought
) {
513 int cmp
= strcmp(ref
->name
, sought
[i
]->name
);
515 break; /* definitely do not have it */
517 keep
= 1; /* definitely have it */
518 sought
[i
]->matched
= 1;
524 if (!keep
&& args
->fetch_all
&&
525 (!args
->depth
|| prefixcmp(ref
->name
, "refs/tags/")))
531 newtail
= &ref
->next
;
537 /* Append unmatched requests to the list */
538 if (allow_tip_sha1_in_want
) {
539 for (i
= 0; i
< nr_sought
; i
++) {
543 if (get_sha1_hex(ref
->name
, ref
->old_sha1
))
549 newtail
= &ref
->next
;
555 static void mark_alternate_complete(const struct ref
*ref
, void *unused
)
557 mark_complete(NULL
, ref
->old_sha1
, 0, NULL
);
560 static int everything_local(struct fetch_pack_args
*args
,
562 struct ref
**sought
, int nr_sought
)
566 unsigned long cutoff
= 0;
568 save_commit_buffer
= 0;
570 for (ref
= *refs
; ref
; ref
= ref
->next
) {
573 if (!has_sha1_file(ref
->old_sha1
))
576 o
= parse_object(ref
->old_sha1
);
580 /* We already have it -- which may mean that we were
581 * in sync with the other side at some time after
582 * that (it is OK if we guess wrong here).
584 if (o
->type
== OBJ_COMMIT
) {
585 struct commit
*commit
= (struct commit
*)o
;
586 if (!cutoff
|| cutoff
< commit
->date
)
587 cutoff
= commit
->date
;
592 for_each_ref(mark_complete
, NULL
);
593 for_each_alternate_ref(mark_alternate_complete
, NULL
);
594 commit_list_sort_by_date(&complete
);
596 mark_recent_complete_commits(args
, cutoff
);
600 * Mark all complete remote refs as common refs.
601 * Don't mark them common yet; the server has to be told so first.
603 for (ref
= *refs
; ref
; ref
= ref
->next
) {
604 struct object
*o
= deref_tag(lookup_object(ref
->old_sha1
),
607 if (!o
|| o
->type
!= OBJ_COMMIT
|| !(o
->flags
& COMPLETE
))
610 if (!(o
->flags
& SEEN
)) {
611 rev_list_push((struct commit
*)o
, COMMON_REF
| SEEN
);
613 mark_common((struct commit
*)o
, 1, 1);
617 filter_refs(args
, refs
, sought
, nr_sought
);
619 for (retval
= 1, ref
= *refs
; ref
; ref
= ref
->next
) {
620 const unsigned char *remote
= ref
->old_sha1
;
621 unsigned char local
[20];
624 o
= lookup_object(remote
);
625 if (!o
|| !(o
->flags
& COMPLETE
)) {
630 "want %s (%s)\n", sha1_to_hex(remote
),
635 hashcpy(ref
->new_sha1
, local
);
639 "already have %s (%s)\n", sha1_to_hex(remote
),
645 static int sideband_demux(int in
, int out
, void *data
)
649 int ret
= recv_sideband("fetch-pack", xd
[0], out
);
654 static int get_pack(struct fetch_pack_args
*args
,
655 int xd
[2], char **pack_lockfile
)
658 const char *argv
[22];
662 int do_keep
= args
->keep_pack
;
663 struct child_process cmd
;
666 memset(&demux
, 0, sizeof(demux
));
668 /* xd[] is talking with upload-pack; subprocess reads from
669 * xd[0], spits out band#2 to stderr, and feeds us band#1
670 * through demux->out.
672 demux
.proc
= sideband_demux
;
675 if (start_async(&demux
))
676 die("fetch-pack: unable to fork off sideband"
682 memset(&cmd
, 0, sizeof(cmd
));
686 if (!args
->keep_pack
&& unpack_limit
) {
687 struct pack_header header
;
689 if (read_pack_header(demux
.out
, &header
))
690 die("protocol error: bad pack header");
691 snprintf(hdr_arg
, sizeof(hdr_arg
),
692 "--pack_header=%"PRIu32
",%"PRIu32
,
693 ntohl(header
.hdr_version
), ntohl(header
.hdr_entries
));
694 if (ntohl(header
.hdr_entries
) < unpack_limit
)
700 if (alternate_shallow_file
) {
701 *av
++ = "--shallow-file";
702 *av
++ = alternate_shallow_file
;
708 *av
++ = "index-pack";
710 if (!args
->quiet
&& !args
->no_progress
)
712 if (args
->use_thin_pack
)
713 *av
++ = "--fix-thin";
714 if (args
->lock_pack
|| unpack_limit
) {
715 int s
= sprintf(keep_arg
,
716 "--keep=fetch-pack %"PRIuMAX
" on ", (uintmax_t) getpid());
717 if (gethostname(keep_arg
+ s
, sizeof(keep_arg
) - s
))
718 strcpy(keep_arg
+ s
, "localhost");
721 if (args
->check_self_contained_and_connected
)
722 *av
++ = "--check-self-contained-and-connected";
725 *av
++ = "unpack-objects";
726 if (args
->quiet
|| args
->no_progress
)
728 args
->check_self_contained_and_connected
= 0;
732 if (fetch_fsck_objects
>= 0
734 : transfer_fsck_objects
>= 0
735 ? transfer_fsck_objects
742 if (start_command(&cmd
))
743 die("fetch-pack: unable to fork off %s", argv
[0]);
744 if (do_keep
&& pack_lockfile
) {
745 *pack_lockfile
= index_pack_lockfile(cmd
.out
);
749 ret
= finish_command(&cmd
);
750 if (!ret
|| (args
->check_self_contained_and_connected
&& ret
== 1))
751 args
->self_contained_and_connected
=
752 args
->check_self_contained_and_connected
&&
755 die("%s failed", argv
[0]);
756 if (use_sideband
&& finish_async(&demux
))
757 die("error in sideband demultiplexer");
761 static int cmp_ref_by_name(const void *a_
, const void *b_
)
763 const struct ref
*a
= *((const struct ref
**)a_
);
764 const struct ref
*b
= *((const struct ref
**)b_
);
765 return strcmp(a
->name
, b
->name
);
768 static struct ref
*do_fetch_pack(struct fetch_pack_args
*args
,
770 const struct ref
*orig_ref
,
771 struct ref
**sought
, int nr_sought
,
772 char **pack_lockfile
)
774 struct ref
*ref
= copy_ref_list(orig_ref
);
775 unsigned char sha1
[20];
776 const char *agent_feature
;
779 sort_ref_list(&ref
, ref_compare_name
);
780 qsort(sought
, nr_sought
, sizeof(*sought
), cmp_ref_by_name
);
782 if (is_repository_shallow() && !server_supports("shallow"))
783 die("Server does not support shallow clients");
784 if (server_supports("multi_ack_detailed")) {
786 fprintf(stderr
, "Server supports multi_ack_detailed\n");
788 if (server_supports("no-done")) {
790 fprintf(stderr
, "Server supports no-done\n");
791 if (args
->stateless_rpc
)
795 else if (server_supports("multi_ack")) {
797 fprintf(stderr
, "Server supports multi_ack\n");
800 if (server_supports("side-band-64k")) {
802 fprintf(stderr
, "Server supports side-band-64k\n");
805 else if (server_supports("side-band")) {
807 fprintf(stderr
, "Server supports side-band\n");
810 if (server_supports("allow-tip-sha1-in-want")) {
812 fprintf(stderr
, "Server supports allow-tip-sha1-in-want\n");
813 allow_tip_sha1_in_want
= 1;
815 if (!server_supports("thin-pack"))
816 args
->use_thin_pack
= 0;
817 if (!server_supports("no-progress"))
818 args
->no_progress
= 0;
819 if (!server_supports("include-tag"))
820 args
->include_tag
= 0;
821 if (server_supports("ofs-delta")) {
823 fprintf(stderr
, "Server supports ofs-delta\n");
825 prefer_ofs_delta
= 0;
827 if ((agent_feature
= server_feature_value("agent", &agent_len
))) {
829 if (args
->verbose
&& agent_len
)
830 fprintf(stderr
, "Server version is %.*s\n",
831 agent_len
, agent_feature
);
834 if (everything_local(args
, &ref
, sought
, nr_sought
)) {
838 if (find_common(args
, fd
, sha1
, ref
) < 0)
839 if (!args
->keep_pack
)
840 /* When cloning, it is not unusual to have
843 warning("no common commits");
845 if (args
->stateless_rpc
)
848 setup_alternate_shallow(&shallow_lock
, &alternate_shallow_file
);
849 if (get_pack(args
, fd
, pack_lockfile
))
850 die("git fetch-pack: fetch failed.");
856 static int fetch_pack_config(const char *var
, const char *value
, void *cb
)
858 if (strcmp(var
, "fetch.unpacklimit") == 0) {
859 fetch_unpack_limit
= git_config_int(var
, value
);
863 if (strcmp(var
, "transfer.unpacklimit") == 0) {
864 transfer_unpack_limit
= git_config_int(var
, value
);
868 if (strcmp(var
, "repack.usedeltabaseoffset") == 0) {
869 prefer_ofs_delta
= git_config_bool(var
, value
);
873 if (!strcmp(var
, "fetch.fsckobjects")) {
874 fetch_fsck_objects
= git_config_bool(var
, value
);
878 if (!strcmp(var
, "transfer.fsckobjects")) {
879 transfer_fsck_objects
= git_config_bool(var
, value
);
883 return git_default_config(var
, value
, cb
);
886 static void fetch_pack_setup(void)
888 static int did_setup
;
891 git_config(fetch_pack_config
, NULL
);
892 if (0 <= transfer_unpack_limit
)
893 unpack_limit
= transfer_unpack_limit
;
894 else if (0 <= fetch_unpack_limit
)
895 unpack_limit
= fetch_unpack_limit
;
899 static int remove_duplicates_in_refs(struct ref
**ref
, int nr
)
901 struct string_list names
= STRING_LIST_INIT_NODUP
;
904 for (src
= dst
= 0; src
< nr
; src
++) {
905 struct string_list_item
*item
;
906 item
= string_list_insert(&names
, ref
[src
]->name
);
908 continue; /* already have it */
909 item
->util
= ref
[src
];
914 for (src
= dst
; src
< nr
; src
++)
916 string_list_clear(&names
, 0);
920 struct ref
*fetch_pack(struct fetch_pack_args
*args
,
921 int fd
[], struct child_process
*conn
,
922 const struct ref
*ref
,
924 struct ref
**sought
, int nr_sought
,
925 char **pack_lockfile
)
931 nr_sought
= remove_duplicates_in_refs(sought
, nr_sought
);
935 die("no matching remote head");
937 ref_cpy
= do_fetch_pack(args
, fd
, ref
, sought
, nr_sought
, pack_lockfile
);
939 if (alternate_shallow_file
) {
940 if (*alternate_shallow_file
== '\0') { /* --unshallow */
941 unlink_or_warn(git_path("shallow"));
942 rollback_lock_file(&shallow_lock
);
944 commit_lock_file(&shallow_lock
);
947 reprepare_packed_git();