4 * Copyright (c) 2007 Kristian Høgsberg <krh@redhat.com>,
5 * 2008 Daniel Barkalow <barkalow@iabervon.org>
6 * Based on git-commit.sh by Junio C Hamano and Linus Torvalds
8 * Clone a repository into a different directory that does not yet exist.
13 #include "parse-options.h"
14 #include "fetch-pack.h"
17 #include "tree-walk.h"
18 #include "unpack-trees.h"
19 #include "transport.h"
25 #include "run-command.h"
26 #include "connected.h"
30 * - respect DB_ENVIRONMENT for .git/objects.
32 * Implementation notes:
33 * - dropping use-separate-remote and no-separate-remote compatibility
36 static const char * const builtin_clone_usage
[] = {
37 N_("git clone [<options>] [--] <repo> [<dir>]"),
41 static int option_no_checkout
, option_bare
, option_mirror
, option_single_branch
= -1;
42 static int option_local
= -1, option_no_hardlinks
, option_shared
, option_recursive
;
43 static char *option_template
, *option_depth
;
44 static char *option_origin
= NULL
;
45 static char *option_branch
= NULL
;
46 static const char *real_git_dir
;
47 static char *option_upload_pack
= "git-upload-pack";
48 static int option_verbosity
;
49 static int option_progress
= -1;
50 static struct string_list option_config
;
51 static struct string_list option_reference
;
52 static int option_dissociate
;
54 static struct option builtin_clone_options
[] = {
55 OPT__VERBOSITY(&option_verbosity
),
56 OPT_BOOL(0, "progress", &option_progress
,
57 N_("force progress reporting")),
58 OPT_BOOL('n', "no-checkout", &option_no_checkout
,
59 N_("don't create a checkout")),
60 OPT_BOOL(0, "bare", &option_bare
, N_("create a bare repository")),
61 OPT_HIDDEN_BOOL(0, "naked", &option_bare
,
62 N_("create a bare repository")),
63 OPT_BOOL(0, "mirror", &option_mirror
,
64 N_("create a mirror repository (implies bare)")),
65 OPT_BOOL('l', "local", &option_local
,
66 N_("to clone from a local repository")),
67 OPT_BOOL(0, "no-hardlinks", &option_no_hardlinks
,
68 N_("don't use local hardlinks, always copy")),
69 OPT_BOOL('s', "shared", &option_shared
,
70 N_("setup as shared repository")),
71 OPT_BOOL(0, "recursive", &option_recursive
,
72 N_("initialize submodules in the clone")),
73 OPT_BOOL(0, "recurse-submodules", &option_recursive
,
74 N_("initialize submodules in the clone")),
75 OPT_STRING(0, "template", &option_template
, N_("template-directory"),
76 N_("directory from which templates will be used")),
77 OPT_STRING_LIST(0, "reference", &option_reference
, N_("repo"),
78 N_("reference repository")),
79 OPT_BOOL(0, "dissociate", &option_dissociate
,
80 N_("use --reference only while cloning")),
81 OPT_STRING('o', "origin", &option_origin
, N_("name"),
82 N_("use <name> instead of 'origin' to track upstream")),
83 OPT_STRING('b', "branch", &option_branch
, N_("branch"),
84 N_("checkout <branch> instead of the remote's HEAD")),
85 OPT_STRING('u', "upload-pack", &option_upload_pack
, N_("path"),
86 N_("path to git-upload-pack on the remote")),
87 OPT_STRING(0, "depth", &option_depth
, N_("depth"),
88 N_("create a shallow clone of that depth")),
89 OPT_BOOL(0, "single-branch", &option_single_branch
,
90 N_("clone only one branch, HEAD or --branch")),
91 OPT_STRING(0, "separate-git-dir", &real_git_dir
, N_("gitdir"),
92 N_("separate git dir from working tree")),
93 OPT_STRING_LIST('c', "config", &option_config
, N_("key=value"),
94 N_("set config inside the new repository")),
98 static const char *argv_submodule
[] = {
99 "submodule", "update", "--init", "--recursive", NULL
102 static char *get_repo_path(const char *repo
, int *is_bundle
)
104 static char *suffix
[] = { "/.git", "", ".git/.git", ".git" };
105 static char *bundle_suffix
[] = { ".bundle", "" };
109 for (i
= 0; i
< ARRAY_SIZE(suffix
); i
++) {
111 path
= mkpath("%s%s", repo
, suffix
[i
]);
114 if (S_ISDIR(st
.st_mode
) && is_git_directory(path
)) {
116 return xstrdup(absolute_path(path
));
117 } else if (S_ISREG(st
.st_mode
) && st
.st_size
> 8) {
118 /* Is it a "gitfile"? */
120 int len
, fd
= open(path
, O_RDONLY
);
123 len
= read_in_full(fd
, signature
, 8);
125 if (len
!= 8 || strncmp(signature
, "gitdir: ", 8))
127 path
= read_gitfile(path
);
130 return xstrdup(absolute_path(path
));
135 for (i
= 0; i
< ARRAY_SIZE(bundle_suffix
); i
++) {
137 path
= mkpath("%s%s", repo
, bundle_suffix
[i
]);
138 if (!stat(path
, &st
) && S_ISREG(st
.st_mode
)) {
140 return xstrdup(absolute_path(path
));
147 static char *guess_dir_name(const char *repo
, int is_bundle
, int is_bare
)
149 const char *end
= repo
+ strlen(repo
), *start
;
153 * Strip trailing spaces, slashes and /.git
155 while (repo
< end
&& (is_dir_sep(end
[-1]) || isspace(end
[-1])))
157 if (end
- repo
> 5 && is_dir_sep(end
[-5]) &&
158 !strncmp(end
- 4, ".git", 4)) {
160 while (repo
< end
&& is_dir_sep(end
[-1]))
165 * Find last component, but be prepared that repo could have
166 * the form "remote.example.com:foo.git", i.e. no slash
167 * in the directory part.
170 while (repo
< start
&& !is_dir_sep(start
[-1]) && start
[-1] != ':')
174 * Strip .{bundle,git}.
177 if (end
- start
> 7 && !strncmp(end
- 7, ".bundle", 7))
180 if (end
- start
> 4 && !strncmp(end
- 4, ".git", 4))
185 struct strbuf result
= STRBUF_INIT
;
186 strbuf_addf(&result
, "%.*s.git", (int)(end
- start
), start
);
187 dir
= strbuf_detach(&result
, NULL
);
189 dir
= xstrndup(start
, end
- start
);
191 * Replace sequences of 'control' characters and whitespace
192 * with one ascii space, remove leading and trailing spaces.
196 int prev_space
= 1 /* strip leading whitespace */;
197 for (end
= dir
; *end
; ++end
) {
199 if ((unsigned char)ch
< '\x20')
210 if (out
> dir
&& prev_space
)
216 static void strip_trailing_slashes(char *dir
)
218 char *end
= dir
+ strlen(dir
);
220 while (dir
< end
- 1 && is_dir_sep(end
[-1]))
225 static int add_one_reference(struct string_list_item
*item
, void *cb_data
)
229 struct strbuf alternate
= STRBUF_INIT
;
231 /* Beware: read_gitfile(), real_path() and mkpath() return static buffer */
232 ref_git
= xstrdup(real_path(item
->string
));
234 repo
= read_gitfile(ref_git
);
236 repo
= read_gitfile(mkpath("%s/.git", ref_git
));
239 ref_git
= xstrdup(repo
);
242 if (!repo
&& is_directory(mkpath("%s/.git/objects", ref_git
))) {
243 char *ref_git_git
= mkpathdup("%s/.git", ref_git
);
245 ref_git
= ref_git_git
;
246 } else if (!is_directory(mkpath("%s/objects", ref_git
)))
247 die(_("reference repository '%s' is not a local repository."),
250 if (!access(mkpath("%s/shallow", ref_git
), F_OK
))
251 die(_("reference repository '%s' is shallow"), item
->string
);
253 if (!access(mkpath("%s/info/grafts", ref_git
), F_OK
))
254 die(_("reference repository '%s' is grafted"), item
->string
);
256 strbuf_addf(&alternate
, "%s/objects", ref_git
);
257 add_to_alternates_file(alternate
.buf
);
258 strbuf_release(&alternate
);
263 static void setup_reference(void)
265 for_each_string_list(&option_reference
, add_one_reference
, NULL
);
268 static void copy_alternates(struct strbuf
*src
, struct strbuf
*dst
,
269 const char *src_repo
)
272 * Read from the source objects/info/alternates file
273 * and copy the entries to corresponding file in the
274 * destination repository with add_to_alternates_file().
275 * Both src and dst have "$path/objects/info/alternates".
277 * Instead of copying bit-for-bit from the original,
278 * we need to append to existing one so that the already
279 * created entry via "clone -s" is not lost, and also
280 * to turn entries with paths relative to the original
281 * absolute, so that they can be used in the new repository.
283 FILE *in
= fopen(src
->buf
, "r");
284 struct strbuf line
= STRBUF_INIT
;
286 while (strbuf_getline(&line
, in
, '\n') != EOF
) {
287 char *abs_path
, abs_buf
[PATH_MAX
];
288 if (!line
.len
|| line
.buf
[0] == '#')
290 if (is_absolute_path(line
.buf
)) {
291 add_to_alternates_file(line
.buf
);
294 abs_path
= mkpath("%s/objects/%s", src_repo
, line
.buf
);
295 normalize_path_copy(abs_buf
, abs_path
);
296 add_to_alternates_file(abs_buf
);
298 strbuf_release(&line
);
302 static void copy_or_link_directory(struct strbuf
*src
, struct strbuf
*dest
,
303 const char *src_repo
, int src_baselen
)
307 int src_len
, dest_len
;
310 dir
= opendir(src
->buf
);
312 die_errno(_("failed to open '%s'"), src
->buf
);
314 if (mkdir(dest
->buf
, 0777)) {
316 die_errno(_("failed to create directory '%s'"), dest
->buf
);
317 else if (stat(dest
->buf
, &buf
))
318 die_errno(_("failed to stat '%s'"), dest
->buf
);
319 else if (!S_ISDIR(buf
.st_mode
))
320 die(_("%s exists and is not a directory"), dest
->buf
);
323 strbuf_addch(src
, '/');
325 strbuf_addch(dest
, '/');
326 dest_len
= dest
->len
;
328 while ((de
= readdir(dir
)) != NULL
) {
329 strbuf_setlen(src
, src_len
);
330 strbuf_addstr(src
, de
->d_name
);
331 strbuf_setlen(dest
, dest_len
);
332 strbuf_addstr(dest
, de
->d_name
);
333 if (stat(src
->buf
, &buf
)) {
334 warning (_("failed to stat %s\n"), src
->buf
);
337 if (S_ISDIR(buf
.st_mode
)) {
338 if (de
->d_name
[0] != '.')
339 copy_or_link_directory(src
, dest
,
340 src_repo
, src_baselen
);
344 /* Files that cannot be copied bit-for-bit... */
345 if (!strcmp(src
->buf
+ src_baselen
, "/info/alternates")) {
346 copy_alternates(src
, dest
, src_repo
);
350 if (unlink(dest
->buf
) && errno
!= ENOENT
)
351 die_errno(_("failed to unlink '%s'"), dest
->buf
);
352 if (!option_no_hardlinks
) {
353 if (!link(src
->buf
, dest
->buf
))
355 if (option_local
> 0)
356 die_errno(_("failed to create link '%s'"), dest
->buf
);
357 option_no_hardlinks
= 1;
359 if (copy_file_with_time(dest
->buf
, src
->buf
, 0666))
360 die_errno(_("failed to copy file to '%s'"), dest
->buf
);
365 static void clone_local(const char *src_repo
, const char *dest_repo
)
368 struct strbuf alt
= STRBUF_INIT
;
369 strbuf_addf(&alt
, "%s/objects", src_repo
);
370 add_to_alternates_file(alt
.buf
);
371 strbuf_release(&alt
);
373 struct strbuf src
= STRBUF_INIT
;
374 struct strbuf dest
= STRBUF_INIT
;
375 strbuf_addf(&src
, "%s/objects", src_repo
);
376 strbuf_addf(&dest
, "%s/objects", dest_repo
);
377 copy_or_link_directory(&src
, &dest
, src_repo
, src
.len
);
378 strbuf_release(&src
);
379 strbuf_release(&dest
);
382 if (0 <= option_verbosity
)
383 fprintf(stderr
, _("done.\n"));
386 static const char *junk_work_tree
;
387 static const char *junk_git_dir
;
392 } junk_mode
= JUNK_LEAVE_NONE
;
394 static const char junk_leave_repo_msg
[] =
395 N_("Clone succeeded, but checkout failed.\n"
396 "You can inspect what was checked out with 'git status'\n"
397 "and retry the checkout with 'git checkout -f HEAD'\n");
399 static void remove_junk(void)
401 struct strbuf sb
= STRBUF_INIT
;
404 case JUNK_LEAVE_REPO
:
405 warning("%s", _(junk_leave_repo_msg
));
410 /* proceed to removal */
415 strbuf_addstr(&sb
, junk_git_dir
);
416 remove_dir_recursively(&sb
, 0);
419 if (junk_work_tree
) {
420 strbuf_addstr(&sb
, junk_work_tree
);
421 remove_dir_recursively(&sb
, 0);
426 static void remove_junk_on_signal(int signo
)
433 static struct ref
*find_remote_branch(const struct ref
*refs
, const char *branch
)
436 struct strbuf head
= STRBUF_INIT
;
437 strbuf_addstr(&head
, "refs/heads/");
438 strbuf_addstr(&head
, branch
);
439 ref
= find_ref_by_name(refs
, head
.buf
);
440 strbuf_release(&head
);
445 strbuf_addstr(&head
, "refs/tags/");
446 strbuf_addstr(&head
, branch
);
447 ref
= find_ref_by_name(refs
, head
.buf
);
448 strbuf_release(&head
);
453 static struct ref
*wanted_peer_refs(const struct ref
*refs
,
454 struct refspec
*refspec
)
456 struct ref
*head
= copy_ref(find_ref_by_name(refs
, "HEAD"));
457 struct ref
*local_refs
= head
;
458 struct ref
**tail
= head
? &head
->next
: &local_refs
;
460 if (option_single_branch
) {
461 struct ref
*remote_head
= NULL
;
464 remote_head
= guess_remote_head(head
, refs
, 0);
468 remote_head
= copy_ref(find_remote_branch(refs
, option_branch
));
471 if (!remote_head
&& option_branch
)
472 warning(_("Could not find remote branch %s to clone."),
475 get_fetch_map(remote_head
, refspec
, &tail
, 0);
477 /* if --branch=tag, pull the requested tag explicitly */
478 get_fetch_map(remote_head
, tag_refspec
, &tail
, 0);
481 get_fetch_map(refs
, refspec
, &tail
, 0);
483 if (!option_mirror
&& !option_single_branch
)
484 get_fetch_map(refs
, tag_refspec
, &tail
, 0);
489 static void write_remote_refs(const struct ref
*local_refs
)
493 lock_packed_refs(LOCK_DIE_ON_ERROR
);
495 for (r
= local_refs
; r
; r
= r
->next
) {
498 add_packed_ref(r
->peer_ref
->name
, r
->old_sha1
);
501 if (commit_packed_refs())
502 die_errno("unable to overwrite old ref-pack file");
505 static void write_followtags(const struct ref
*refs
, const char *msg
)
507 const struct ref
*ref
;
508 for (ref
= refs
; ref
; ref
= ref
->next
) {
509 if (!starts_with(ref
->name
, "refs/tags/"))
511 if (ends_with(ref
->name
, "^{}"))
513 if (!has_sha1_file(ref
->old_sha1
))
515 update_ref(msg
, ref
->name
, ref
->old_sha1
,
516 NULL
, 0, UPDATE_REFS_DIE_ON_ERR
);
520 static int iterate_ref_map(void *cb_data
, unsigned char sha1
[20])
522 struct ref
**rm
= cb_data
;
523 struct ref
*ref
= *rm
;
526 * Skip anything missing a peer_ref, which we are not
527 * actually going to write a ref for.
529 while (ref
&& !ref
->peer_ref
)
531 /* Returning -1 notes "end of list" to the caller. */
535 hashcpy(sha1
, ref
->old_sha1
);
540 static void update_remote_refs(const struct ref
*refs
,
541 const struct ref
*mapped_refs
,
542 const struct ref
*remote_head_points_at
,
543 const char *branch_top
,
545 struct transport
*transport
,
546 int check_connectivity
)
548 const struct ref
*rm
= mapped_refs
;
550 if (check_connectivity
) {
551 if (transport
->progress
)
552 fprintf(stderr
, _("Checking connectivity... "));
553 if (check_everything_connected_with_transport(iterate_ref_map
,
555 die(_("remote did not send all necessary objects"));
556 if (transport
->progress
)
557 fprintf(stderr
, _("done.\n"));
561 write_remote_refs(mapped_refs
);
562 if (option_single_branch
)
563 write_followtags(refs
, msg
);
566 if (remote_head_points_at
&& !option_bare
) {
567 struct strbuf head_ref
= STRBUF_INIT
;
568 strbuf_addstr(&head_ref
, branch_top
);
569 strbuf_addstr(&head_ref
, "HEAD");
570 create_symref(head_ref
.buf
,
571 remote_head_points_at
->peer_ref
->name
,
576 static void update_head(const struct ref
*our
, const struct ref
*remote
,
580 if (our
&& skip_prefix(our
->name
, "refs/heads/", &head
)) {
581 /* Local default branch link */
582 create_symref("HEAD", our
->name
, NULL
);
584 update_ref(msg
, "HEAD", our
->old_sha1
, NULL
, 0,
585 UPDATE_REFS_DIE_ON_ERR
);
586 install_branch_config(0, head
, option_origin
, our
->name
);
589 struct commit
*c
= lookup_commit_reference(our
->old_sha1
);
590 /* --branch specifies a non-branch (i.e. tags), detach HEAD */
591 update_ref(msg
, "HEAD", c
->object
.sha1
,
592 NULL
, REF_NODEREF
, UPDATE_REFS_DIE_ON_ERR
);
595 * We know remote HEAD points to a non-branch, or
596 * HEAD points to a branch but we don't know which one.
597 * Detach HEAD in all these cases.
599 update_ref(msg
, "HEAD", remote
->old_sha1
,
600 NULL
, REF_NODEREF
, UPDATE_REFS_DIE_ON_ERR
);
604 static int checkout(void)
606 unsigned char sha1
[20];
608 struct lock_file
*lock_file
;
609 struct unpack_trees_options opts
;
614 if (option_no_checkout
)
617 head
= resolve_refdup("HEAD", RESOLVE_REF_READING
, sha1
, NULL
);
619 warning(_("remote HEAD refers to nonexistent ref, "
620 "unable to checkout.\n"));
623 if (!strcmp(head
, "HEAD")) {
624 if (advice_detached_head
)
625 detach_advice(sha1_to_hex(sha1
));
627 if (!starts_with(head
, "refs/heads/"))
628 die(_("HEAD not found below refs/heads!"));
632 /* We need to be in the new work tree for the checkout */
635 lock_file
= xcalloc(1, sizeof(struct lock_file
));
636 hold_locked_index(lock_file
, 1);
638 memset(&opts
, 0, sizeof opts
);
641 opts
.fn
= oneway_merge
;
642 opts
.verbose_update
= (option_verbosity
>= 0);
643 opts
.src_index
= &the_index
;
644 opts
.dst_index
= &the_index
;
646 tree
= parse_tree_indirect(sha1
);
648 init_tree_desc(&t
, tree
->buffer
, tree
->size
);
649 if (unpack_trees(1, &t
, &opts
) < 0)
650 die(_("unable to checkout working tree"));
652 if (write_locked_index(&the_index
, lock_file
, COMMIT_LOCK
))
653 die(_("unable to write new index file"));
655 err
|= run_hook_le(NULL
, "post-checkout", sha1_to_hex(null_sha1
),
656 sha1_to_hex(sha1
), "1", NULL
);
658 if (!err
&& option_recursive
)
659 err
= run_command_v_opt(argv_submodule
, RUN_GIT_CMD
);
664 static int write_one_config(const char *key
, const char *value
, void *data
)
666 return git_config_set_multivar(key
, value
? value
: "true", "^$", 0);
669 static void write_config(struct string_list
*config
)
673 for (i
= 0; i
< config
->nr
; i
++) {
674 if (git_config_parse_parameter(config
->items
[i
].string
,
675 write_one_config
, NULL
) < 0)
676 die("unable to write parameters to config file");
680 static void write_refspec_config(const char *src_ref_prefix
,
681 const struct ref
*our_head_points_at
,
682 const struct ref
*remote_head_points_at
,
683 struct strbuf
*branch_top
)
685 struct strbuf key
= STRBUF_INIT
;
686 struct strbuf value
= STRBUF_INIT
;
688 if (option_mirror
|| !option_bare
) {
689 if (option_single_branch
&& !option_mirror
) {
691 if (starts_with(our_head_points_at
->name
, "refs/tags/"))
692 strbuf_addf(&value
, "+%s:%s", our_head_points_at
->name
,
693 our_head_points_at
->name
);
695 strbuf_addf(&value
, "+%s:%s%s", our_head_points_at
->name
,
696 branch_top
->buf
, option_branch
);
697 } else if (remote_head_points_at
) {
698 const char *head
= remote_head_points_at
->name
;
699 if (!skip_prefix(head
, "refs/heads/", &head
))
700 die("BUG: remote HEAD points at non-head?");
702 strbuf_addf(&value
, "+%s:%s%s", remote_head_points_at
->name
,
703 branch_top
->buf
, head
);
706 * otherwise, the next "git fetch" will
707 * simply fetch from HEAD without updating
708 * any remote-tracking branch, which is what
712 strbuf_addf(&value
, "+%s*:%s*", src_ref_prefix
, branch_top
->buf
);
714 /* Configure the remote */
716 strbuf_addf(&key
, "remote.%s.fetch", option_origin
);
717 git_config_set_multivar(key
.buf
, value
.buf
, "^$", 0);
721 strbuf_addf(&key
, "remote.%s.mirror", option_origin
);
722 git_config_set(key
.buf
, "true");
728 strbuf_release(&key
);
729 strbuf_release(&value
);
732 static void dissociate_from_references(void)
734 static const char* argv
[] = { "repack", "-a", "-d", NULL
};
736 if (run_command_v_opt(argv
, RUN_GIT_CMD
|RUN_COMMAND_NO_STDIN
))
737 die(_("cannot repack to clean up"));
738 if (unlink(git_path("objects/info/alternates")) && errno
!= ENOENT
)
739 die_errno(_("cannot unlink temporary alternates file"));
742 int cmd_clone(int argc
, const char **argv
, const char *prefix
)
744 int is_bundle
= 0, is_local
;
746 const char *repo_name
, *repo
, *work_tree
, *git_dir
;
749 const struct ref
*refs
, *remote_head
;
750 const struct ref
*remote_head_points_at
;
751 const struct ref
*our_head_points_at
;
752 struct ref
*mapped_refs
;
753 const struct ref
*ref
;
754 struct strbuf key
= STRBUF_INIT
, value
= STRBUF_INIT
;
755 struct strbuf branch_top
= STRBUF_INIT
, reflog_msg
= STRBUF_INIT
;
756 struct transport
*transport
= NULL
;
757 const char *src_ref_prefix
= "refs/heads/";
758 struct remote
*remote
;
759 int err
= 0, complete_refs_before_fetch
= 1;
761 struct refspec
*refspec
;
762 const char *fetch_pattern
;
764 packet_trace_identity("clone");
765 argc
= parse_options(argc
, argv
, prefix
, builtin_clone_options
,
766 builtin_clone_usage
, 0);
769 usage_msg_opt(_("Too many arguments."),
770 builtin_clone_usage
, builtin_clone_options
);
773 usage_msg_opt(_("You must specify a repository to clone."),
774 builtin_clone_usage
, builtin_clone_options
);
776 if (option_single_branch
== -1)
777 option_single_branch
= option_depth
? 1 : 0;
784 die(_("--bare and --origin %s options are incompatible."),
787 die(_("--bare and --separate-git-dir are incompatible."));
788 option_no_checkout
= 1;
792 option_origin
= "origin";
796 path
= get_repo_path(repo_name
, &is_bundle
);
798 repo
= xstrdup(absolute_path(repo_name
));
799 else if (!strchr(repo_name
, ':'))
800 die(_("repository '%s' does not exist"), repo_name
);
804 /* no need to be strict, transport_set_option() will validate it again */
805 if (option_depth
&& atoi(option_depth
) < 1)
806 die(_("depth %s is not a positive number"), option_depth
);
809 dir
= xstrdup(argv
[1]);
811 dir
= guess_dir_name(repo_name
, is_bundle
, option_bare
);
812 strip_trailing_slashes(dir
);
814 dest_exists
= !stat(dir
, &buf
);
815 if (dest_exists
&& !is_empty_dir(dir
))
816 die(_("destination path '%s' already exists and is not "
817 "an empty directory."), dir
);
819 strbuf_addf(&reflog_msg
, "clone: from %s", repo
);
824 work_tree
= getenv("GIT_WORK_TREE");
825 if (work_tree
&& !stat(work_tree
, &buf
))
826 die(_("working tree '%s' already exists."), work_tree
);
829 if (option_bare
|| work_tree
)
830 git_dir
= xstrdup(dir
);
833 git_dir
= mkpathdup("%s/.git", dir
);
837 sigchain_push_common(remove_junk_on_signal
);
840 if (safe_create_leading_directories_const(work_tree
) < 0)
841 die_errno(_("could not create leading directories of '%s'"),
843 if (!dest_exists
&& mkdir(work_tree
, 0777))
844 die_errno(_("could not create work tree dir '%s'"),
846 junk_work_tree
= work_tree
;
847 set_git_work_tree(work_tree
);
850 junk_git_dir
= git_dir
;
851 if (safe_create_leading_directories_const(git_dir
) < 0)
852 die(_("could not create leading directories of '%s'"), git_dir
);
854 set_git_dir_init(git_dir
, real_git_dir
, 0);
856 git_dir
= real_git_dir
;
857 junk_git_dir
= real_git_dir
;
860 if (0 <= option_verbosity
) {
862 fprintf(stderr
, _("Cloning into bare repository '%s'...\n"), dir
);
864 fprintf(stderr
, _("Cloning into '%s'...\n"), dir
);
866 init_db(option_template
, INIT_DB_QUIET
);
867 write_config(&option_config
);
869 git_config(git_default_config
, NULL
);
873 src_ref_prefix
= "refs/";
874 strbuf_addstr(&branch_top
, src_ref_prefix
);
876 git_config_set("core.bare", "true");
878 strbuf_addf(&branch_top
, "refs/remotes/%s/", option_origin
);
881 strbuf_addf(&value
, "+%s*:%s*", src_ref_prefix
, branch_top
.buf
);
882 strbuf_addf(&key
, "remote.%s.url", option_origin
);
883 git_config_set(key
.buf
, repo
);
886 if (option_reference
.nr
)
888 else if (option_dissociate
) {
889 warning(_("--dissociate given, but there is no --reference"));
890 option_dissociate
= 0;
893 fetch_pattern
= value
.buf
;
894 refspec
= parse_fetch_refspec(1, &fetch_pattern
);
896 strbuf_reset(&value
);
898 remote
= remote_get(option_origin
);
899 transport
= transport_get(remote
, remote
->url
[0]);
900 transport_set_verbosity(transport
, option_verbosity
, option_progress
);
902 path
= get_repo_path(remote
->url
[0], &is_bundle
);
903 is_local
= option_local
!= 0 && path
&& !is_bundle
;
906 warning(_("--depth is ignored in local clones; use file:// instead."));
907 if (!access(mkpath("%s/shallow", path
), F_OK
)) {
908 if (option_local
> 0)
909 warning(_("source repository is shallow, ignoring --local"));
913 if (option_local
> 0 && !is_local
)
914 warning(_("--local is ignored"));
915 transport
->cloning
= 1;
917 if (!transport
->get_refs_list
|| (!is_local
&& !transport
->fetch
))
918 die(_("Don't know how to clone %s"), transport
->url
);
920 transport_set_option(transport
, TRANS_OPT_KEEP
, "yes");
923 transport_set_option(transport
, TRANS_OPT_DEPTH
,
925 if (option_single_branch
)
926 transport_set_option(transport
, TRANS_OPT_FOLLOWTAGS
, "1");
928 if (option_upload_pack
)
929 transport_set_option(transport
, TRANS_OPT_UPLOADPACK
,
932 if (transport
->smart_options
&& !option_depth
)
933 transport
->smart_options
->check_self_contained_and_connected
= 1;
935 refs
= transport_get_remote_refs(transport
);
938 mapped_refs
= wanted_peer_refs(refs
, refspec
);
940 * transport_get_remote_refs() may return refs with null sha-1
941 * in mapped_refs (see struct transport->get_refs_list
942 * comment). In that case we need fetch it early because
943 * remote_head code below relies on it.
945 * for normal clones, transport_get_remote_refs() should
946 * return reliable ref set, we can delay cloning until after
949 for (ref
= refs
; ref
; ref
= ref
->next
)
950 if (is_null_sha1(ref
->old_sha1
)) {
951 complete_refs_before_fetch
= 0;
955 if (!is_local
&& !complete_refs_before_fetch
)
956 transport_fetch_refs(transport
, mapped_refs
);
958 remote_head
= find_ref_by_name(refs
, "HEAD");
959 remote_head_points_at
=
960 guess_remote_head(remote_head
, mapped_refs
, 0);
964 find_remote_branch(mapped_refs
, option_branch
);
966 if (!our_head_points_at
)
967 die(_("Remote branch %s not found in upstream %s"),
968 option_branch
, option_origin
);
971 our_head_points_at
= remote_head_points_at
;
975 die(_("Remote branch %s not found in upstream %s"),
976 option_branch
, option_origin
);
978 warning(_("You appear to have cloned an empty repository."));
980 our_head_points_at
= NULL
;
981 remote_head_points_at
= NULL
;
983 option_no_checkout
= 1;
985 install_branch_config(0, "master", option_origin
,
986 "refs/heads/master");
989 write_refspec_config(src_ref_prefix
, our_head_points_at
,
990 remote_head_points_at
, &branch_top
);
993 clone_local(path
, git_dir
);
994 else if (refs
&& complete_refs_before_fetch
)
995 transport_fetch_refs(transport
, mapped_refs
);
997 update_remote_refs(refs
, mapped_refs
, remote_head_points_at
,
998 branch_top
.buf
, reflog_msg
.buf
, transport
, !is_local
);
1000 update_head(our_head_points_at
, remote_head
, reflog_msg
.buf
);
1002 transport_unlock_pack(transport
);
1003 transport_disconnect(transport
);
1005 if (option_dissociate
)
1006 dissociate_from_references();
1008 junk_mode
= JUNK_LEAVE_REPO
;
1011 strbuf_release(&reflog_msg
);
1012 strbuf_release(&branch_top
);
1013 strbuf_release(&key
);
1014 strbuf_release(&value
);
1015 junk_mode
= JUNK_LEAVE_ALL
;