Merge branch 'cb/push-quiet'
[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_extra_ref(r->peer_ref->name, r->old_sha1, 0);
468         }
469
470         pack_refs(PACK_REFS_ALL);
471         clear_extra_refs();
472 }
473
474 static void write_followtags(const struct ref *refs, const char *msg)
475 {
476         const struct ref *ref;
477         for (ref = refs; ref; ref = ref->next) {
478                 if (prefixcmp(ref->name, "refs/tags/"))
479                         continue;
480                 if (!suffixcmp(ref->name, "^{}"))
481                         continue;
482                 if (!has_sha1_file(ref->old_sha1))
483                         continue;
484                 update_ref(msg, ref->name, ref->old_sha1,
485                            NULL, 0, DIE_ON_ERR);
486         }
487 }
488
489 static int write_one_config(const char *key, const char *value, void *data)
490 {
491         return git_config_set_multivar(key, value ? value : "true", "^$", 0);
492 }
493
494 static void write_config(struct string_list *config)
495 {
496         int i;
497
498         for (i = 0; i < config->nr; i++) {
499                 if (git_config_parse_parameter(config->items[i].string,
500                                                write_one_config, NULL) < 0)
501                         die("unable to write parameters to config file");
502         }
503 }
504
505 int cmd_clone(int argc, const char **argv, const char *prefix)
506 {
507         int is_bundle = 0, is_local;
508         struct stat buf;
509         const char *repo_name, *repo, *work_tree, *git_dir;
510         char *path, *dir;
511         int dest_exists;
512         const struct ref *refs, *remote_head;
513         const struct ref *remote_head_points_at;
514         const struct ref *our_head_points_at;
515         struct ref *mapped_refs;
516         struct strbuf key = STRBUF_INIT, value = STRBUF_INIT;
517         struct strbuf branch_top = STRBUF_INIT, reflog_msg = STRBUF_INIT;
518         struct transport *transport = NULL;
519         int err = 0;
520
521         struct refspec *refspec;
522         const char *fetch_pattern;
523
524         junk_pid = getpid();
525
526         packet_trace_identity("clone");
527         argc = parse_options(argc, argv, prefix, builtin_clone_options,
528                              builtin_clone_usage, 0);
529
530         if (argc > 2)
531                 usage_msg_opt(_("Too many arguments."),
532                         builtin_clone_usage, builtin_clone_options);
533
534         if (argc == 0)
535                 usage_msg_opt(_("You must specify a repository to clone."),
536                         builtin_clone_usage, builtin_clone_options);
537
538         if (option_single_branch == -1)
539                 option_single_branch = option_depth ? 1 : 0;
540
541         if (option_mirror)
542                 option_bare = 1;
543
544         if (option_bare) {
545                 if (option_origin)
546                         die(_("--bare and --origin %s options are incompatible."),
547                             option_origin);
548                 option_no_checkout = 1;
549         }
550
551         if (!option_origin)
552                 option_origin = "origin";
553
554         repo_name = argv[0];
555
556         path = get_repo_path(repo_name, &is_bundle);
557         if (path)
558                 repo = xstrdup(absolute_path(repo_name));
559         else if (!strchr(repo_name, ':'))
560                 die(_("repository '%s' does not exist"), repo_name);
561         else
562                 repo = repo_name;
563         is_local = path && !is_bundle;
564         if (is_local && option_depth)
565                 warning(_("--depth is ignored in local clones; use file:// instead."));
566
567         if (argc == 2)
568                 dir = xstrdup(argv[1]);
569         else
570                 dir = guess_dir_name(repo_name, is_bundle, option_bare);
571         strip_trailing_slashes(dir);
572
573         dest_exists = !stat(dir, &buf);
574         if (dest_exists && !is_empty_dir(dir))
575                 die(_("destination path '%s' already exists and is not "
576                         "an empty directory."), dir);
577
578         strbuf_addf(&reflog_msg, "clone: from %s", repo);
579
580         if (option_bare)
581                 work_tree = NULL;
582         else {
583                 work_tree = getenv("GIT_WORK_TREE");
584                 if (work_tree && !stat(work_tree, &buf))
585                         die(_("working tree '%s' already exists."), work_tree);
586         }
587
588         if (option_bare || work_tree)
589                 git_dir = xstrdup(dir);
590         else {
591                 work_tree = dir;
592                 git_dir = xstrdup(mkpath("%s/.git", dir));
593         }
594
595         if (!option_bare) {
596                 junk_work_tree = work_tree;
597                 if (safe_create_leading_directories_const(work_tree) < 0)
598                         die_errno(_("could not create leading directories of '%s'"),
599                                   work_tree);
600                 if (!dest_exists && mkdir(work_tree, 0755))
601                         die_errno(_("could not create work tree dir '%s'."),
602                                   work_tree);
603                 set_git_work_tree(work_tree);
604         }
605         junk_git_dir = git_dir;
606         atexit(remove_junk);
607         sigchain_push_common(remove_junk_on_signal);
608
609         setenv(CONFIG_ENVIRONMENT, mkpath("%s/config", git_dir), 1);
610
611         if (safe_create_leading_directories_const(git_dir) < 0)
612                 die(_("could not create leading directories of '%s'"), git_dir);
613
614         set_git_dir_init(git_dir, real_git_dir, 0);
615         if (real_git_dir)
616                 git_dir = real_git_dir;
617
618         if (0 <= option_verbosity) {
619                 if (option_bare)
620                         printf(_("Cloning into bare repository '%s'...\n"), dir);
621                 else
622                         printf(_("Cloning into '%s'...\n"), dir);
623         }
624         init_db(option_template, INIT_DB_QUIET);
625         write_config(&option_config);
626
627         /*
628          * At this point, the config exists, so we do not need the
629          * environment variable.  We actually need to unset it, too, to
630          * re-enable parsing of the global configs.
631          */
632         unsetenv(CONFIG_ENVIRONMENT);
633
634         git_config(git_default_config, NULL);
635
636         if (option_bare) {
637                 if (option_mirror)
638                         src_ref_prefix = "refs/";
639                 strbuf_addstr(&branch_top, src_ref_prefix);
640
641                 git_config_set("core.bare", "true");
642         } else {
643                 strbuf_addf(&branch_top, "refs/remotes/%s/", option_origin);
644         }
645
646         strbuf_addf(&value, "+%s*:%s*", src_ref_prefix, branch_top.buf);
647
648         if (option_mirror || !option_bare) {
649                 /* Configure the remote */
650                 strbuf_addf(&key, "remote.%s.fetch", option_origin);
651                 git_config_set_multivar(key.buf, value.buf, "^$", 0);
652                 strbuf_reset(&key);
653
654                 if (option_mirror) {
655                         strbuf_addf(&key, "remote.%s.mirror", option_origin);
656                         git_config_set(key.buf, "true");
657                         strbuf_reset(&key);
658                 }
659         }
660
661         strbuf_addf(&key, "remote.%s.url", option_origin);
662         git_config_set(key.buf, repo);
663         strbuf_reset(&key);
664
665         if (option_reference.nr)
666                 setup_reference();
667
668         fetch_pattern = value.buf;
669         refspec = parse_fetch_refspec(1, &fetch_pattern);
670
671         strbuf_reset(&value);
672
673         if (is_local) {
674                 refs = clone_local(path, git_dir);
675                 mapped_refs = wanted_peer_refs(refs, refspec);
676         } else {
677                 struct remote *remote = remote_get(option_origin);
678                 transport = transport_get(remote, remote->url[0]);
679
680                 if (!transport->get_refs_list || !transport->fetch)
681                         die(_("Don't know how to clone %s"), transport->url);
682
683                 transport_set_option(transport, TRANS_OPT_KEEP, "yes");
684
685                 if (option_depth)
686                         transport_set_option(transport, TRANS_OPT_DEPTH,
687                                              option_depth);
688                 if (option_single_branch)
689                         transport_set_option(transport, TRANS_OPT_FOLLOWTAGS, "1");
690
691                 transport_set_verbosity(transport, option_verbosity, option_progress);
692
693                 if (option_upload_pack)
694                         transport_set_option(transport, TRANS_OPT_UPLOADPACK,
695                                              option_upload_pack);
696
697                 refs = transport_get_remote_refs(transport);
698                 if (refs) {
699                         mapped_refs = wanted_peer_refs(refs, refspec);
700                         transport_fetch_refs(transport, mapped_refs);
701                 }
702         }
703
704         if (refs) {
705                 clear_extra_refs();
706
707                 write_remote_refs(mapped_refs);
708                 if (option_single_branch)
709                         write_followtags(refs, reflog_msg.buf);
710
711                 remote_head = find_ref_by_name(refs, "HEAD");
712                 remote_head_points_at =
713                         guess_remote_head(remote_head, mapped_refs, 0);
714
715                 if (option_branch) {
716                         struct strbuf head = STRBUF_INIT;
717                         strbuf_addstr(&head, src_ref_prefix);
718                         strbuf_addstr(&head, option_branch);
719                         our_head_points_at =
720                                 find_ref_by_name(mapped_refs, head.buf);
721                         strbuf_release(&head);
722
723                         if (!our_head_points_at) {
724                                 warning(_("Remote branch %s not found in "
725                                         "upstream %s, using HEAD instead"),
726                                         option_branch, option_origin);
727                                 our_head_points_at = remote_head_points_at;
728                         }
729                 }
730                 else
731                         our_head_points_at = remote_head_points_at;
732         }
733         else {
734                 warning(_("You appear to have cloned an empty repository."));
735                 our_head_points_at = NULL;
736                 remote_head_points_at = NULL;
737                 remote_head = NULL;
738                 option_no_checkout = 1;
739                 if (!option_bare)
740                         install_branch_config(0, "master", option_origin,
741                                               "refs/heads/master");
742         }
743
744         if (remote_head_points_at && !option_bare) {
745                 struct strbuf head_ref = STRBUF_INIT;
746                 strbuf_addstr(&head_ref, branch_top.buf);
747                 strbuf_addstr(&head_ref, "HEAD");
748                 create_symref(head_ref.buf,
749                               remote_head_points_at->peer_ref->name,
750                               reflog_msg.buf);
751         }
752
753         if (our_head_points_at) {
754                 /* Local default branch link */
755                 create_symref("HEAD", our_head_points_at->name, NULL);
756                 if (!option_bare) {
757                         const char *head = skip_prefix(our_head_points_at->name,
758                                                        "refs/heads/");
759                         update_ref(reflog_msg.buf, "HEAD",
760                                    our_head_points_at->old_sha1,
761                                    NULL, 0, DIE_ON_ERR);
762                         install_branch_config(0, head, option_origin,
763                                               our_head_points_at->name);
764                 }
765         } else if (remote_head) {
766                 /* Source had detached HEAD pointing somewhere. */
767                 if (!option_bare) {
768                         update_ref(reflog_msg.buf, "HEAD",
769                                    remote_head->old_sha1,
770                                    NULL, REF_NODEREF, DIE_ON_ERR);
771                         our_head_points_at = remote_head;
772                 }
773         } else {
774                 /* Nothing to checkout out */
775                 if (!option_no_checkout)
776                         warning(_("remote HEAD refers to nonexistent ref, "
777                                 "unable to checkout.\n"));
778                 option_no_checkout = 1;
779         }
780
781         if (transport) {
782                 transport_unlock_pack(transport);
783                 transport_disconnect(transport);
784         }
785
786         if (!option_no_checkout) {
787                 struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
788                 struct unpack_trees_options opts;
789                 struct tree *tree;
790                 struct tree_desc t;
791                 int fd;
792
793                 /* We need to be in the new work tree for the checkout */
794                 setup_work_tree();
795
796                 fd = hold_locked_index(lock_file, 1);
797
798                 memset(&opts, 0, sizeof opts);
799                 opts.update = 1;
800                 opts.merge = 1;
801                 opts.fn = oneway_merge;
802                 opts.verbose_update = (option_verbosity > 0);
803                 opts.src_index = &the_index;
804                 opts.dst_index = &the_index;
805
806                 tree = parse_tree_indirect(our_head_points_at->old_sha1);
807                 parse_tree(tree);
808                 init_tree_desc(&t, tree->buffer, tree->size);
809                 unpack_trees(1, &t, &opts);
810
811                 if (write_cache(fd, active_cache, active_nr) ||
812                     commit_locked_index(lock_file))
813                         die(_("unable to write new index file"));
814
815                 err |= run_hook(NULL, "post-checkout", sha1_to_hex(null_sha1),
816                                 sha1_to_hex(our_head_points_at->old_sha1), "1",
817                                 NULL);
818
819                 if (!err && option_recursive)
820                         err = run_command_v_opt(argv_submodule, RUN_GIT_CMD);
821         }
822
823         strbuf_release(&reflog_msg);
824         strbuf_release(&branch_top);
825         strbuf_release(&key);
826         strbuf_release(&value);
827         junk_pid = 0;
828         return err;
829 }