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.
12 #include "parse-options.h"
13 #include "fetch-pack.h"
16 #include "tree-walk.h"
17 #include "unpack-trees.h"
18 #include "transport.h"
21 #include "pack-refs.h"
25 #include "run-command.h"
29 * - respect DB_ENVIRONMENT for .git/objects.
31 * Implementation notes:
32 * - dropping use-separate-remote and no-separate-remote compatibility
35 static const char * const builtin_clone_usage
[] = {
36 "git clone [options] [--] <repo> [<dir>]",
40 static int option_no_checkout
, option_bare
, option_mirror
, option_single_branch
= -1;
41 static int option_local
, option_no_hardlinks
, option_shared
, option_recursive
;
42 static char *option_template
, *option_depth
;
43 static char *option_origin
= NULL
;
44 static char *option_branch
= NULL
;
45 static const char *real_git_dir
;
46 static char *option_upload_pack
= "git-upload-pack";
47 static int option_verbosity
;
48 static int option_progress
;
49 static struct string_list option_config
;
50 static struct string_list option_reference
;
52 static int opt_parse_reference(const struct option
*opt
, const char *arg
, int unset
)
54 struct string_list
*option_reference
= opt
->value
;
57 string_list_append(option_reference
, arg
);
61 static struct option builtin_clone_options
[] = {
62 OPT__VERBOSITY(&option_verbosity
),
63 OPT_BOOLEAN(0, "progress", &option_progress
,
64 "force progress reporting"),
65 OPT_BOOLEAN('n', "no-checkout", &option_no_checkout
,
66 "don't create a checkout"),
67 OPT_BOOLEAN(0, "bare", &option_bare
, "create a bare repository"),
68 { OPTION_BOOLEAN
, 0, "naked", &option_bare
, NULL
,
69 "create a bare repository",
70 PARSE_OPT_NOARG
| PARSE_OPT_HIDDEN
},
71 OPT_BOOLEAN(0, "mirror", &option_mirror
,
72 "create a mirror repository (implies bare)"),
73 OPT_BOOLEAN('l', "local", &option_local
,
74 "to clone from a local repository"),
75 OPT_BOOLEAN(0, "no-hardlinks", &option_no_hardlinks
,
76 "don't use local hardlinks, always copy"),
77 OPT_BOOLEAN('s', "shared", &option_shared
,
78 "setup as shared repository"),
79 OPT_BOOLEAN(0, "recursive", &option_recursive
,
80 "initialize submodules in the clone"),
81 OPT_BOOLEAN(0, "recurse-submodules", &option_recursive
,
82 "initialize submodules in the clone"),
83 OPT_STRING(0, "template", &option_template
, "template-directory",
84 "directory from which templates will be used"),
85 OPT_CALLBACK(0 , "reference", &option_reference
, "repo",
86 "reference repository", &opt_parse_reference
),
87 OPT_STRING('o', "origin", &option_origin
, "name",
88 "use <name> instead of 'origin' to track upstream"),
89 OPT_STRING('b', "branch", &option_branch
, "branch",
90 "checkout <branch> instead of the remote's HEAD"),
91 OPT_STRING('u', "upload-pack", &option_upload_pack
, "path",
92 "path to git-upload-pack on the remote"),
93 OPT_STRING(0, "depth", &option_depth
, "depth",
94 "create a shallow clone of that depth"),
95 OPT_BOOL(0, "single-branch", &option_single_branch
,
96 "clone only one branch, HEAD or --branch"),
97 OPT_STRING(0, "separate-git-dir", &real_git_dir
, "gitdir",
98 "separate git dir from working tree"),
99 OPT_STRING_LIST('c', "config", &option_config
, "key=value",
100 "set config inside the new repository"),
104 static const char *argv_submodule
[] = {
105 "submodule", "update", "--init", "--recursive", NULL
108 static char *get_repo_path(const char *repo
, int *is_bundle
)
110 static char *suffix
[] = { "/.git", ".git", "" };
111 static char *bundle_suffix
[] = { ".bundle", "" };
115 for (i
= 0; i
< ARRAY_SIZE(suffix
); i
++) {
117 path
= mkpath("%s%s", repo
, suffix
[i
]);
120 if (S_ISDIR(st
.st_mode
)) {
122 return xstrdup(absolute_path(path
));
123 } else if (S_ISREG(st
.st_mode
) && st
.st_size
> 8) {
124 /* Is it a "gitfile"? */
126 int len
, fd
= open(path
, O_RDONLY
);
129 len
= read_in_full(fd
, signature
, 8);
131 if (len
!= 8 || strncmp(signature
, "gitdir: ", 8))
133 path
= read_gitfile(path
);
136 return xstrdup(absolute_path(path
));
141 for (i
= 0; i
< ARRAY_SIZE(bundle_suffix
); i
++) {
143 path
= mkpath("%s%s", repo
, bundle_suffix
[i
]);
144 if (!stat(path
, &st
) && S_ISREG(st
.st_mode
)) {
146 return xstrdup(absolute_path(path
));
153 static char *guess_dir_name(const char *repo
, int is_bundle
, int is_bare
)
155 const char *end
= repo
+ strlen(repo
), *start
;
159 * Strip trailing spaces, slashes and /.git
161 while (repo
< end
&& (is_dir_sep(end
[-1]) || isspace(end
[-1])))
163 if (end
- repo
> 5 && is_dir_sep(end
[-5]) &&
164 !strncmp(end
- 4, ".git", 4)) {
166 while (repo
< end
&& is_dir_sep(end
[-1]))
171 * Find last component, but be prepared that repo could have
172 * the form "remote.example.com:foo.git", i.e. no slash
173 * in the directory part.
176 while (repo
< start
&& !is_dir_sep(start
[-1]) && start
[-1] != ':')
180 * Strip .{bundle,git}.
183 if (end
- start
> 7 && !strncmp(end
- 7, ".bundle", 7))
186 if (end
- start
> 4 && !strncmp(end
- 4, ".git", 4))
191 struct strbuf result
= STRBUF_INIT
;
192 strbuf_addf(&result
, "%.*s.git", (int)(end
- start
), start
);
193 dir
= strbuf_detach(&result
, NULL
);
195 dir
= xstrndup(start
, end
- start
);
197 * Replace sequences of 'control' characters and whitespace
198 * with one ascii space, remove leading and trailing spaces.
202 int prev_space
= 1 /* strip leading whitespace */;
203 for (end
= dir
; *end
; ++end
) {
205 if ((unsigned char)ch
< '\x20')
216 if (out
> dir
&& prev_space
)
222 static void strip_trailing_slashes(char *dir
)
224 char *end
= dir
+ strlen(dir
);
226 while (dir
< end
- 1 && is_dir_sep(end
[-1]))
231 static int add_one_reference(struct string_list_item
*item
, void *cb_data
)
234 struct strbuf alternate
= STRBUF_INIT
;
235 struct remote
*remote
;
236 struct transport
*transport
;
237 const struct ref
*extra
;
239 /* Beware: real_path() and mkpath() return static buffer */
240 ref_git
= xstrdup(real_path(item
->string
));
241 if (is_directory(mkpath("%s/.git/objects", ref_git
))) {
242 char *ref_git_git
= xstrdup(mkpath("%s/.git", ref_git
));
244 ref_git
= ref_git_git
;
245 } else if (!is_directory(mkpath("%s/objects", ref_git
)))
246 die(_("reference repository '%s' is not a local directory."),
249 strbuf_addf(&alternate
, "%s/objects", ref_git
);
250 add_to_alternates_file(alternate
.buf
);
251 strbuf_release(&alternate
);
253 remote
= remote_get(ref_git
);
254 transport
= transport_get(remote
, ref_git
);
255 for (extra
= transport_get_remote_refs(transport
); extra
;
257 add_extra_ref(extra
->name
, extra
->old_sha1
, 0);
259 transport_disconnect(transport
);
264 static void setup_reference(void)
266 for_each_string_list(&option_reference
, add_one_reference
, NULL
);
269 static void copy_alternates(struct strbuf
*src
, struct strbuf
*dst
,
270 const char *src_repo
)
273 * Read from the source objects/info/alternates file
274 * and copy the entries to corresponding file in the
275 * destination repository with add_to_alternates_file().
276 * Both src and dst have "$path/objects/info/alternates".
278 * Instead of copying bit-for-bit from the original,
279 * we need to append to existing one so that the already
280 * created entry via "clone -s" is not lost, and also
281 * to turn entries with paths relative to the original
282 * absolute, so that they can be used in the new repository.
284 FILE *in
= fopen(src
->buf
, "r");
285 struct strbuf line
= STRBUF_INIT
;
287 while (strbuf_getline(&line
, in
, '\n') != EOF
) {
288 char *abs_path
, abs_buf
[PATH_MAX
];
289 if (!line
.len
|| line
.buf
[0] == '#')
291 if (is_absolute_path(line
.buf
)) {
292 add_to_alternates_file(line
.buf
);
295 abs_path
= mkpath("%s/objects/%s", src_repo
, line
.buf
);
296 normalize_path_copy(abs_buf
, abs_path
);
297 add_to_alternates_file(abs_buf
);
299 strbuf_release(&line
);
303 static void copy_or_link_directory(struct strbuf
*src
, struct strbuf
*dest
,
304 const char *src_repo
, int src_baselen
)
308 int src_len
, dest_len
;
311 dir
= opendir(src
->buf
);
313 die_errno(_("failed to open '%s'"), src
->buf
);
315 if (mkdir(dest
->buf
, 0777)) {
317 die_errno(_("failed to create directory '%s'"), dest
->buf
);
318 else if (stat(dest
->buf
, &buf
))
319 die_errno(_("failed to stat '%s'"), dest
->buf
);
320 else if (!S_ISDIR(buf
.st_mode
))
321 die(_("%s exists and is not a directory"), dest
->buf
);
324 strbuf_addch(src
, '/');
326 strbuf_addch(dest
, '/');
327 dest_len
= dest
->len
;
329 while ((de
= readdir(dir
)) != NULL
) {
330 strbuf_setlen(src
, src_len
);
331 strbuf_addstr(src
, de
->d_name
);
332 strbuf_setlen(dest
, dest_len
);
333 strbuf_addstr(dest
, de
->d_name
);
334 if (stat(src
->buf
, &buf
)) {
335 warning (_("failed to stat %s\n"), src
->buf
);
338 if (S_ISDIR(buf
.st_mode
)) {
339 if (de
->d_name
[0] != '.')
340 copy_or_link_directory(src
, dest
,
341 src_repo
, src_baselen
);
345 /* Files that cannot be copied bit-for-bit... */
346 if (!strcmp(src
->buf
+ src_baselen
, "/info/alternates")) {
347 copy_alternates(src
, dest
, src_repo
);
351 if (unlink(dest
->buf
) && errno
!= ENOENT
)
352 die_errno(_("failed to unlink '%s'"), dest
->buf
);
353 if (!option_no_hardlinks
) {
354 if (!link(src
->buf
, dest
->buf
))
357 die_errno(_("failed to create link '%s'"), dest
->buf
);
358 option_no_hardlinks
= 1;
360 if (copy_file_with_time(dest
->buf
, src
->buf
, 0666))
361 die_errno(_("failed to copy file to '%s'"), dest
->buf
);
366 static void clone_local(const char *src_repo
, const char *dest_repo
)
369 struct strbuf alt
= STRBUF_INIT
;
370 strbuf_addf(&alt
, "%s/objects", src_repo
);
371 add_to_alternates_file(alt
.buf
);
372 strbuf_release(&alt
);
374 struct strbuf src
= STRBUF_INIT
;
375 struct strbuf dest
= STRBUF_INIT
;
376 strbuf_addf(&src
, "%s/objects", src_repo
);
377 strbuf_addf(&dest
, "%s/objects", dest_repo
);
378 copy_or_link_directory(&src
, &dest
, src_repo
, src
.len
);
379 strbuf_release(&src
);
380 strbuf_release(&dest
);
383 if (0 <= option_verbosity
)
384 printf(_("done.\n"));
387 static const char *junk_work_tree
;
388 static const char *junk_git_dir
;
389 static pid_t junk_pid
;
391 static void remove_junk(void)
393 struct strbuf sb
= STRBUF_INIT
;
394 if (getpid() != junk_pid
)
397 strbuf_addstr(&sb
, junk_git_dir
);
398 remove_dir_recursively(&sb
, 0);
401 if (junk_work_tree
) {
402 strbuf_addstr(&sb
, junk_work_tree
);
403 remove_dir_recursively(&sb
, 0);
408 static void remove_junk_on_signal(int signo
)
415 static struct ref
*find_remote_branch(const struct ref
*refs
, const char *branch
)
418 struct strbuf head
= STRBUF_INIT
;
419 strbuf_addstr(&head
, "refs/heads/");
420 strbuf_addstr(&head
, branch
);
421 ref
= find_ref_by_name(refs
, head
.buf
);
422 strbuf_release(&head
);
427 strbuf_addstr(&head
, "refs/tags/");
428 strbuf_addstr(&head
, branch
);
429 ref
= find_ref_by_name(refs
, head
.buf
);
430 strbuf_release(&head
);
435 static struct ref
*wanted_peer_refs(const struct ref
*refs
,
436 struct refspec
*refspec
)
438 struct ref
*head
= copy_ref(find_ref_by_name(refs
, "HEAD"));
439 struct ref
*local_refs
= head
;
440 struct ref
**tail
= head
? &head
->next
: &local_refs
;
442 if (option_single_branch
) {
443 struct ref
*remote_head
= NULL
;
446 remote_head
= guess_remote_head(head
, refs
, 0);
448 remote_head
= find_remote_branch(refs
, option_branch
);
450 if (!remote_head
&& option_branch
)
451 warning(_("Could not find remote branch %s to clone."),
454 get_fetch_map(remote_head
, refspec
, &tail
, 0);
456 /* if --branch=tag, pull the requested tag explicitly */
457 get_fetch_map(remote_head
, tag_refspec
, &tail
, 0);
460 get_fetch_map(refs
, refspec
, &tail
, 0);
462 if (!option_mirror
&& !option_single_branch
)
463 get_fetch_map(refs
, tag_refspec
, &tail
, 0);
468 static void write_remote_refs(const struct ref
*local_refs
)
472 for (r
= local_refs
; r
; r
= r
->next
) {
475 add_packed_ref(r
->peer_ref
->name
, r
->old_sha1
);
478 pack_refs(PACK_REFS_ALL
);
481 static void write_followtags(const struct ref
*refs
, const char *msg
)
483 const struct ref
*ref
;
484 for (ref
= refs
; ref
; ref
= ref
->next
) {
485 if (prefixcmp(ref
->name
, "refs/tags/"))
487 if (!suffixcmp(ref
->name
, "^{}"))
489 if (!has_sha1_file(ref
->old_sha1
))
491 update_ref(msg
, ref
->name
, ref
->old_sha1
,
492 NULL
, 0, DIE_ON_ERR
);
496 static void update_remote_refs(const struct ref
*refs
,
497 const struct ref
*mapped_refs
,
498 const struct ref
*remote_head_points_at
,
499 const char *branch_top
,
504 write_remote_refs(mapped_refs
);
505 if (option_single_branch
)
506 write_followtags(refs
, msg
);
509 if (remote_head_points_at
&& !option_bare
) {
510 struct strbuf head_ref
= STRBUF_INIT
;
511 strbuf_addstr(&head_ref
, branch_top
);
512 strbuf_addstr(&head_ref
, "HEAD");
513 create_symref(head_ref
.buf
,
514 remote_head_points_at
->peer_ref
->name
,
519 static void update_head(const struct ref
*our
, const struct ref
*remote
,
522 if (our
&& !prefixcmp(our
->name
, "refs/heads/")) {
523 /* Local default branch link */
524 create_symref("HEAD", our
->name
, NULL
);
526 const char *head
= skip_prefix(our
->name
, "refs/heads/");
527 update_ref(msg
, "HEAD", our
->old_sha1
, NULL
, 0, DIE_ON_ERR
);
528 install_branch_config(0, head
, option_origin
, our
->name
);
531 struct commit
*c
= lookup_commit_reference(our
->old_sha1
);
532 /* --branch specifies a non-branch (i.e. tags), detach HEAD */
533 update_ref(msg
, "HEAD", c
->object
.sha1
,
534 NULL
, REF_NODEREF
, DIE_ON_ERR
);
537 * We know remote HEAD points to a non-branch, or
538 * HEAD points to a branch but we don't know which one.
539 * Detach HEAD in all these cases.
541 update_ref(msg
, "HEAD", remote
->old_sha1
,
542 NULL
, REF_NODEREF
, DIE_ON_ERR
);
546 static int checkout(void)
548 unsigned char sha1
[20];
550 struct lock_file
*lock_file
;
551 struct unpack_trees_options opts
;
556 if (option_no_checkout
)
559 head
= resolve_refdup("HEAD", sha1
, 1, NULL
);
561 warning(_("remote HEAD refers to nonexistent ref, "
562 "unable to checkout.\n"));
565 if (!strcmp(head
, "HEAD")) {
566 if (advice_detached_head
)
567 detach_advice(sha1_to_hex(sha1
));
569 if (prefixcmp(head
, "refs/heads/"))
570 die(_("HEAD not found below refs/heads!"));
574 /* We need to be in the new work tree for the checkout */
577 lock_file
= xcalloc(1, sizeof(struct lock_file
));
578 fd
= hold_locked_index(lock_file
, 1);
580 memset(&opts
, 0, sizeof opts
);
583 opts
.fn
= oneway_merge
;
584 opts
.verbose_update
= (option_verbosity
> 0);
585 opts
.src_index
= &the_index
;
586 opts
.dst_index
= &the_index
;
588 tree
= parse_tree_indirect(sha1
);
590 init_tree_desc(&t
, tree
->buffer
, tree
->size
);
591 unpack_trees(1, &t
, &opts
);
593 if (write_cache(fd
, active_cache
, active_nr
) ||
594 commit_locked_index(lock_file
))
595 die(_("unable to write new index file"));
597 err
|= run_hook(NULL
, "post-checkout", sha1_to_hex(null_sha1
),
598 sha1_to_hex(sha1
), "1", NULL
);
600 if (!err
&& option_recursive
)
601 err
= run_command_v_opt(argv_submodule
, RUN_GIT_CMD
);
606 static int write_one_config(const char *key
, const char *value
, void *data
)
608 return git_config_set_multivar(key
, value
? value
: "true", "^$", 0);
611 static void write_config(struct string_list
*config
)
615 for (i
= 0; i
< config
->nr
; i
++) {
616 if (git_config_parse_parameter(config
->items
[i
].string
,
617 write_one_config
, NULL
) < 0)
618 die("unable to write parameters to config file");
622 int cmd_clone(int argc
, const char **argv
, const char *prefix
)
624 int is_bundle
= 0, is_local
;
626 const char *repo_name
, *repo
, *work_tree
, *git_dir
;
629 const struct ref
*refs
, *remote_head
;
630 const struct ref
*remote_head_points_at
;
631 const struct ref
*our_head_points_at
;
632 struct ref
*mapped_refs
;
633 const struct ref
*ref
;
634 struct strbuf key
= STRBUF_INIT
, value
= STRBUF_INIT
;
635 struct strbuf branch_top
= STRBUF_INIT
, reflog_msg
= STRBUF_INIT
;
636 struct transport
*transport
= NULL
;
637 const char *src_ref_prefix
= "refs/heads/";
638 struct remote
*remote
;
639 int err
= 0, complete_refs_before_fetch
= 1;
641 struct refspec
*refspec
;
642 const char *fetch_pattern
;
646 packet_trace_identity("clone");
647 argc
= parse_options(argc
, argv
, prefix
, builtin_clone_options
,
648 builtin_clone_usage
, 0);
651 usage_msg_opt(_("Too many arguments."),
652 builtin_clone_usage
, builtin_clone_options
);
655 usage_msg_opt(_("You must specify a repository to clone."),
656 builtin_clone_usage
, builtin_clone_options
);
658 if (option_single_branch
== -1)
659 option_single_branch
= option_depth
? 1 : 0;
666 die(_("--bare and --origin %s options are incompatible."),
668 option_no_checkout
= 1;
672 option_origin
= "origin";
676 path
= get_repo_path(repo_name
, &is_bundle
);
678 repo
= xstrdup(absolute_path(repo_name
));
679 else if (!strchr(repo_name
, ':'))
680 die(_("repository '%s' does not exist"), repo_name
);
683 is_local
= path
&& !is_bundle
;
684 if (is_local
&& option_depth
)
685 warning(_("--depth is ignored in local clones; use file:// instead."));
688 dir
= xstrdup(argv
[1]);
690 dir
= guess_dir_name(repo_name
, is_bundle
, option_bare
);
691 strip_trailing_slashes(dir
);
693 dest_exists
= !stat(dir
, &buf
);
694 if (dest_exists
&& !is_empty_dir(dir
))
695 die(_("destination path '%s' already exists and is not "
696 "an empty directory."), dir
);
698 strbuf_addf(&reflog_msg
, "clone: from %s", repo
);
703 work_tree
= getenv("GIT_WORK_TREE");
704 if (work_tree
&& !stat(work_tree
, &buf
))
705 die(_("working tree '%s' already exists."), work_tree
);
708 if (option_bare
|| work_tree
)
709 git_dir
= xstrdup(dir
);
712 git_dir
= xstrdup(mkpath("%s/.git", dir
));
716 junk_work_tree
= work_tree
;
717 if (safe_create_leading_directories_const(work_tree
) < 0)
718 die_errno(_("could not create leading directories of '%s'"),
720 if (!dest_exists
&& mkdir(work_tree
, 0755))
721 die_errno(_("could not create work tree dir '%s'."),
723 set_git_work_tree(work_tree
);
725 junk_git_dir
= git_dir
;
727 sigchain_push_common(remove_junk_on_signal
);
729 setenv(CONFIG_ENVIRONMENT
, mkpath("%s/config", git_dir
), 1);
731 if (safe_create_leading_directories_const(git_dir
) < 0)
732 die(_("could not create leading directories of '%s'"), git_dir
);
734 set_git_dir_init(git_dir
, real_git_dir
, 0);
736 git_dir
= real_git_dir
;
738 if (0 <= option_verbosity
) {
740 printf(_("Cloning into bare repository '%s'...\n"), dir
);
742 printf(_("Cloning into '%s'...\n"), dir
);
744 init_db(option_template
, INIT_DB_QUIET
);
745 write_config(&option_config
);
748 * At this point, the config exists, so we do not need the
749 * environment variable. We actually need to unset it, too, to
750 * re-enable parsing of the global configs.
752 unsetenv(CONFIG_ENVIRONMENT
);
754 git_config(git_default_config
, NULL
);
758 src_ref_prefix
= "refs/";
759 strbuf_addstr(&branch_top
, src_ref_prefix
);
761 git_config_set("core.bare", "true");
763 strbuf_addf(&branch_top
, "refs/remotes/%s/", option_origin
);
766 strbuf_addf(&value
, "+%s*:%s*", src_ref_prefix
, branch_top
.buf
);
768 if (option_mirror
|| !option_bare
) {
769 /* Configure the remote */
770 strbuf_addf(&key
, "remote.%s.fetch", option_origin
);
771 git_config_set_multivar(key
.buf
, value
.buf
, "^$", 0);
775 strbuf_addf(&key
, "remote.%s.mirror", option_origin
);
776 git_config_set(key
.buf
, "true");
781 strbuf_addf(&key
, "remote.%s.url", option_origin
);
782 git_config_set(key
.buf
, repo
);
785 if (option_reference
.nr
)
788 fetch_pattern
= value
.buf
;
789 refspec
= parse_fetch_refspec(1, &fetch_pattern
);
791 strbuf_reset(&value
);
793 remote
= remote_get(option_origin
);
794 transport
= transport_get(remote
, remote
->url
[0]);
797 if (!transport
->get_refs_list
|| !transport
->fetch
)
798 die(_("Don't know how to clone %s"), transport
->url
);
800 transport_set_option(transport
, TRANS_OPT_KEEP
, "yes");
803 transport_set_option(transport
, TRANS_OPT_DEPTH
,
805 if (option_single_branch
)
806 transport_set_option(transport
, TRANS_OPT_FOLLOWTAGS
, "1");
808 transport_set_verbosity(transport
, option_verbosity
, option_progress
);
810 if (option_upload_pack
)
811 transport_set_option(transport
, TRANS_OPT_UPLOADPACK
,
815 refs
= transport_get_remote_refs(transport
);
818 mapped_refs
= wanted_peer_refs(refs
, refspec
);
820 * transport_get_remote_refs() may return refs with null sha-1
821 * in mapped_refs (see struct transport->get_refs_list
822 * comment). In that case we need fetch it early because
823 * remote_head code below relies on it.
825 * for normal clones, transport_get_remote_refs() should
826 * return reliable ref set, we can delay cloning until after
829 for (ref
= refs
; ref
; ref
= ref
->next
)
830 if (is_null_sha1(ref
->old_sha1
)) {
831 complete_refs_before_fetch
= 0;
835 if (!is_local
&& !complete_refs_before_fetch
)
836 transport_fetch_refs(transport
, mapped_refs
);
838 remote_head
= find_ref_by_name(refs
, "HEAD");
839 remote_head_points_at
=
840 guess_remote_head(remote_head
, mapped_refs
, 0);
844 find_remote_branch(mapped_refs
, option_branch
);
846 if (!our_head_points_at
)
847 die(_("Remote branch %s not found in upstream %s"),
848 option_branch
, option_origin
);
851 our_head_points_at
= remote_head_points_at
;
854 warning(_("You appear to have cloned an empty repository."));
856 our_head_points_at
= NULL
;
857 remote_head_points_at
= NULL
;
859 option_no_checkout
= 1;
861 install_branch_config(0, "master", option_origin
,
862 "refs/heads/master");
866 clone_local(path
, git_dir
);
867 else if (refs
&& complete_refs_before_fetch
)
868 transport_fetch_refs(transport
, mapped_refs
);
870 update_remote_refs(refs
, mapped_refs
, remote_head_points_at
,
871 branch_top
.buf
, reflog_msg
.buf
);
873 update_head(our_head_points_at
, remote_head
, reflog_msg
.buf
);
875 transport_unlock_pack(transport
);
876 transport_disconnect(transport
);
880 strbuf_release(&reflog_msg
);
881 strbuf_release(&branch_top
);
882 strbuf_release(&key
);
883 strbuf_release(&value
);