builtin / clone.con commit submodule init: warn about falling back to a local path (d1b3b81)
   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 "lockfile.h"
  13#include "parse-options.h"
  14#include "fetch-pack.h"
  15#include "refs.h"
  16#include "tree.h"
  17#include "tree-walk.h"
  18#include "unpack-trees.h"
  19#include "transport.h"
  20#include "strbuf.h"
  21#include "dir.h"
  22#include "sigchain.h"
  23#include "branch.h"
  24#include "remote.h"
  25#include "run-command.h"
  26#include "connected.h"
  27
  28/*
  29 * Overall FIXMEs:
  30 *  - respect DB_ENVIRONMENT for .git/objects.
  31 *
  32 * Implementation notes:
  33 *  - dropping use-separate-remote and no-separate-remote compatibility
  34 *
  35 */
  36static const char * const builtin_clone_usage[] = {
  37        N_("git clone [<options>] [--] <repo> [<dir>]"),
  38        NULL
  39};
  40
  41static int option_no_checkout, option_bare, option_mirror, option_single_branch = -1;
  42static int option_local = -1, option_no_hardlinks, option_shared, option_recursive;
  43static int option_shallow_submodules;
  44static int deepen;
  45static char *option_template, *option_depth, *option_since;
  46static char *option_origin = NULL;
  47static char *option_branch = NULL;
  48static struct string_list option_not = STRING_LIST_INIT_NODUP;
  49static const char *real_git_dir;
  50static char *option_upload_pack = "git-upload-pack";
  51static int option_verbosity;
  52static int option_progress = -1;
  53static enum transport_family family;
  54static struct string_list option_config = STRING_LIST_INIT_NODUP;
  55static struct string_list option_required_reference = STRING_LIST_INIT_NODUP;
  56static struct string_list option_optional_reference = STRING_LIST_INIT_NODUP;
  57static int option_dissociate;
  58static int max_jobs = -1;
  59
  60static struct option builtin_clone_options[] = {
  61        OPT__VERBOSITY(&option_verbosity),
  62        OPT_BOOL(0, "progress", &option_progress,
  63                 N_("force progress reporting")),
  64        OPT_BOOL('n', "no-checkout", &option_no_checkout,
  65                 N_("don't create a checkout")),
  66        OPT_BOOL(0, "bare", &option_bare, N_("create a bare repository")),
  67        OPT_HIDDEN_BOOL(0, "naked", &option_bare,
  68                        N_("create a bare repository")),
  69        OPT_BOOL(0, "mirror", &option_mirror,
  70                 N_("create a mirror repository (implies bare)")),
  71        OPT_BOOL('l', "local", &option_local,
  72                N_("to clone from a local repository")),
  73        OPT_BOOL(0, "no-hardlinks", &option_no_hardlinks,
  74                    N_("don't use local hardlinks, always copy")),
  75        OPT_BOOL('s', "shared", &option_shared,
  76                    N_("setup as shared repository")),
  77        OPT_BOOL(0, "recursive", &option_recursive,
  78                    N_("initialize submodules in the clone")),
  79        OPT_BOOL(0, "recurse-submodules", &option_recursive,
  80                    N_("initialize submodules in the clone")),
  81        OPT_INTEGER('j', "jobs", &max_jobs,
  82                    N_("number of submodules cloned in parallel")),
  83        OPT_STRING(0, "template", &option_template, N_("template-directory"),
  84                   N_("directory from which templates will be used")),
  85        OPT_STRING_LIST(0, "reference", &option_required_reference, N_("repo"),
  86                        N_("reference repository")),
  87        OPT_STRING_LIST(0, "reference-if-able", &option_optional_reference,
  88                        N_("repo"), N_("reference repository")),
  89        OPT_BOOL(0, "dissociate", &option_dissociate,
  90                 N_("use --reference only while cloning")),
  91        OPT_STRING('o', "origin", &option_origin, N_("name"),
  92                   N_("use <name> instead of 'origin' to track upstream")),
  93        OPT_STRING('b', "branch", &option_branch, N_("branch"),
  94                   N_("checkout <branch> instead of the remote's HEAD")),
  95        OPT_STRING('u', "upload-pack", &option_upload_pack, N_("path"),
  96                   N_("path to git-upload-pack on the remote")),
  97        OPT_STRING(0, "depth", &option_depth, N_("depth"),
  98                    N_("create a shallow clone of that depth")),
  99        OPT_STRING(0, "shallow-since", &option_since, N_("time"),
 100                    N_("create a shallow clone since a specific time")),
 101        OPT_STRING_LIST(0, "shallow-exclude", &option_not, N_("revision"),
 102                        N_("deepen history of shallow clone, excluding rev")),
 103        OPT_BOOL(0, "single-branch", &option_single_branch,
 104                    N_("clone only one branch, HEAD or --branch")),
 105        OPT_BOOL(0, "shallow-submodules", &option_shallow_submodules,
 106                    N_("any cloned submodules will be shallow")),
 107        OPT_STRING(0, "separate-git-dir", &real_git_dir, N_("gitdir"),
 108                   N_("separate git dir from working tree")),
 109        OPT_STRING_LIST('c', "config", &option_config, N_("key=value"),
 110                        N_("set config inside the new repository")),
 111        OPT_SET_INT('4', "ipv4", &family, N_("use IPv4 addresses only"),
 112                        TRANSPORT_FAMILY_IPV4),
 113        OPT_SET_INT('6', "ipv6", &family, N_("use IPv6 addresses only"),
 114                        TRANSPORT_FAMILY_IPV6),
 115        OPT_END()
 116};
 117
 118static const char *get_repo_path_1(struct strbuf *path, int *is_bundle)
 119{
 120        static char *suffix[] = { "/.git", "", ".git/.git", ".git" };
 121        static char *bundle_suffix[] = { ".bundle", "" };
 122        size_t baselen = path->len;
 123        struct stat st;
 124        int i;
 125
 126        for (i = 0; i < ARRAY_SIZE(suffix); i++) {
 127                strbuf_setlen(path, baselen);
 128                strbuf_addstr(path, suffix[i]);
 129                if (stat(path->buf, &st))
 130                        continue;
 131                if (S_ISDIR(st.st_mode) && is_git_directory(path->buf)) {
 132                        *is_bundle = 0;
 133                        return path->buf;
 134                } else if (S_ISREG(st.st_mode) && st.st_size > 8) {
 135                        /* Is it a "gitfile"? */
 136                        char signature[8];
 137                        const char *dst;
 138                        int len, fd = open(path->buf, O_RDONLY);
 139                        if (fd < 0)
 140                                continue;
 141                        len = read_in_full(fd, signature, 8);
 142                        close(fd);
 143                        if (len != 8 || strncmp(signature, "gitdir: ", 8))
 144                                continue;
 145                        dst = read_gitfile(path->buf);
 146                        if (dst) {
 147                                *is_bundle = 0;
 148                                return dst;
 149                        }
 150                }
 151        }
 152
 153        for (i = 0; i < ARRAY_SIZE(bundle_suffix); i++) {
 154                strbuf_setlen(path, baselen);
 155                strbuf_addstr(path, bundle_suffix[i]);
 156                if (!stat(path->buf, &st) && S_ISREG(st.st_mode)) {
 157                        *is_bundle = 1;
 158                        return path->buf;
 159                }
 160        }
 161
 162        return NULL;
 163}
 164
 165static char *get_repo_path(const char *repo, int *is_bundle)
 166{
 167        struct strbuf path = STRBUF_INIT;
 168        const char *raw;
 169        char *canon;
 170
 171        strbuf_addstr(&path, repo);
 172        raw = get_repo_path_1(&path, is_bundle);
 173        canon = raw ? absolute_pathdup(raw) : NULL;
 174        strbuf_release(&path);
 175        return canon;
 176}
 177
 178static char *guess_dir_name(const char *repo, int is_bundle, int is_bare)
 179{
 180        const char *end = repo + strlen(repo), *start, *ptr;
 181        size_t len;
 182        char *dir;
 183
 184        /*
 185         * Skip scheme.
 186         */
 187        start = strstr(repo, "://");
 188        if (start == NULL)
 189                start = repo;
 190        else
 191                start += 3;
 192
 193        /*
 194         * Skip authentication data. The stripping does happen
 195         * greedily, such that we strip up to the last '@' inside
 196         * the host part.
 197         */
 198        for (ptr = start; ptr < end && !is_dir_sep(*ptr); ptr++) {
 199                if (*ptr == '@')
 200                        start = ptr + 1;
 201        }
 202
 203        /*
 204         * Strip trailing spaces, slashes and /.git
 205         */
 206        while (start < end && (is_dir_sep(end[-1]) || isspace(end[-1])))
 207                end--;
 208        if (end - start > 5 && is_dir_sep(end[-5]) &&
 209            !strncmp(end - 4, ".git", 4)) {
 210                end -= 5;
 211                while (start < end && is_dir_sep(end[-1]))
 212                        end--;
 213        }
 214
 215        /*
 216         * Strip trailing port number if we've got only a
 217         * hostname (that is, there is no dir separator but a
 218         * colon). This check is required such that we do not
 219         * strip URI's like '/foo/bar:2222.git', which should
 220         * result in a dir '2222' being guessed due to backwards
 221         * compatibility.
 222         */
 223        if (memchr(start, '/', end - start) == NULL
 224            && memchr(start, ':', end - start) != NULL) {
 225                ptr = end;
 226                while (start < ptr && isdigit(ptr[-1]) && ptr[-1] != ':')
 227                        ptr--;
 228                if (start < ptr && ptr[-1] == ':')
 229                        end = ptr - 1;
 230        }
 231
 232        /*
 233         * Find last component. To remain backwards compatible we
 234         * also regard colons as path separators, such that
 235         * cloning a repository 'foo:bar.git' would result in a
 236         * directory 'bar' being guessed.
 237         */
 238        ptr = end;
 239        while (start < ptr && !is_dir_sep(ptr[-1]) && ptr[-1] != ':')
 240                ptr--;
 241        start = ptr;
 242
 243        /*
 244         * Strip .{bundle,git}.
 245         */
 246        len = end - start;
 247        strip_suffix_mem(start, &len, is_bundle ? ".bundle" : ".git");
 248
 249        if (!len || (len == 1 && *start == '/'))
 250                die(_("No directory name could be guessed.\n"
 251                      "Please specify a directory on the command line"));
 252
 253        if (is_bare)
 254                dir = xstrfmt("%.*s.git", (int)len, start);
 255        else
 256                dir = xstrndup(start, len);
 257        /*
 258         * Replace sequences of 'control' characters and whitespace
 259         * with one ascii space, remove leading and trailing spaces.
 260         */
 261        if (*dir) {
 262                char *out = dir;
 263                int prev_space = 1 /* strip leading whitespace */;
 264                for (end = dir; *end; ++end) {
 265                        char ch = *end;
 266                        if ((unsigned char)ch < '\x20')
 267                                ch = '\x20';
 268                        if (isspace(ch)) {
 269                                if (prev_space)
 270                                        continue;
 271                                prev_space = 1;
 272                        } else
 273                                prev_space = 0;
 274                        *out++ = ch;
 275                }
 276                *out = '\0';
 277                if (out > dir && prev_space)
 278                        out[-1] = '\0';
 279        }
 280        return dir;
 281}
 282
 283static void strip_trailing_slashes(char *dir)
 284{
 285        char *end = dir + strlen(dir);
 286
 287        while (dir < end - 1 && is_dir_sep(end[-1]))
 288                end--;
 289        *end = '\0';
 290}
 291
 292static int add_one_reference(struct string_list_item *item, void *cb_data)
 293{
 294        struct strbuf err = STRBUF_INIT;
 295        int *required = cb_data;
 296        char *ref_git = compute_alternate_path(item->string, &err);
 297
 298        if (!ref_git) {
 299                if (*required)
 300                        die("%s", err.buf);
 301                else
 302                        fprintf(stderr,
 303                                _("info: Could not add alternate for '%s': %s\n"),
 304                                item->string, err.buf);
 305        } else {
 306                struct strbuf sb = STRBUF_INIT;
 307                strbuf_addf(&sb, "%s/objects", ref_git);
 308                add_to_alternates_file(sb.buf);
 309                strbuf_release(&sb);
 310        }
 311
 312        strbuf_release(&err);
 313        free(ref_git);
 314        return 0;
 315}
 316
 317static void setup_reference(void)
 318{
 319        int required = 1;
 320        for_each_string_list(&option_required_reference,
 321                             add_one_reference, &required);
 322        required = 0;
 323        for_each_string_list(&option_optional_reference,
 324                             add_one_reference, &required);
 325}
 326
 327static void copy_alternates(struct strbuf *src, struct strbuf *dst,
 328                            const char *src_repo)
 329{
 330        /*
 331         * Read from the source objects/info/alternates file
 332         * and copy the entries to corresponding file in the
 333         * destination repository with add_to_alternates_file().
 334         * Both src and dst have "$path/objects/info/alternates".
 335         *
 336         * Instead of copying bit-for-bit from the original,
 337         * we need to append to existing one so that the already
 338         * created entry via "clone -s" is not lost, and also
 339         * to turn entries with paths relative to the original
 340         * absolute, so that they can be used in the new repository.
 341         */
 342        FILE *in = fopen(src->buf, "r");
 343        struct strbuf line = STRBUF_INIT;
 344
 345        while (strbuf_getline(&line, in) != EOF) {
 346                char *abs_path;
 347                if (!line.len || line.buf[0] == '#')
 348                        continue;
 349                if (is_absolute_path(line.buf)) {
 350                        add_to_alternates_file(line.buf);
 351                        continue;
 352                }
 353                abs_path = mkpathdup("%s/objects/%s", src_repo, line.buf);
 354                if (!normalize_path_copy(abs_path, abs_path))
 355                        add_to_alternates_file(abs_path);
 356                else
 357                        warning("skipping invalid relative alternate: %s/%s",
 358                                src_repo, line.buf);
 359                free(abs_path);
 360        }
 361        strbuf_release(&line);
 362        fclose(in);
 363}
 364
 365static void copy_or_link_directory(struct strbuf *src, struct strbuf *dest,
 366                                   const char *src_repo, int src_baselen)
 367{
 368        struct dirent *de;
 369        struct stat buf;
 370        int src_len, dest_len;
 371        DIR *dir;
 372
 373        dir = opendir(src->buf);
 374        if (!dir)
 375                die_errno(_("failed to open '%s'"), src->buf);
 376
 377        if (mkdir(dest->buf, 0777)) {
 378                if (errno != EEXIST)
 379                        die_errno(_("failed to create directory '%s'"), dest->buf);
 380                else if (stat(dest->buf, &buf))
 381                        die_errno(_("failed to stat '%s'"), dest->buf);
 382                else if (!S_ISDIR(buf.st_mode))
 383                        die(_("%s exists and is not a directory"), dest->buf);
 384        }
 385
 386        strbuf_addch(src, '/');
 387        src_len = src->len;
 388        strbuf_addch(dest, '/');
 389        dest_len = dest->len;
 390
 391        while ((de = readdir(dir)) != NULL) {
 392                strbuf_setlen(src, src_len);
 393                strbuf_addstr(src, de->d_name);
 394                strbuf_setlen(dest, dest_len);
 395                strbuf_addstr(dest, de->d_name);
 396                if (stat(src->buf, &buf)) {
 397                        warning (_("failed to stat %s\n"), src->buf);
 398                        continue;
 399                }
 400                if (S_ISDIR(buf.st_mode)) {
 401                        if (de->d_name[0] != '.')
 402                                copy_or_link_directory(src, dest,
 403                                                       src_repo, src_baselen);
 404                        continue;
 405                }
 406
 407                /* Files that cannot be copied bit-for-bit... */
 408                if (!strcmp(src->buf + src_baselen, "/info/alternates")) {
 409                        copy_alternates(src, dest, src_repo);
 410                        continue;
 411                }
 412
 413                if (unlink(dest->buf) && errno != ENOENT)
 414                        die_errno(_("failed to unlink '%s'"), dest->buf);
 415                if (!option_no_hardlinks) {
 416                        if (!link(src->buf, dest->buf))
 417                                continue;
 418                        if (option_local > 0)
 419                                die_errno(_("failed to create link '%s'"), dest->buf);
 420                        option_no_hardlinks = 1;
 421                }
 422                if (copy_file_with_time(dest->buf, src->buf, 0666))
 423                        die_errno(_("failed to copy file to '%s'"), dest->buf);
 424        }
 425        closedir(dir);
 426}
 427
 428static void clone_local(const char *src_repo, const char *dest_repo)
 429{
 430        if (option_shared) {
 431                struct strbuf alt = STRBUF_INIT;
 432                strbuf_addf(&alt, "%s/objects", src_repo);
 433                add_to_alternates_file(alt.buf);
 434                strbuf_release(&alt);
 435        } else {
 436                struct strbuf src = STRBUF_INIT;
 437                struct strbuf dest = STRBUF_INIT;
 438                get_common_dir(&src, src_repo);
 439                get_common_dir(&dest, dest_repo);
 440                strbuf_addstr(&src, "/objects");
 441                strbuf_addstr(&dest, "/objects");
 442                copy_or_link_directory(&src, &dest, src_repo, src.len);
 443                strbuf_release(&src);
 444                strbuf_release(&dest);
 445        }
 446
 447        if (0 <= option_verbosity)
 448                fprintf(stderr, _("done.\n"));
 449}
 450
 451static const char *junk_work_tree;
 452static const char *junk_git_dir;
 453static enum {
 454        JUNK_LEAVE_NONE,
 455        JUNK_LEAVE_REPO,
 456        JUNK_LEAVE_ALL
 457} junk_mode = JUNK_LEAVE_NONE;
 458
 459static const char junk_leave_repo_msg[] =
 460N_("Clone succeeded, but checkout failed.\n"
 461   "You can inspect what was checked out with 'git status'\n"
 462   "and retry the checkout with 'git checkout -f HEAD'\n");
 463
 464static void remove_junk(void)
 465{
 466        struct strbuf sb = STRBUF_INIT;
 467
 468        switch (junk_mode) {
 469        case JUNK_LEAVE_REPO:
 470                warning("%s", _(junk_leave_repo_msg));
 471                /* fall-through */
 472        case JUNK_LEAVE_ALL:
 473                return;
 474        default:
 475                /* proceed to removal */
 476                break;
 477        }
 478
 479        if (junk_git_dir) {
 480                strbuf_addstr(&sb, junk_git_dir);
 481                remove_dir_recursively(&sb, 0);
 482                strbuf_reset(&sb);
 483        }
 484        if (junk_work_tree) {
 485                strbuf_addstr(&sb, junk_work_tree);
 486                remove_dir_recursively(&sb, 0);
 487                strbuf_reset(&sb);
 488        }
 489}
 490
 491static void remove_junk_on_signal(int signo)
 492{
 493        remove_junk();
 494        sigchain_pop(signo);
 495        raise(signo);
 496}
 497
 498static struct ref *find_remote_branch(const struct ref *refs, const char *branch)
 499{
 500        struct ref *ref;
 501        struct strbuf head = STRBUF_INIT;
 502        strbuf_addstr(&head, "refs/heads/");
 503        strbuf_addstr(&head, branch);
 504        ref = find_ref_by_name(refs, head.buf);
 505        strbuf_release(&head);
 506
 507        if (ref)
 508                return ref;
 509
 510        strbuf_addstr(&head, "refs/tags/");
 511        strbuf_addstr(&head, branch);
 512        ref = find_ref_by_name(refs, head.buf);
 513        strbuf_release(&head);
 514
 515        return ref;
 516}
 517
 518static struct ref *wanted_peer_refs(const struct ref *refs,
 519                struct refspec *refspec)
 520{
 521        struct ref *head = copy_ref(find_ref_by_name(refs, "HEAD"));
 522        struct ref *local_refs = head;
 523        struct ref **tail = head ? &head->next : &local_refs;
 524
 525        if (option_single_branch) {
 526                struct ref *remote_head = NULL;
 527
 528                if (!option_branch)
 529                        remote_head = guess_remote_head(head, refs, 0);
 530                else {
 531                        local_refs = NULL;
 532                        tail = &local_refs;
 533                        remote_head = copy_ref(find_remote_branch(refs, option_branch));
 534                }
 535
 536                if (!remote_head && option_branch)
 537                        warning(_("Could not find remote branch %s to clone."),
 538                                option_branch);
 539                else {
 540                        get_fetch_map(remote_head, refspec, &tail, 0);
 541
 542                        /* if --branch=tag, pull the requested tag explicitly */
 543                        get_fetch_map(remote_head, tag_refspec, &tail, 0);
 544                }
 545        } else
 546                get_fetch_map(refs, refspec, &tail, 0);
 547
 548        if (!option_mirror && !option_single_branch)
 549                get_fetch_map(refs, tag_refspec, &tail, 0);
 550
 551        return local_refs;
 552}
 553
 554static void write_remote_refs(const struct ref *local_refs)
 555{
 556        const struct ref *r;
 557
 558        struct ref_transaction *t;
 559        struct strbuf err = STRBUF_INIT;
 560
 561        t = ref_transaction_begin(&err);
 562        if (!t)
 563                die("%s", err.buf);
 564
 565        for (r = local_refs; r; r = r->next) {
 566                if (!r->peer_ref)
 567                        continue;
 568                if (ref_transaction_create(t, r->peer_ref->name, r->old_oid.hash,
 569                                           0, NULL, &err))
 570                        die("%s", err.buf);
 571        }
 572
 573        if (initial_ref_transaction_commit(t, &err))
 574                die("%s", err.buf);
 575
 576        strbuf_release(&err);
 577        ref_transaction_free(t);
 578}
 579
 580static void write_followtags(const struct ref *refs, const char *msg)
 581{
 582        const struct ref *ref;
 583        for (ref = refs; ref; ref = ref->next) {
 584                if (!starts_with(ref->name, "refs/tags/"))
 585                        continue;
 586                if (ends_with(ref->name, "^{}"))
 587                        continue;
 588                if (!has_object_file(&ref->old_oid))
 589                        continue;
 590                update_ref(msg, ref->name, ref->old_oid.hash,
 591                           NULL, 0, UPDATE_REFS_DIE_ON_ERR);
 592        }
 593}
 594
 595static int iterate_ref_map(void *cb_data, unsigned char sha1[20])
 596{
 597        struct ref **rm = cb_data;
 598        struct ref *ref = *rm;
 599
 600        /*
 601         * Skip anything missing a peer_ref, which we are not
 602         * actually going to write a ref for.
 603         */
 604        while (ref && !ref->peer_ref)
 605                ref = ref->next;
 606        /* Returning -1 notes "end of list" to the caller. */
 607        if (!ref)
 608                return -1;
 609
 610        hashcpy(sha1, ref->old_oid.hash);
 611        *rm = ref->next;
 612        return 0;
 613}
 614
 615static void update_remote_refs(const struct ref *refs,
 616                               const struct ref *mapped_refs,
 617                               const struct ref *remote_head_points_at,
 618                               const char *branch_top,
 619                               const char *msg,
 620                               struct transport *transport,
 621                               int check_connectivity)
 622{
 623        const struct ref *rm = mapped_refs;
 624
 625        if (check_connectivity) {
 626                struct check_connected_options opt = CHECK_CONNECTED_INIT;
 627
 628                opt.transport = transport;
 629                opt.progress = transport->progress;
 630
 631                if (check_connected(iterate_ref_map, &rm, &opt))
 632                        die(_("remote did not send all necessary objects"));
 633        }
 634
 635        if (refs) {
 636                write_remote_refs(mapped_refs);
 637                if (option_single_branch)
 638                        write_followtags(refs, msg);
 639        }
 640
 641        if (remote_head_points_at && !option_bare) {
 642                struct strbuf head_ref = STRBUF_INIT;
 643                strbuf_addstr(&head_ref, branch_top);
 644                strbuf_addstr(&head_ref, "HEAD");
 645                if (create_symref(head_ref.buf,
 646                                  remote_head_points_at->peer_ref->name,
 647                                  msg) < 0)
 648                        die(_("unable to update %s"), head_ref.buf);
 649                strbuf_release(&head_ref);
 650        }
 651}
 652
 653static void update_head(const struct ref *our, const struct ref *remote,
 654                        const char *msg)
 655{
 656        const char *head;
 657        if (our && skip_prefix(our->name, "refs/heads/", &head)) {
 658                /* Local default branch link */
 659                if (create_symref("HEAD", our->name, NULL) < 0)
 660                        die(_("unable to update HEAD"));
 661                if (!option_bare) {
 662                        update_ref(msg, "HEAD", our->old_oid.hash, NULL, 0,
 663                                   UPDATE_REFS_DIE_ON_ERR);
 664                        install_branch_config(0, head, option_origin, our->name);
 665                }
 666        } else if (our) {
 667                struct commit *c = lookup_commit_reference(our->old_oid.hash);
 668                /* --branch specifies a non-branch (i.e. tags), detach HEAD */
 669                update_ref(msg, "HEAD", c->object.oid.hash,
 670                           NULL, REF_NODEREF, UPDATE_REFS_DIE_ON_ERR);
 671        } else if (remote) {
 672                /*
 673                 * We know remote HEAD points to a non-branch, or
 674                 * HEAD points to a branch but we don't know which one.
 675                 * Detach HEAD in all these cases.
 676                 */
 677                update_ref(msg, "HEAD", remote->old_oid.hash,
 678                           NULL, REF_NODEREF, UPDATE_REFS_DIE_ON_ERR);
 679        }
 680}
 681
 682static int checkout(int submodule_progress)
 683{
 684        unsigned char sha1[20];
 685        char *head;
 686        struct lock_file *lock_file;
 687        struct unpack_trees_options opts;
 688        struct tree *tree;
 689        struct tree_desc t;
 690        int err = 0;
 691
 692        if (option_no_checkout)
 693                return 0;
 694
 695        head = resolve_refdup("HEAD", RESOLVE_REF_READING, sha1, NULL);
 696        if (!head) {
 697                warning(_("remote HEAD refers to nonexistent ref, "
 698                          "unable to checkout.\n"));
 699                return 0;
 700        }
 701        if (!strcmp(head, "HEAD")) {
 702                if (advice_detached_head)
 703                        detach_advice(sha1_to_hex(sha1));
 704        } else {
 705                if (!starts_with(head, "refs/heads/"))
 706                        die(_("HEAD not found below refs/heads!"));
 707        }
 708        free(head);
 709
 710        /* We need to be in the new work tree for the checkout */
 711        setup_work_tree();
 712
 713        lock_file = xcalloc(1, sizeof(struct lock_file));
 714        hold_locked_index(lock_file, LOCK_DIE_ON_ERROR);
 715
 716        memset(&opts, 0, sizeof opts);
 717        opts.update = 1;
 718        opts.merge = 1;
 719        opts.fn = oneway_merge;
 720        opts.verbose_update = (option_verbosity >= 0);
 721        opts.src_index = &the_index;
 722        opts.dst_index = &the_index;
 723
 724        tree = parse_tree_indirect(sha1);
 725        parse_tree(tree);
 726        init_tree_desc(&t, tree->buffer, tree->size);
 727        if (unpack_trees(1, &t, &opts) < 0)
 728                die(_("unable to checkout working tree"));
 729
 730        if (write_locked_index(&the_index, lock_file, COMMIT_LOCK))
 731                die(_("unable to write new index file"));
 732
 733        err |= run_hook_le(NULL, "post-checkout", sha1_to_hex(null_sha1),
 734                           sha1_to_hex(sha1), "1", NULL);
 735
 736        if (!err && option_recursive) {
 737                struct argv_array args = ARGV_ARRAY_INIT;
 738                argv_array_pushl(&args, "submodule", "update", "--init", "--recursive", NULL);
 739
 740                if (option_shallow_submodules == 1)
 741                        argv_array_push(&args, "--depth=1");
 742
 743                if (max_jobs != -1)
 744                        argv_array_pushf(&args, "--jobs=%d", max_jobs);
 745
 746                if (submodule_progress)
 747                        argv_array_push(&args, "--progress");
 748
 749                err = run_command_v_opt(args.argv, RUN_GIT_CMD);
 750                argv_array_clear(&args);
 751        }
 752
 753        return err;
 754}
 755
 756static int write_one_config(const char *key, const char *value, void *data)
 757{
 758        return git_config_set_multivar_gently(key, value ? value : "true", "^$", 0);
 759}
 760
 761static void write_config(struct string_list *config)
 762{
 763        int i;
 764
 765        for (i = 0; i < config->nr; i++) {
 766                if (git_config_parse_parameter(config->items[i].string,
 767                                               write_one_config, NULL) < 0)
 768                        die(_("unable to write parameters to config file"));
 769        }
 770}
 771
 772static void write_refspec_config(const char *src_ref_prefix,
 773                const struct ref *our_head_points_at,
 774                const struct ref *remote_head_points_at,
 775                struct strbuf *branch_top)
 776{
 777        struct strbuf key = STRBUF_INIT;
 778        struct strbuf value = STRBUF_INIT;
 779
 780        if (option_mirror || !option_bare) {
 781                if (option_single_branch && !option_mirror) {
 782                        if (option_branch) {
 783                                if (starts_with(our_head_points_at->name, "refs/tags/"))
 784                                        strbuf_addf(&value, "+%s:%s", our_head_points_at->name,
 785                                                our_head_points_at->name);
 786                                else
 787                                        strbuf_addf(&value, "+%s:%s%s", our_head_points_at->name,
 788                                                branch_top->buf, option_branch);
 789                        } else if (remote_head_points_at) {
 790                                const char *head = remote_head_points_at->name;
 791                                if (!skip_prefix(head, "refs/heads/", &head))
 792                                        die("BUG: remote HEAD points at non-head?");
 793
 794                                strbuf_addf(&value, "+%s:%s%s", remote_head_points_at->name,
 795                                                branch_top->buf, head);
 796                        }
 797                        /*
 798                         * otherwise, the next "git fetch" will
 799                         * simply fetch from HEAD without updating
 800                         * any remote-tracking branch, which is what
 801                         * we want.
 802                         */
 803                } else {
 804                        strbuf_addf(&value, "+%s*:%s*", src_ref_prefix, branch_top->buf);
 805                }
 806                /* Configure the remote */
 807                if (value.len) {
 808                        strbuf_addf(&key, "remote.%s.fetch", option_origin);
 809                        git_config_set_multivar(key.buf, value.buf, "^$", 0);
 810                        strbuf_reset(&key);
 811
 812                        if (option_mirror) {
 813                                strbuf_addf(&key, "remote.%s.mirror", option_origin);
 814                                git_config_set(key.buf, "true");
 815                                strbuf_reset(&key);
 816                        }
 817                }
 818        }
 819
 820        strbuf_release(&key);
 821        strbuf_release(&value);
 822}
 823
 824static void dissociate_from_references(void)
 825{
 826        static const char* argv[] = { "repack", "-a", "-d", NULL };
 827        char *alternates = git_pathdup("objects/info/alternates");
 828
 829        if (!access(alternates, F_OK)) {
 830                if (run_command_v_opt(argv, RUN_GIT_CMD|RUN_COMMAND_NO_STDIN))
 831                        die(_("cannot repack to clean up"));
 832                if (unlink(alternates) && errno != ENOENT)
 833                        die_errno(_("cannot unlink temporary alternates file"));
 834        }
 835        free(alternates);
 836}
 837
 838int cmd_clone(int argc, const char **argv, const char *prefix)
 839{
 840        int is_bundle = 0, is_local;
 841        struct stat buf;
 842        const char *repo_name, *repo, *work_tree, *git_dir;
 843        char *path, *dir;
 844        int dest_exists;
 845        const struct ref *refs, *remote_head;
 846        const struct ref *remote_head_points_at;
 847        const struct ref *our_head_points_at;
 848        struct ref *mapped_refs;
 849        const struct ref *ref;
 850        struct strbuf key = STRBUF_INIT, value = STRBUF_INIT;
 851        struct strbuf branch_top = STRBUF_INIT, reflog_msg = STRBUF_INIT;
 852        struct transport *transport = NULL;
 853        const char *src_ref_prefix = "refs/heads/";
 854        struct remote *remote;
 855        int err = 0, complete_refs_before_fetch = 1;
 856        int submodule_progress;
 857
 858        struct refspec *refspec;
 859        const char *fetch_pattern;
 860
 861        packet_trace_identity("clone");
 862        argc = parse_options(argc, argv, prefix, builtin_clone_options,
 863                             builtin_clone_usage, 0);
 864
 865        if (argc > 2)
 866                usage_msg_opt(_("Too many arguments."),
 867                        builtin_clone_usage, builtin_clone_options);
 868
 869        if (argc == 0)
 870                usage_msg_opt(_("You must specify a repository to clone."),
 871                        builtin_clone_usage, builtin_clone_options);
 872
 873        if (option_depth || option_since || option_not.nr)
 874                deepen = 1;
 875        if (option_single_branch == -1)
 876                option_single_branch = deepen ? 1 : 0;
 877
 878        if (option_mirror)
 879                option_bare = 1;
 880
 881        if (option_bare) {
 882                if (option_origin)
 883                        die(_("--bare and --origin %s options are incompatible."),
 884                            option_origin);
 885                if (real_git_dir)
 886                        die(_("--bare and --separate-git-dir are incompatible."));
 887                option_no_checkout = 1;
 888        }
 889
 890        if (!option_origin)
 891                option_origin = "origin";
 892
 893        repo_name = argv[0];
 894
 895        path = get_repo_path(repo_name, &is_bundle);
 896        if (path)
 897                repo = absolute_pathdup(repo_name);
 898        else if (!strchr(repo_name, ':'))
 899                die(_("repository '%s' does not exist"), repo_name);
 900        else
 901                repo = repo_name;
 902
 903        /* no need to be strict, transport_set_option() will validate it again */
 904        if (option_depth && atoi(option_depth) < 1)
 905                die(_("depth %s is not a positive number"), option_depth);
 906
 907        if (argc == 2)
 908                dir = xstrdup(argv[1]);
 909        else
 910                dir = guess_dir_name(repo_name, is_bundle, option_bare);
 911        strip_trailing_slashes(dir);
 912
 913        dest_exists = !stat(dir, &buf);
 914        if (dest_exists && !is_empty_dir(dir))
 915                die(_("destination path '%s' already exists and is not "
 916                        "an empty directory."), dir);
 917
 918        strbuf_addf(&reflog_msg, "clone: from %s", repo);
 919
 920        if (option_bare)
 921                work_tree = NULL;
 922        else {
 923                work_tree = getenv("GIT_WORK_TREE");
 924                if (work_tree && !stat(work_tree, &buf))
 925                        die(_("working tree '%s' already exists."), work_tree);
 926        }
 927
 928        if (option_bare || work_tree)
 929                git_dir = xstrdup(dir);
 930        else {
 931                work_tree = dir;
 932                git_dir = mkpathdup("%s/.git", dir);
 933        }
 934
 935        atexit(remove_junk);
 936        sigchain_push_common(remove_junk_on_signal);
 937
 938        if (!option_bare) {
 939                if (safe_create_leading_directories_const(work_tree) < 0)
 940                        die_errno(_("could not create leading directories of '%s'"),
 941                                  work_tree);
 942                if (!dest_exists && mkdir(work_tree, 0777))
 943                        die_errno(_("could not create work tree dir '%s'"),
 944                                  work_tree);
 945                junk_work_tree = work_tree;
 946                set_git_work_tree(work_tree);
 947        }
 948
 949        junk_git_dir = real_git_dir ? real_git_dir : git_dir;
 950        if (safe_create_leading_directories_const(git_dir) < 0)
 951                die(_("could not create leading directories of '%s'"), git_dir);
 952
 953        if (0 <= option_verbosity) {
 954                if (option_bare)
 955                        fprintf(stderr, _("Cloning into bare repository '%s'...\n"), dir);
 956                else
 957                        fprintf(stderr, _("Cloning into '%s'...\n"), dir);
 958        }
 959
 960        if (option_recursive) {
 961                if (option_required_reference.nr &&
 962                    option_optional_reference.nr)
 963                        die(_("clone --recursive is not compatible with "
 964                              "both --reference and --reference-if-able"));
 965                else if (option_required_reference.nr) {
 966                        string_list_append(&option_config,
 967                                "submodule.alternateLocation=superproject");
 968                        string_list_append(&option_config,
 969                                "submodule.alternateErrorStrategy=die");
 970                } else if (option_optional_reference.nr) {
 971                        string_list_append(&option_config,
 972                                "submodule.alternateLocation=superproject");
 973                        string_list_append(&option_config,
 974                                "submodule.alternateErrorStrategy=info");
 975                }
 976        }
 977
 978        init_db(git_dir, real_git_dir, option_template, INIT_DB_QUIET);
 979
 980        if (real_git_dir)
 981                git_dir = real_git_dir;
 982
 983        write_config(&option_config);
 984
 985        git_config(git_default_config, NULL);
 986
 987        if (option_bare) {
 988                if (option_mirror)
 989                        src_ref_prefix = "refs/";
 990                strbuf_addstr(&branch_top, src_ref_prefix);
 991
 992                git_config_set("core.bare", "true");
 993        } else {
 994                strbuf_addf(&branch_top, "refs/remotes/%s/", option_origin);
 995        }
 996
 997        strbuf_addf(&value, "+%s*:%s*", src_ref_prefix, branch_top.buf);
 998        strbuf_addf(&key, "remote.%s.url", option_origin);
 999        git_config_set(key.buf, repo);
1000        strbuf_reset(&key);
1001
1002        if (option_required_reference.nr || option_optional_reference.nr)
1003                setup_reference();
1004
1005        fetch_pattern = value.buf;
1006        refspec = parse_fetch_refspec(1, &fetch_pattern);
1007
1008        strbuf_reset(&value);
1009
1010        remote = remote_get(option_origin);
1011        transport = transport_get(remote, remote->url[0]);
1012        transport_set_verbosity(transport, option_verbosity, option_progress);
1013        transport->family = family;
1014
1015        path = get_repo_path(remote->url[0], &is_bundle);
1016        is_local = option_local != 0 && path && !is_bundle;
1017        if (is_local) {
1018                if (option_depth)
1019                        warning(_("--depth is ignored in local clones; use file:// instead."));
1020                if (option_since)
1021                        warning(_("--shallow-since is ignored in local clones; use file:// instead."));
1022                if (option_not.nr)
1023                        warning(_("--shallow-exclude is ignored in local clones; use file:// instead."));
1024                if (!access(mkpath("%s/shallow", path), F_OK)) {
1025                        if (option_local > 0)
1026                                warning(_("source repository is shallow, ignoring --local"));
1027                        is_local = 0;
1028                }
1029        }
1030        if (option_local > 0 && !is_local)
1031                warning(_("--local is ignored"));
1032        transport->cloning = 1;
1033
1034        if (!transport->get_refs_list || (!is_local && !transport->fetch))
1035                die(_("Don't know how to clone %s"), transport->url);
1036
1037        transport_set_option(transport, TRANS_OPT_KEEP, "yes");
1038
1039        if (option_depth)
1040                transport_set_option(transport, TRANS_OPT_DEPTH,
1041                                     option_depth);
1042        if (option_since)
1043                transport_set_option(transport, TRANS_OPT_DEEPEN_SINCE,
1044                                     option_since);
1045        if (option_not.nr)
1046                transport_set_option(transport, TRANS_OPT_DEEPEN_NOT,
1047                                     (const char *)&option_not);
1048        if (option_single_branch)
1049                transport_set_option(transport, TRANS_OPT_FOLLOWTAGS, "1");
1050
1051        if (option_upload_pack)
1052                transport_set_option(transport, TRANS_OPT_UPLOADPACK,
1053                                     option_upload_pack);
1054
1055        if (transport->smart_options && !deepen)
1056                transport->smart_options->check_self_contained_and_connected = 1;
1057
1058        refs = transport_get_remote_refs(transport);
1059
1060        if (refs) {
1061                mapped_refs = wanted_peer_refs(refs, refspec);
1062                /*
1063                 * transport_get_remote_refs() may return refs with null sha-1
1064                 * in mapped_refs (see struct transport->get_refs_list
1065                 * comment). In that case we need fetch it early because
1066                 * remote_head code below relies on it.
1067                 *
1068                 * for normal clones, transport_get_remote_refs() should
1069                 * return reliable ref set, we can delay cloning until after
1070                 * remote HEAD check.
1071                 */
1072                for (ref = refs; ref; ref = ref->next)
1073                        if (is_null_oid(&ref->old_oid)) {
1074                                complete_refs_before_fetch = 0;
1075                                break;
1076                        }
1077
1078                if (!is_local && !complete_refs_before_fetch)
1079                        transport_fetch_refs(transport, mapped_refs);
1080
1081                remote_head = find_ref_by_name(refs, "HEAD");
1082                remote_head_points_at =
1083                        guess_remote_head(remote_head, mapped_refs, 0);
1084
1085                if (option_branch) {
1086                        our_head_points_at =
1087                                find_remote_branch(mapped_refs, option_branch);
1088
1089                        if (!our_head_points_at)
1090                                die(_("Remote branch %s not found in upstream %s"),
1091                                    option_branch, option_origin);
1092                }
1093                else
1094                        our_head_points_at = remote_head_points_at;
1095        }
1096        else {
1097                if (option_branch)
1098                        die(_("Remote branch %s not found in upstream %s"),
1099                                        option_branch, option_origin);
1100
1101                warning(_("You appear to have cloned an empty repository."));
1102                mapped_refs = NULL;
1103                our_head_points_at = NULL;
1104                remote_head_points_at = NULL;
1105                remote_head = NULL;
1106                option_no_checkout = 1;
1107                if (!option_bare)
1108                        install_branch_config(0, "master", option_origin,
1109                                              "refs/heads/master");
1110        }
1111
1112        write_refspec_config(src_ref_prefix, our_head_points_at,
1113                        remote_head_points_at, &branch_top);
1114
1115        if (is_local)
1116                clone_local(path, git_dir);
1117        else if (refs && complete_refs_before_fetch)
1118                transport_fetch_refs(transport, mapped_refs);
1119
1120        update_remote_refs(refs, mapped_refs, remote_head_points_at,
1121                           branch_top.buf, reflog_msg.buf, transport, !is_local);
1122
1123        update_head(our_head_points_at, remote_head, reflog_msg.buf);
1124
1125        /*
1126         * We want to show progress for recursive submodule clones iff
1127         * we did so for the main clone. But only the transport knows
1128         * the final decision for this flag, so we need to rescue the value
1129         * before we free the transport.
1130         */
1131        submodule_progress = transport->progress;
1132
1133        transport_unlock_pack(transport);
1134        transport_disconnect(transport);
1135
1136        if (option_dissociate) {
1137                close_all_packs();
1138                dissociate_from_references();
1139        }
1140
1141        junk_mode = JUNK_LEAVE_REPO;
1142        err = checkout(submodule_progress);
1143
1144        strbuf_release(&reflog_msg);
1145        strbuf_release(&branch_top);
1146        strbuf_release(&key);
1147        strbuf_release(&value);
1148        junk_mode = JUNK_LEAVE_ALL;
1149
1150        free(refspec);
1151        return err;
1152}