Merge branch 'da/maint-mergetool-twoway'
[git] / builtin / clone.c
1 /*
2  * Builtin "git clone"
3  *
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
7  *
8  * Clone a repository into a different directory that does not yet exist.
9  */
10
11 #include "builtin.h"
12 #include "parse-options.h"
13 #include "fetch-pack.h"
14 #include "refs.h"
15 #include "tree.h"
16 #include "tree-walk.h"
17 #include "unpack-trees.h"
18 #include "transport.h"
19 #include "strbuf.h"
20 #include "dir.h"
21 #include "pack-refs.h"
22 #include "sigchain.h"
23 #include "branch.h"
24 #include "remote.h"
25 #include "run-command.h"
26
27 /*
28  * Overall FIXMEs:
29  *  - respect DB_ENVIRONMENT for .git/objects.
30  *
31  * Implementation notes:
32  *  - dropping use-separate-remote and no-separate-remote compatibility
33  *
34  */
35 static const char * const builtin_clone_usage[] = {
36         "git clone [options] [--] <repo> [<dir>]",
37         NULL
38 };
39
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;
51 static const char *src_ref_prefix = "refs/heads/";
52
53 static int opt_parse_reference(const struct option *opt, const char *arg, int unset)
54 {
55         struct string_list *option_reference = opt->value;
56         if (!arg)
57                 return -1;
58         string_list_append(option_reference, arg);
59         return 0;
60 }
61
62 static struct option builtin_clone_options[] = {
63         OPT__VERBOSITY(&option_verbosity),
64         OPT_BOOLEAN(0, "progress", &option_progress,
65                         "force progress reporting"),
66         OPT_BOOLEAN('n', "no-checkout", &option_no_checkout,
67                     "don't create a checkout"),
68         OPT_BOOLEAN(0, "bare", &option_bare, "create a bare repository"),
69         { OPTION_BOOLEAN, 0, "naked", &option_bare, NULL,
70                 "create a bare repository",
71                 PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
72         OPT_BOOLEAN(0, "mirror", &option_mirror,
73                     "create a mirror repository (implies bare)"),
74         OPT_BOOLEAN('l', "local", &option_local,
75                     "to clone from a local repository"),
76         OPT_BOOLEAN(0, "no-hardlinks", &option_no_hardlinks,
77                     "don't use local hardlinks, always copy"),
78         OPT_BOOLEAN('s', "shared", &option_shared,
79                     "setup as shared repository"),
80         OPT_BOOLEAN(0, "recursive", &option_recursive,
81                     "initialize submodules in the clone"),
82         OPT_BOOLEAN(0, "recurse-submodules", &option_recursive,
83                     "initialize submodules in the clone"),
84         OPT_STRING(0, "template", &option_template, "template-directory",
85                    "directory from which templates will be used"),
86         OPT_CALLBACK(0 , "reference", &option_reference, "repo",
87                      "reference repository", &opt_parse_reference),
88         OPT_STRING('o', "origin", &option_origin, "name",
89                    "use <name> instead of 'origin' to track upstream"),
90         OPT_STRING('b', "branch", &option_branch, "branch",
91                    "checkout <branch> instead of the remote's HEAD"),
92         OPT_STRING('u', "upload-pack", &option_upload_pack, "path",
93                    "path to git-upload-pack on the remote"),
94         OPT_STRING(0, "depth", &option_depth, "depth",
95                     "create a shallow clone of that depth"),
96         OPT_BOOL(0, "single-branch", &option_single_branch,
97                     "clone only one branch, HEAD or --branch"),
98         OPT_STRING(0, "separate-git-dir", &real_git_dir, "gitdir",
99                    "separate git dir from working tree"),
100         OPT_STRING_LIST('c', "config", &option_config, "key=value",
101                         "set config inside the new repository"),
102         OPT_END()
103 };
104
105 static const char *argv_submodule[] = {
106         "submodule", "update", "--init", "--recursive", NULL
107 };
108
109 static char *get_repo_path(const char *repo, int *is_bundle)
110 {
111         static char *suffix[] = { "/.git", ".git", "" };
112         static char *bundle_suffix[] = { ".bundle", "" };
113         struct stat st;
114         int i;
115
116         for (i = 0; i < ARRAY_SIZE(suffix); i++) {
117                 const char *path;
118                 path = mkpath("%s%s", repo, suffix[i]);
119                 if (stat(path, &st))
120                         continue;
121                 if (S_ISDIR(st.st_mode)) {
122                         *is_bundle = 0;
123                         return xstrdup(absolute_path(path));
124                 } else if (S_ISREG(st.st_mode) && st.st_size > 8) {
125                         /* Is it a "gitfile"? */
126                         char signature[8];
127                         int len, fd = open(path, O_RDONLY);
128                         if (fd < 0)
129                                 continue;
130                         len = read_in_full(fd, signature, 8);
131                         close(fd);
132                         if (len != 8 || strncmp(signature, "gitdir: ", 8))
133                                 continue;
134                         path = read_gitfile(path);
135                         if (path) {
136                                 *is_bundle = 0;
137                                 return xstrdup(absolute_path(path));
138                         }
139                 }
140         }
141
142         for (i = 0; i < ARRAY_SIZE(bundle_suffix); i++) {
143                 const char *path;
144                 path = mkpath("%s%s", repo, bundle_suffix[i]);
145                 if (!stat(path, &st) && S_ISREG(st.st_mode)) {
146                         *is_bundle = 1;
147                         return xstrdup(absolute_path(path));
148                 }
149         }
150
151         return NULL;
152 }
153
154 static char *guess_dir_name(const char *repo, int is_bundle, int is_bare)
155 {
156         const char *end = repo + strlen(repo), *start;
157         char *dir;
158
159         /*
160          * Strip trailing spaces, slashes and /.git
161          */
162         while (repo < end && (is_dir_sep(end[-1]) || isspace(end[-1])))
163                 end--;
164         if (end - repo > 5 && is_dir_sep(end[-5]) &&
165             !strncmp(end - 4, ".git", 4)) {
166                 end -= 5;
167                 while (repo < end && is_dir_sep(end[-1]))
168                         end--;
169         }
170
171         /*
172          * Find last component, but be prepared that repo could have
173          * the form  "remote.example.com:foo.git", i.e. no slash
174          * in the directory part.
175          */
176         start = end;
177         while (repo < start && !is_dir_sep(start[-1]) && start[-1] != ':')
178                 start--;
179
180         /*
181          * Strip .{bundle,git}.
182          */
183         if (is_bundle) {
184                 if (end - start > 7 && !strncmp(end - 7, ".bundle", 7))
185                         end -= 7;
186         } else {
187                 if (end - start > 4 && !strncmp(end - 4, ".git", 4))
188                         end -= 4;
189         }
190
191         if (is_bare) {
192                 struct strbuf result = STRBUF_INIT;
193                 strbuf_addf(&result, "%.*s.git", (int)(end - start), start);
194                 dir = strbuf_detach(&result, NULL);
195         } else
196                 dir = xstrndup(start, end - start);
197         /*
198          * Replace sequences of 'control' characters and whitespace
199          * with one ascii space, remove leading and trailing spaces.
200          */
201         if (*dir) {
202                 char *out = dir;
203                 int prev_space = 1 /* strip leading whitespace */;
204                 for (end = dir; *end; ++end) {
205                         char ch = *end;
206                         if ((unsigned char)ch < '\x20')
207                                 ch = '\x20';
208                         if (isspace(ch)) {
209                                 if (prev_space)
210                                         continue;
211                                 prev_space = 1;
212                         } else
213                                 prev_space = 0;
214                         *out++ = ch;
215                 }
216                 *out = '\0';
217                 if (out > dir && prev_space)
218                         out[-1] = '\0';
219         }
220         return dir;
221 }
222
223 static void strip_trailing_slashes(char *dir)
224 {
225         char *end = dir + strlen(dir);
226
227         while (dir < end - 1 && is_dir_sep(end[-1]))
228                 end--;
229         *end = '\0';
230 }
231
232 static int add_one_reference(struct string_list_item *item, void *cb_data)
233 {
234         char *ref_git;
235         struct strbuf alternate = STRBUF_INIT;
236         struct remote *remote;
237         struct transport *transport;
238         const struct ref *extra;
239
240         /* Beware: real_path() and mkpath() return static buffer */
241         ref_git = xstrdup(real_path(item->string));
242         if (is_directory(mkpath("%s/.git/objects", ref_git))) {
243                 char *ref_git_git = xstrdup(mkpath("%s/.git", ref_git));
244                 free(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 directory."),
248                     item->string);
249
250         strbuf_addf(&alternate, "%s/objects", ref_git);
251         add_to_alternates_file(alternate.buf);
252         strbuf_release(&alternate);
253
254         remote = remote_get(ref_git);
255         transport = transport_get(remote, ref_git);
256         for (extra = transport_get_remote_refs(transport); extra;
257              extra = extra->next)
258                 add_extra_ref(extra->name, extra->old_sha1, 0);
259
260         transport_disconnect(transport);
261         free(ref_git);
262         return 0;
263 }
264
265 static void setup_reference(void)
266 {
267         for_each_string_list(&option_reference, add_one_reference, NULL);
268 }
269
270 static void copy_alternates(struct strbuf *src, struct strbuf *dst,
271                             const char *src_repo)
272 {
273         /*
274          * Read from the source objects/info/alternates file
275          * and copy the entries to corresponding file in the
276          * destination repository with add_to_alternates_file().
277          * Both src and dst have "$path/objects/info/alternates".
278          *
279          * Instead of copying bit-for-bit from the original,
280          * we need to append to existing one so that the already
281          * created entry via "clone -s" is not lost, and also
282          * to turn entries with paths relative to the original
283          * absolute, so that they can be used in the new repository.
284          */
285         FILE *in = fopen(src->buf, "r");
286         struct strbuf line = STRBUF_INIT;
287
288         while (strbuf_getline(&line, in, '\n') != EOF) {
289                 char *abs_path, abs_buf[PATH_MAX];
290                 if (!line.len || line.buf[0] == '#')
291                         continue;
292                 if (is_absolute_path(line.buf)) {
293                         add_to_alternates_file(line.buf);
294                         continue;
295                 }
296                 abs_path = mkpath("%s/objects/%s", src_repo, line.buf);
297                 normalize_path_copy(abs_buf, abs_path);
298                 add_to_alternates_file(abs_buf);
299         }
300         strbuf_release(&line);
301         fclose(in);
302 }
303
304 static void copy_or_link_directory(struct strbuf *src, struct strbuf *dest,
305                                    const char *src_repo, int src_baselen)
306 {
307         struct dirent *de;
308         struct stat buf;
309         int src_len, dest_len;
310         DIR *dir;
311
312         dir = opendir(src->buf);
313         if (!dir)
314                 die_errno(_("failed to open '%s'"), src->buf);
315
316         if (mkdir(dest->buf, 0777)) {
317                 if (errno != EEXIST)
318                         die_errno(_("failed to create directory '%s'"), dest->buf);
319                 else if (stat(dest->buf, &buf))
320                         die_errno(_("failed to stat '%s'"), dest->buf);
321                 else if (!S_ISDIR(buf.st_mode))
322                         die(_("%s exists and is not a directory"), dest->buf);
323         }
324
325         strbuf_addch(src, '/');
326         src_len = src->len;
327         strbuf_addch(dest, '/');
328         dest_len = dest->len;
329
330         while ((de = readdir(dir)) != NULL) {
331                 strbuf_setlen(src, src_len);
332                 strbuf_addstr(src, de->d_name);
333                 strbuf_setlen(dest, dest_len);
334                 strbuf_addstr(dest, de->d_name);
335                 if (stat(src->buf, &buf)) {
336                         warning (_("failed to stat %s\n"), src->buf);
337                         continue;
338                 }
339                 if (S_ISDIR(buf.st_mode)) {
340                         if (de->d_name[0] != '.')
341                                 copy_or_link_directory(src, dest,
342                                                        src_repo, src_baselen);
343                         continue;
344                 }
345
346                 /* Files that cannot be copied bit-for-bit... */
347                 if (!strcmp(src->buf + src_baselen, "/info/alternates")) {
348                         copy_alternates(src, dest, src_repo);
349                         continue;
350                 }
351
352                 if (unlink(dest->buf) && errno != ENOENT)
353                         die_errno(_("failed to unlink '%s'"), dest->buf);
354                 if (!option_no_hardlinks) {
355                         if (!link(src->buf, dest->buf))
356                                 continue;
357                         if (option_local)
358                                 die_errno(_("failed to create link '%s'"), dest->buf);
359                         option_no_hardlinks = 1;
360                 }
361                 if (copy_file_with_time(dest->buf, src->buf, 0666))
362                         die_errno(_("failed to copy file to '%s'"), dest->buf);
363         }
364         closedir(dir);
365 }
366
367 static const struct ref *clone_local(const char *src_repo,
368                                      const char *dest_repo)
369 {
370         const struct ref *ret;
371         struct remote *remote;
372         struct transport *transport;
373
374         if (option_shared) {
375                 struct strbuf alt = STRBUF_INIT;
376                 strbuf_addf(&alt, "%s/objects", src_repo);
377                 add_to_alternates_file(alt.buf);
378                 strbuf_release(&alt);
379         } else {
380                 struct strbuf src = STRBUF_INIT;
381                 struct strbuf dest = STRBUF_INIT;
382                 strbuf_addf(&src, "%s/objects", src_repo);
383                 strbuf_addf(&dest, "%s/objects", dest_repo);
384                 copy_or_link_directory(&src, &dest, src_repo, src.len);
385                 strbuf_release(&src);
386                 strbuf_release(&dest);
387         }
388
389         remote = remote_get(src_repo);
390         transport = transport_get(remote, src_repo);
391         ret = transport_get_remote_refs(transport);
392         transport_disconnect(transport);
393         if (0 <= option_verbosity)
394                 printf(_("done.\n"));
395         return ret;
396 }
397
398 static const char *junk_work_tree;
399 static const char *junk_git_dir;
400 static pid_t junk_pid;
401
402 static void remove_junk(void)
403 {
404         struct strbuf sb = STRBUF_INIT;
405         if (getpid() != junk_pid)
406                 return;
407         if (junk_git_dir) {
408                 strbuf_addstr(&sb, junk_git_dir);
409                 remove_dir_recursively(&sb, 0);
410                 strbuf_reset(&sb);
411         }
412         if (junk_work_tree) {
413                 strbuf_addstr(&sb, junk_work_tree);
414                 remove_dir_recursively(&sb, 0);
415                 strbuf_reset(&sb);
416         }
417 }
418
419 static void remove_junk_on_signal(int signo)
420 {
421         remove_junk();
422         sigchain_pop(signo);
423         raise(signo);
424 }
425
426 static struct ref *wanted_peer_refs(const struct ref *refs,
427                 struct refspec *refspec)
428 {
429         struct ref *head = copy_ref(find_ref_by_name(refs, "HEAD"));
430         struct ref *local_refs = head;
431         struct ref **tail = head ? &head->next : &local_refs;
432
433         if (option_single_branch) {
434                 struct ref *remote_head = NULL;
435
436                 if (!option_branch)
437                         remote_head = guess_remote_head(head, refs, 0);
438                 else {
439                         struct strbuf sb = STRBUF_INIT;
440                         strbuf_addstr(&sb, src_ref_prefix);
441                         strbuf_addstr(&sb, option_branch);
442                         remote_head = find_ref_by_name(refs, sb.buf);
443                         strbuf_release(&sb);
444                 }
445
446                 if (!remote_head && option_branch)
447                         warning(_("Could not find remote branch %s to clone."),
448                                 option_branch);
449                 else
450                         get_fetch_map(remote_head, refspec, &tail, 0);
451         } else
452                 get_fetch_map(refs, refspec, &tail, 0);
453
454         if (!option_mirror && !option_single_branch)
455                 get_fetch_map(refs, tag_refspec, &tail, 0);
456
457         return local_refs;
458 }
459
460 static void write_remote_refs(const struct ref *local_refs)
461 {
462         const struct ref *r;
463
464         for (r = local_refs; r; r = r->next) {
465                 if (!r->peer_ref)
466                         continue;
467                 add_packed_ref(r->peer_ref->name, r->old_sha1);
468         }
469
470         pack_refs(PACK_REFS_ALL);
471 }
472
473 static void write_followtags(const struct ref *refs, const char *msg)
474 {
475         const struct ref *ref;
476         for (ref = refs; ref; ref = ref->next) {
477                 if (prefixcmp(ref->name, "refs/tags/"))
478                         continue;
479                 if (!suffixcmp(ref->name, "^{}"))
480                         continue;
481                 if (!has_sha1_file(ref->old_sha1))
482                         continue;
483                 update_ref(msg, ref->name, ref->old_sha1,
484                            NULL, 0, DIE_ON_ERR);
485         }
486 }
487
488 static int write_one_config(const char *key, const char *value, void *data)
489 {
490         return git_config_set_multivar(key, value ? value : "true", "^$", 0);
491 }
492
493 static void write_config(struct string_list *config)
494 {
495         int i;
496
497         for (i = 0; i < config->nr; i++) {
498                 if (git_config_parse_parameter(config->items[i].string,
499                                                write_one_config, NULL) < 0)
500                         die("unable to write parameters to config file");
501         }
502 }
503
504 int cmd_clone(int argc, const char **argv, const char *prefix)
505 {
506         int is_bundle = 0, is_local;
507         struct stat buf;
508         const char *repo_name, *repo, *work_tree, *git_dir;
509         char *path, *dir;
510         int dest_exists;
511         const struct ref *refs, *remote_head;
512         const struct ref *remote_head_points_at;
513         const struct ref *our_head_points_at;
514         struct ref *mapped_refs;
515         struct strbuf key = STRBUF_INIT, value = STRBUF_INIT;
516         struct strbuf branch_top = STRBUF_INIT, reflog_msg = STRBUF_INIT;
517         struct transport *transport = NULL;
518         int err = 0;
519
520         struct refspec *refspec;
521         const char *fetch_pattern;
522
523         junk_pid = getpid();
524
525         packet_trace_identity("clone");
526         argc = parse_options(argc, argv, prefix, builtin_clone_options,
527                              builtin_clone_usage, 0);
528
529         if (argc > 2)
530                 usage_msg_opt(_("Too many arguments."),
531                         builtin_clone_usage, builtin_clone_options);
532
533         if (argc == 0)
534                 usage_msg_opt(_("You must specify a repository to clone."),
535                         builtin_clone_usage, builtin_clone_options);
536
537         if (option_single_branch == -1)
538                 option_single_branch = option_depth ? 1 : 0;
539
540         if (option_mirror)
541                 option_bare = 1;
542
543         if (option_bare) {
544                 if (option_origin)
545                         die(_("--bare and --origin %s options are incompatible."),
546                             option_origin);
547                 option_no_checkout = 1;
548         }
549
550         if (!option_origin)
551                 option_origin = "origin";
552
553         repo_name = argv[0];
554
555         path = get_repo_path(repo_name, &is_bundle);
556         if (path)
557                 repo = xstrdup(absolute_path(repo_name));
558         else if (!strchr(repo_name, ':'))
559                 die(_("repository '%s' does not exist"), repo_name);
560         else
561                 repo = repo_name;
562         is_local = path && !is_bundle;
563         if (is_local && option_depth)
564                 warning(_("--depth is ignored in local clones; use file:// instead."));
565
566         if (argc == 2)
567                 dir = xstrdup(argv[1]);
568         else
569                 dir = guess_dir_name(repo_name, is_bundle, option_bare);
570         strip_trailing_slashes(dir);
571
572         dest_exists = !stat(dir, &buf);
573         if (dest_exists && !is_empty_dir(dir))
574                 die(_("destination path '%s' already exists and is not "
575                         "an empty directory."), dir);
576
577         strbuf_addf(&reflog_msg, "clone: from %s", repo);
578
579         if (option_bare)
580                 work_tree = NULL;
581         else {
582                 work_tree = getenv("GIT_WORK_TREE");
583                 if (work_tree && !stat(work_tree, &buf))
584                         die(_("working tree '%s' already exists."), work_tree);
585         }
586
587         if (option_bare || work_tree)
588                 git_dir = xstrdup(dir);
589         else {
590                 work_tree = dir;
591                 git_dir = xstrdup(mkpath("%s/.git", dir));
592         }
593
594         if (!option_bare) {
595                 junk_work_tree = work_tree;
596                 if (safe_create_leading_directories_const(work_tree) < 0)
597                         die_errno(_("could not create leading directories of '%s'"),
598                                   work_tree);
599                 if (!dest_exists && mkdir(work_tree, 0755))
600                         die_errno(_("could not create work tree dir '%s'."),
601                                   work_tree);
602                 set_git_work_tree(work_tree);
603         }
604         junk_git_dir = git_dir;
605         atexit(remove_junk);
606         sigchain_push_common(remove_junk_on_signal);
607
608         setenv(CONFIG_ENVIRONMENT, mkpath("%s/config", git_dir), 1);
609
610         if (safe_create_leading_directories_const(git_dir) < 0)
611                 die(_("could not create leading directories of '%s'"), git_dir);
612
613         set_git_dir_init(git_dir, real_git_dir, 0);
614         if (real_git_dir)
615                 git_dir = real_git_dir;
616
617         if (0 <= option_verbosity) {
618                 if (option_bare)
619                         printf(_("Cloning into bare repository '%s'...\n"), dir);
620                 else
621                         printf(_("Cloning into '%s'...\n"), dir);
622         }
623         init_db(option_template, INIT_DB_QUIET);
624         write_config(&option_config);
625
626         /*
627          * At this point, the config exists, so we do not need the
628          * environment variable.  We actually need to unset it, too, to
629          * re-enable parsing of the global configs.
630          */
631         unsetenv(CONFIG_ENVIRONMENT);
632
633         git_config(git_default_config, NULL);
634
635         if (option_bare) {
636                 if (option_mirror)
637                         src_ref_prefix = "refs/";
638                 strbuf_addstr(&branch_top, src_ref_prefix);
639
640                 git_config_set("core.bare", "true");
641         } else {
642                 strbuf_addf(&branch_top, "refs/remotes/%s/", option_origin);
643         }
644
645         strbuf_addf(&value, "+%s*:%s*", src_ref_prefix, branch_top.buf);
646
647         if (option_mirror || !option_bare) {
648                 /* Configure the remote */
649                 strbuf_addf(&key, "remote.%s.fetch", option_origin);
650                 git_config_set_multivar(key.buf, value.buf, "^$", 0);
651                 strbuf_reset(&key);
652
653                 if (option_mirror) {
654                         strbuf_addf(&key, "remote.%s.mirror", option_origin);
655                         git_config_set(key.buf, "true");
656                         strbuf_reset(&key);
657                 }
658         }
659
660         strbuf_addf(&key, "remote.%s.url", option_origin);
661         git_config_set(key.buf, repo);
662         strbuf_reset(&key);
663
664         if (option_reference.nr)
665                 setup_reference();
666
667         fetch_pattern = value.buf;
668         refspec = parse_fetch_refspec(1, &fetch_pattern);
669
670         strbuf_reset(&value);
671
672         if (is_local) {
673                 refs = clone_local(path, git_dir);
674                 mapped_refs = wanted_peer_refs(refs, refspec);
675         } else {
676                 struct remote *remote = remote_get(option_origin);
677                 transport = transport_get(remote, remote->url[0]);
678
679                 if (!transport->get_refs_list || !transport->fetch)
680                         die(_("Don't know how to clone %s"), transport->url);
681
682                 transport_set_option(transport, TRANS_OPT_KEEP, "yes");
683
684                 if (option_depth)
685                         transport_set_option(transport, TRANS_OPT_DEPTH,
686                                              option_depth);
687                 if (option_single_branch)
688                         transport_set_option(transport, TRANS_OPT_FOLLOWTAGS, "1");
689
690                 transport_set_verbosity(transport, option_verbosity, option_progress);
691
692                 if (option_upload_pack)
693                         transport_set_option(transport, TRANS_OPT_UPLOADPACK,
694                                              option_upload_pack);
695
696                 refs = transport_get_remote_refs(transport);
697                 if (refs) {
698                         mapped_refs = wanted_peer_refs(refs, refspec);
699                         transport_fetch_refs(transport, mapped_refs);
700                 }
701         }
702
703         if (refs) {
704                 clear_extra_refs();
705
706                 write_remote_refs(mapped_refs);
707                 if (option_single_branch)
708                         write_followtags(refs, reflog_msg.buf);
709
710                 remote_head = find_ref_by_name(refs, "HEAD");
711                 remote_head_points_at =
712                         guess_remote_head(remote_head, mapped_refs, 0);
713
714                 if (option_branch) {
715                         struct strbuf head = STRBUF_INIT;
716                         strbuf_addstr(&head, src_ref_prefix);
717                         strbuf_addstr(&head, option_branch);
718                         our_head_points_at =
719                                 find_ref_by_name(mapped_refs, head.buf);
720                         strbuf_release(&head);
721
722                         if (!our_head_points_at) {
723                                 warning(_("Remote branch %s not found in "
724                                         "upstream %s, using HEAD instead"),
725                                         option_branch, option_origin);
726                                 our_head_points_at = remote_head_points_at;
727                         }
728                 }
729                 else
730                         our_head_points_at = remote_head_points_at;
731         }
732         else {
733                 warning(_("You appear to have cloned an empty repository."));
734                 our_head_points_at = NULL;
735                 remote_head_points_at = NULL;
736                 remote_head = NULL;
737                 option_no_checkout = 1;
738                 if (!option_bare)
739                         install_branch_config(0, "master", option_origin,
740                                               "refs/heads/master");
741         }
742
743         if (remote_head_points_at && !option_bare) {
744                 struct strbuf head_ref = STRBUF_INIT;
745                 strbuf_addstr(&head_ref, branch_top.buf);
746                 strbuf_addstr(&head_ref, "HEAD");
747                 create_symref(head_ref.buf,
748                               remote_head_points_at->peer_ref->name,
749                               reflog_msg.buf);
750         }
751
752         if (our_head_points_at) {
753                 /* Local default branch link */
754                 create_symref("HEAD", our_head_points_at->name, NULL);
755                 if (!option_bare) {
756                         const char *head = skip_prefix(our_head_points_at->name,
757                                                        "refs/heads/");
758                         update_ref(reflog_msg.buf, "HEAD",
759                                    our_head_points_at->old_sha1,
760                                    NULL, 0, DIE_ON_ERR);
761                         install_branch_config(0, head, option_origin,
762                                               our_head_points_at->name);
763                 }
764         } else if (remote_head) {
765                 /* Source had detached HEAD pointing somewhere. */
766                 if (!option_bare) {
767                         update_ref(reflog_msg.buf, "HEAD",
768                                    remote_head->old_sha1,
769                                    NULL, REF_NODEREF, DIE_ON_ERR);
770                         our_head_points_at = remote_head;
771                 }
772         } else {
773                 /* Nothing to checkout out */
774                 if (!option_no_checkout)
775                         warning(_("remote HEAD refers to nonexistent ref, "
776                                 "unable to checkout.\n"));
777                 option_no_checkout = 1;
778         }
779
780         if (transport) {
781                 transport_unlock_pack(transport);
782                 transport_disconnect(transport);
783         }
784
785         if (!option_no_checkout) {
786                 struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
787                 struct unpack_trees_options opts;
788                 struct tree *tree;
789                 struct tree_desc t;
790                 int fd;
791
792                 /* We need to be in the new work tree for the checkout */
793                 setup_work_tree();
794
795                 fd = hold_locked_index(lock_file, 1);
796
797                 memset(&opts, 0, sizeof opts);
798                 opts.update = 1;
799                 opts.merge = 1;
800                 opts.fn = oneway_merge;
801                 opts.verbose_update = (option_verbosity > 0);
802                 opts.src_index = &the_index;
803                 opts.dst_index = &the_index;
804
805                 tree = parse_tree_indirect(our_head_points_at->old_sha1);
806                 parse_tree(tree);
807                 init_tree_desc(&t, tree->buffer, tree->size);
808                 unpack_trees(1, &t, &opts);
809
810                 if (write_cache(fd, active_cache, active_nr) ||
811                     commit_locked_index(lock_file))
812                         die(_("unable to write new index file"));
813
814                 err |= run_hook(NULL, "post-checkout", sha1_to_hex(null_sha1),
815                                 sha1_to_hex(our_head_points_at->old_sha1), "1",
816                                 NULL);
817
818                 if (!err && option_recursive)
819                         err = run_command_v_opt(argv_submodule, RUN_GIT_CMD);
820         }
821
822         strbuf_release(&reflog_msg);
823         strbuf_release(&branch_top);
824         strbuf_release(&key);
825         strbuf_release(&value);
826         junk_pid = 0;
827         return err;
828 }