]> git.ipfire.org Git - thirdparty/git.git/blame - builtin/clone.c
bundle-uri: create basic file-copy logic
[thirdparty/git.git] / builtin / clone.c
CommitLineData
8434c2f1
DB
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
f8adbec9 11#define USE_THE_INDEX_COMPATIBILITY_MACROS
c2e86add 12#include "builtin.h"
b2141fc1 13#include "config.h"
697cc8ef 14#include "lockfile.h"
8434c2f1
DB
15#include "parse-options.h"
16#include "fetch-pack.h"
17#include "refs.h"
ec0cb496 18#include "refspec.h"
cbd53a21 19#include "object-store.h"
8434c2f1
DB
20#include "tree.h"
21#include "tree-walk.h"
22#include "unpack-trees.h"
23#include "transport.h"
24#include "strbuf.h"
25#include "dir.h"
ff7ccc8c
MT
26#include "dir-iterator.h"
27#include "iterator.h"
4a16d072 28#include "sigchain.h"
a9f2c136 29#include "branch.h"
8ef51733 30#include "remote.h"
dfa7a6c5 31#include "run-command.h"
0433ad12 32#include "connected.h"
3836d88a 33#include "packfile.h"
548719fb 34#include "list-objects-filter-options.h"
72ddf34d 35#include "hook.h"
86fdd94d 36#include "bundle.h"
8434c2f1
DB
37
38/*
39 * Overall FIXMEs:
40 * - respect DB_ENVIRONMENT for .git/objects.
41 *
42 * Implementation notes:
43 * - dropping use-separate-remote and no-separate-remote compatibility
44 *
45 */
46static const char * const builtin_clone_usage[] = {
9c9b4f2f 47 N_("git clone [<options>] [--] <repo> [<dir>]"),
8434c2f1
DB
48 NULL
49};
50
3e6e0edd 51static int option_no_checkout, option_bare, option_mirror, option_single_branch = -1;
bb62e0a9 52static int option_local = -1, option_no_hardlinks, option_shared;
0dab2468 53static int option_no_tags;
18a74a09 54static int option_shallow_submodules;
4fe788b1
LL
55static int option_reject_shallow = -1; /* unspecified */
56static int config_reject_shallow = -1; /* unspecified */
994c2aaf
NTND
57static int deepen;
58static char *option_template, *option_depth, *option_since;
8434c2f1 59static char *option_origin = NULL;
de9ed3ef 60static char *remote_name = NULL;
7a4ee28f 61static char *option_branch = NULL;
859e5df9 62static struct string_list option_not = STRING_LIST_INIT_NODUP;
b57fb80a 63static const char *real_git_dir;
8434c2f1 64static char *option_upload_pack = "git-upload-pack";
5bd631b3 65static int option_verbosity;
01fdc21f 66static int option_progress = -1;
d89f09c8 67static int option_sparse_checkout;
c915f11e 68static enum transport_family family;
2721ce21 69static struct string_list option_config = STRING_LIST_INIT_NODUP;
5e40800d 70static struct string_list option_required_reference = STRING_LIST_INIT_NODUP;
f7415b4d 71static struct string_list option_optional_reference = STRING_LIST_INIT_NODUP;
fb1d6dab 72static int option_dissociate;
72290d6a 73static int max_jobs = -1;
bb62e0a9 74static struct string_list option_recurse_submodules = STRING_LIST_INIT_NODUP;
548719fb 75static struct list_objects_filter_options filter_options;
f05da2b4
JS
76static int option_filter_submodules = -1; /* unspecified */
77static int config_filter_submodules = -1; /* unspecified */
6e983059 78static struct string_list server_options = STRING_LIST_INIT_NODUP;
4c691016 79static int option_remote_submodules;
bb62e0a9
BW
80
81static int recurse_submodules_cb(const struct option *opt,
82 const char *arg, int unset)
83{
84 if (unset)
85 string_list_clear((struct string_list *)opt->value, 0);
86 else if (arg)
87 string_list_append((struct string_list *)opt->value, arg);
88 else
89 string_list_append((struct string_list *)opt->value,
90 (const char *)opt->defval);
91
92 return 0;
93}
dbc92b07 94
8434c2f1 95static struct option builtin_clone_options[] = {
5bd631b3 96 OPT__VERBOSITY(&option_verbosity),
01fdc21f 97 OPT_BOOL(0, "progress", &option_progress,
32b77add 98 N_("force progress reporting")),
4fe788b1
LL
99 OPT_BOOL(0, "reject-shallow", &option_reject_shallow,
100 N_("don't clone shallow repository")),
d5d09d47
SB
101 OPT_BOOL('n', "no-checkout", &option_no_checkout,
102 N_("don't create a checkout")),
4741edd5
SB
103 OPT_BOOL(0, "bare", &option_bare, N_("create a bare repository")),
104 OPT_HIDDEN_BOOL(0, "naked", &option_bare,
105 N_("create a bare repository")),
d5d09d47
SB
106 OPT_BOOL(0, "mirror", &option_mirror,
107 N_("create a mirror repository (implies bare)")),
189260b1 108 OPT_BOOL('l', "local", &option_local,
32b77add 109 N_("to clone from a local repository")),
d5d09d47 110 OPT_BOOL(0, "no-hardlinks", &option_no_hardlinks,
32b77add 111 N_("don't use local hardlinks, always copy")),
d5d09d47 112 OPT_BOOL('s', "shared", &option_shared,
32b77add 113 N_("setup as shared repository")),
bb62e0a9
BW
114 { OPTION_CALLBACK, 0, "recurse-submodules", &option_recurse_submodules,
115 N_("pathspec"), N_("initialize submodules in the clone"),
116 PARSE_OPT_OPTARG, recurse_submodules_cb, (intptr_t)"." },
c28b036f 117 OPT_ALIAS(0, "recursive", "recurse-submodules"),
72290d6a
SB
118 OPT_INTEGER('j', "jobs", &max_jobs,
119 N_("number of submodules cloned in parallel")),
32b77add
NTND
120 OPT_STRING(0, "template", &option_template, N_("template-directory"),
121 N_("directory from which templates will be used")),
5e40800d 122 OPT_STRING_LIST(0, "reference", &option_required_reference, N_("repo"),
8ade009c 123 N_("reference repository")),
f7415b4d
SB
124 OPT_STRING_LIST(0, "reference-if-able", &option_optional_reference,
125 N_("repo"), N_("reference repository")),
14f8b9b4
JK
126 OPT_BOOL(0, "dissociate", &option_dissociate,
127 N_("use --reference only while cloning")),
32b77add
NTND
128 OPT_STRING('o', "origin", &option_origin, N_("name"),
129 N_("use <name> instead of 'origin' to track upstream")),
130 OPT_STRING('b', "branch", &option_branch, N_("branch"),
131 N_("checkout <branch> instead of the remote's HEAD")),
132 OPT_STRING('u', "upload-pack", &option_upload_pack, N_("path"),
133 N_("path to git-upload-pack on the remote")),
134 OPT_STRING(0, "depth", &option_depth, N_("depth"),
135 N_("create a shallow clone of that depth")),
994c2aaf
NTND
136 OPT_STRING(0, "shallow-since", &option_since, N_("time"),
137 N_("create a shallow clone since a specific time")),
859e5df9 138 OPT_STRING_LIST(0, "shallow-exclude", &option_not, N_("revision"),
6d873865 139 N_("deepen history of shallow clone, excluding rev")),
3e6e0edd 140 OPT_BOOL(0, "single-branch", &option_single_branch,
32b77add 141 N_("clone only one branch, HEAD or --branch")),
0dab2468
ÆAB
142 OPT_BOOL(0, "no-tags", &option_no_tags,
143 N_("don't clone any tags, and make later fetches not to follow them")),
d22eb044
SB
144 OPT_BOOL(0, "shallow-submodules", &option_shallow_submodules,
145 N_("any cloned submodules will be shallow")),
32b77add
NTND
146 OPT_STRING(0, "separate-git-dir", &real_git_dir, N_("gitdir"),
147 N_("separate git dir from working tree")),
148 OPT_STRING_LIST('c', "config", &option_config, N_("key=value"),
149 N_("set config inside the new repository")),
6e983059
JT
150 OPT_STRING_LIST(0, "server-option", &server_options,
151 N_("server-specific"), N_("option to transmit")),
c915f11e
EW
152 OPT_SET_INT('4', "ipv4", &family, N_("use IPv4 addresses only"),
153 TRANSPORT_FAMILY_IPV4),
154 OPT_SET_INT('6', "ipv6", &family, N_("use IPv6 addresses only"),
155 TRANSPORT_FAMILY_IPV6),
548719fb 156 OPT_PARSE_LIST_OBJECTS_FILTER(&filter_options),
f05da2b4
JS
157 OPT_BOOL(0, "also-filter-submodules", &option_filter_submodules,
158 N_("apply partial clone filters to submodules")),
4c691016
BA
159 OPT_BOOL(0, "remote-submodules", &option_remote_submodules,
160 N_("any cloned submodules will use their remote-tracking branch")),
d89f09c8
DS
161 OPT_BOOL(0, "sparse", &option_sparse_checkout,
162 N_("initialize sparse-checkout file to include only files at root")),
8434c2f1
DB
163 OPT_END()
164};
165
0ea68e42 166static const char *get_repo_path_1(struct strbuf *path, int *is_bundle)
8434c2f1 167{
b3256eb8 168 static char *suffix[] = { "/.git", "", ".git/.git", ".git" };
8434c2f1 169 static char *bundle_suffix[] = { ".bundle", "" };
0ea68e42 170 size_t baselen = path->len;
8434c2f1
DB
171 struct stat st;
172 int i;
173
174 for (i = 0; i < ARRAY_SIZE(suffix); i++) {
0ea68e42
JK
175 strbuf_setlen(path, baselen);
176 strbuf_addstr(path, suffix[i]);
177 if (stat(path->buf, &st))
9b0ebc72 178 continue;
0ea68e42 179 if (S_ISDIR(st.st_mode) && is_git_directory(path->buf)) {
8434c2f1 180 *is_bundle = 0;
0ea68e42 181 return path->buf;
9b0ebc72
NTND
182 } else if (S_ISREG(st.st_mode) && st.st_size > 8) {
183 /* Is it a "gitfile"? */
184 char signature[8];
0ea68e42
JK
185 const char *dst;
186 int len, fd = open(path->buf, O_RDONLY);
9b0ebc72
NTND
187 if (fd < 0)
188 continue;
189 len = read_in_full(fd, signature, 8);
190 close(fd);
191 if (len != 8 || strncmp(signature, "gitdir: ", 8))
192 continue;
0ea68e42
JK
193 dst = read_gitfile(path->buf);
194 if (dst) {
9b0ebc72 195 *is_bundle = 0;
0ea68e42 196 return dst;
9b0ebc72 197 }
8434c2f1
DB
198 }
199 }
200
201 for (i = 0; i < ARRAY_SIZE(bundle_suffix); i++) {
0ea68e42
JK
202 strbuf_setlen(path, baselen);
203 strbuf_addstr(path, bundle_suffix[i]);
204 if (!stat(path->buf, &st) && S_ISREG(st.st_mode)) {
8434c2f1 205 *is_bundle = 1;
0ea68e42 206 return path->buf;
8434c2f1
DB
207 }
208 }
209
210 return NULL;
211}
212
0ea68e42
JK
213static char *get_repo_path(const char *repo, int *is_bundle)
214{
215 struct strbuf path = STRBUF_INIT;
216 const char *raw;
217 char *canon;
218
219 strbuf_addstr(&path, repo);
220 raw = get_repo_path_1(&path, is_bundle);
0aaad415 221 canon = raw ? absolute_pathdup(raw) : NULL;
0ea68e42
JK
222 strbuf_release(&path);
223 return canon;
224}
225
dbc92b07 226static int add_one_reference(struct string_list_item *item, void *cb_data)
8434c2f1 227{
9eeea7d2 228 struct strbuf err = STRBUF_INIT;
f7415b4d 229 int *required = cb_data;
9eeea7d2 230 char *ref_git = compute_alternate_path(item->string, &err);
8434c2f1 231
f7415b4d
SB
232 if (!ref_git) {
233 if (*required)
234 die("%s", err.buf);
235 else
236 fprintf(stderr,
237 _("info: Could not add alternate for '%s': %s\n"),
238 item->string, err.buf);
239 } else {
240 struct strbuf sb = STRBUF_INIT;
241 strbuf_addf(&sb, "%s/objects", ref_git);
242 add_to_alternates_file(sb.buf);
243 strbuf_release(&sb);
244 }
606e435a 245
9eeea7d2 246 strbuf_release(&err);
f7415b4d 247 free(ref_git);
dbc92b07
JH
248 return 0;
249}
8434c2f1 250
dbc92b07
JH
251static void setup_reference(void)
252{
f7415b4d
SB
253 int required = 1;
254 for_each_string_list(&option_required_reference,
255 add_one_reference, &required);
256 required = 0;
257 for_each_string_list(&option_optional_reference,
258 add_one_reference, &required);
8434c2f1
DB
259}
260
3c1dce88 261static void copy_alternates(struct strbuf *src, const char *src_repo)
e6baf4a1
JH
262{
263 /*
264 * Read from the source objects/info/alternates file
265 * and copy the entries to corresponding file in the
266 * destination repository with add_to_alternates_file().
267 * Both src and dst have "$path/objects/info/alternates".
268 *
269 * Instead of copying bit-for-bit from the original,
270 * we need to append to existing one so that the already
271 * created entry via "clone -s" is not lost, and also
272 * to turn entries with paths relative to the original
273 * absolute, so that they can be used in the new repository.
274 */
02912f47 275 FILE *in = xfopen(src->buf, "r");
e6baf4a1
JH
276 struct strbuf line = STRBUF_INIT;
277
3f163962 278 while (strbuf_getline(&line, in) != EOF) {
dcf69262 279 char *abs_path;
e6baf4a1
JH
280 if (!line.len || line.buf[0] == '#')
281 continue;
282 if (is_absolute_path(line.buf)) {
283 add_to_alternates_file(line.buf);
284 continue;
285 }
dcf69262 286 abs_path = mkpathdup("%s/objects/%s", src_repo, line.buf);
22d3b8de
JK
287 if (!normalize_path_copy(abs_path, abs_path))
288 add_to_alternates_file(abs_path);
289 else
290 warning("skipping invalid relative alternate: %s/%s",
291 src_repo, line.buf);
dcf69262 292 free(abs_path);
e6baf4a1
JH
293 }
294 strbuf_release(&line);
295 fclose(in);
296}
297
14954b79
MT
298static void mkdir_if_missing(const char *pathname, mode_t mode)
299{
300 struct stat st;
301
302 if (!mkdir(pathname, mode))
303 return;
304
305 if (errno != EEXIST)
306 die_errno(_("failed to create directory '%s'"), pathname);
307 else if (stat(pathname, &st))
308 die_errno(_("failed to stat '%s'"), pathname);
309 else if (!S_ISDIR(st.st_mode))
310 die(_("%s exists and is not a directory"), pathname);
311}
312
e6baf4a1 313static void copy_or_link_directory(struct strbuf *src, struct strbuf *dest,
ff7ccc8c 314 const char *src_repo)
8434c2f1 315{
8434c2f1 316 int src_len, dest_len;
ff7ccc8c
MT
317 struct dir_iterator *iter;
318 int iter_status;
319 unsigned int flags;
3d7747e3 320 struct strbuf realpath = STRBUF_INIT;
8434c2f1 321
14954b79 322 mkdir_if_missing(dest->buf, 0777);
8434c2f1 323
ff7ccc8c
MT
324 flags = DIR_ITERATOR_PEDANTIC | DIR_ITERATOR_FOLLOW_SYMLINKS;
325 iter = dir_iterator_begin(src->buf, flags);
326
327 if (!iter)
328 die_errno(_("failed to start iterator over '%s'"), src->buf);
8434c2f1 329
b9e125e0
MV
330 strbuf_addch(src, '/');
331 src_len = src->len;
332 strbuf_addch(dest, '/');
333 dest_len = dest->len;
8434c2f1 334
ff7ccc8c 335 while ((iter_status = dir_iterator_advance(iter)) == ITER_OK) {
b9e125e0 336 strbuf_setlen(src, src_len);
ff7ccc8c 337 strbuf_addstr(src, iter->relative_path);
b9e125e0 338 strbuf_setlen(dest, dest_len);
ff7ccc8c
MT
339 strbuf_addstr(dest, iter->relative_path);
340
341 if (S_ISDIR(iter->st.st_mode)) {
342 mkdir_if_missing(dest->buf, 0777);
e6baf4a1
JH
343 continue;
344 }
345
346 /* Files that cannot be copied bit-for-bit... */
c4d9c506 347 if (!fspathcmp(iter->relative_path, "info/alternates")) {
3c1dce88 348 copy_alternates(src, src_repo);
8434c2f1
DB
349 continue;
350 }
351
b9e125e0 352 if (unlink(dest->buf) && errno != ENOENT)
e84d7b74 353 die_errno(_("failed to unlink '%s'"), dest->buf);
fdabc242 354 if (!option_no_hardlinks) {
3d7747e3
AM
355 strbuf_realpath(&realpath, src->buf, 1);
356 if (!link(realpath.buf, dest->buf))
fdabc242 357 continue;
189260b1 358 if (option_local > 0)
e84d7b74 359 die_errno(_("failed to create link '%s'"), dest->buf);
fdabc242 360 option_no_hardlinks = 1;
8434c2f1 361 }
f7835a25 362 if (copy_file_with_time(dest->buf, src->buf, 0666))
e84d7b74 363 die_errno(_("failed to copy file to '%s'"), dest->buf);
8434c2f1 364 }
ff7ccc8c
MT
365
366 if (iter_status != ITER_DONE) {
367 strbuf_setlen(src, src_len);
368 die(_("failed to iterate over '%s'"), src->buf);
369 }
3d7747e3
AM
370
371 strbuf_release(&realpath);
8434c2f1
DB
372}
373
6f48d39f 374static void clone_local(const char *src_repo, const char *dest_repo)
8434c2f1 375{
e6baf4a1
JH
376 if (option_shared) {
377 struct strbuf alt = STRBUF_INIT;
b3b05971
ES
378 get_common_dir(&alt, src_repo);
379 strbuf_addstr(&alt, "/objects");
e6baf4a1
JH
380 add_to_alternates_file(alt.buf);
381 strbuf_release(&alt);
382 } else {
383 struct strbuf src = STRBUF_INIT;
384 struct strbuf dest = STRBUF_INIT;
744e4697
NTND
385 get_common_dir(&src, src_repo);
386 get_common_dir(&dest, dest_repo);
387 strbuf_addstr(&src, "/objects");
388 strbuf_addstr(&dest, "/objects");
ff7ccc8c 389 copy_or_link_directory(&src, &dest, src_repo);
b9e125e0
MV
390 strbuf_release(&src);
391 strbuf_release(&dest);
8434c2f1
DB
392 }
393
28ba96ab 394 if (0 <= option_verbosity)
68b939b2 395 fprintf(stderr, _("done.\n"));
8434c2f1
DB
396}
397
398static const char *junk_work_tree;
d45420c1 399static int junk_work_tree_flags;
8434c2f1 400static const char *junk_git_dir;
d45420c1 401static int junk_git_dir_flags;
85064630 402static enum {
d3b34622
JK
403 JUNK_LEAVE_NONE,
404 JUNK_LEAVE_REPO,
405 JUNK_LEAVE_ALL
406} junk_mode = JUNK_LEAVE_NONE;
407
408static const char junk_leave_repo_msg[] =
409N_("Clone succeeded, but checkout failed.\n"
410 "You can inspect what was checked out with 'git status'\n"
80f537f7 411 "and retry with 'git restore --source=HEAD :/'\n");
8434c2f1
DB
412
413static void remove_junk(void)
414{
f285a2d7 415 struct strbuf sb = STRBUF_INIT;
d3b34622
JK
416
417 switch (junk_mode) {
418 case JUNK_LEAVE_REPO:
419 warning("%s", _(junk_leave_repo_msg));
420 /* fall-through */
421 case JUNK_LEAVE_ALL:
422 return;
423 default:
424 /* proceed to removal */
425 break;
426 }
427
8434c2f1
DB
428 if (junk_git_dir) {
429 strbuf_addstr(&sb, junk_git_dir);
d45420c1 430 remove_dir_recursively(&sb, junk_git_dir_flags);
8434c2f1
DB
431 strbuf_reset(&sb);
432 }
433 if (junk_work_tree) {
434 strbuf_addstr(&sb, junk_work_tree);
d45420c1 435 remove_dir_recursively(&sb, junk_work_tree_flags);
8434c2f1 436 }
9c18b548 437 strbuf_release(&sb);
8434c2f1
DB
438}
439
440static void remove_junk_on_signal(int signo)
441{
442 remove_junk();
4a16d072 443 sigchain_pop(signo);
8434c2f1
DB
444 raise(signo);
445}
446
9e585046
NTND
447static struct ref *find_remote_branch(const struct ref *refs, const char *branch)
448{
449 struct ref *ref;
450 struct strbuf head = STRBUF_INIT;
451 strbuf_addstr(&head, "refs/heads/");
452 strbuf_addstr(&head, branch);
453 ref = find_ref_by_name(refs, head.buf);
454 strbuf_release(&head);
5a7d5b68
NTND
455
456 if (ref)
457 return ref;
458
459 strbuf_addstr(&head, "refs/tags/");
460 strbuf_addstr(&head, branch);
461 ref = find_ref_by_name(refs, head.buf);
462 strbuf_release(&head);
463
9e585046
NTND
464 return ref;
465}
466
5bdc32d3 467static struct ref *wanted_peer_refs(const struct ref *refs,
515be833 468 struct refspec *refspec)
8434c2f1 469{
c1921c18
JK
470 struct ref *head = copy_ref(find_ref_by_name(refs, "HEAD"));
471 struct ref *local_refs = head;
472 struct ref **tail = head ? &head->next : &local_refs;
8434c2f1 473
3e6e0edd
NTND
474 if (option_single_branch) {
475 struct ref *remote_head = NULL;
476
477 if (!option_branch)
478 remote_head = guess_remote_head(head, refs, 0);
0ec4b165
NTND
479 else {
480 local_refs = NULL;
481 tail = &local_refs;
482 remote_head = copy_ref(find_remote_branch(refs, option_branch));
483 }
3e6e0edd
NTND
484
485 if (!remote_head && option_branch)
486 warning(_("Could not find remote branch %s to clone."),
487 option_branch);
5a7d5b68 488 else {
515be833
SG
489 int i;
490 for (i = 0; i < refspec->nr; i++)
491 get_fetch_map(remote_head, &refspec->items[i],
492 &tail, 0);
5a7d5b68
NTND
493
494 /* if --branch=tag, pull the requested tag explicitly */
495 get_fetch_map(remote_head, tag_refspec, &tail, 0);
496 }
74a06a9f 497 free_refs(remote_head);
515be833
SG
498 } else {
499 int i;
500 for (i = 0; i < refspec->nr; i++)
501 get_fetch_map(refs, &refspec->items[i], &tail, 0);
502 }
3e6e0edd 503
0dab2468 504 if (!option_mirror && !option_single_branch && !option_no_tags)
468386a9 505 get_fetch_map(refs, tag_refspec, &tail, 0);
8434c2f1 506
5bdc32d3
NP
507 return local_refs;
508}
509
510static void write_remote_refs(const struct ref *local_refs)
511{
512 const struct ref *r;
513
58f233ce
MH
514 struct ref_transaction *t;
515 struct strbuf err = STRBUF_INIT;
516
517 t = ref_transaction_begin(&err);
518 if (!t)
519 die("%s", err.buf);
9f69d297 520
c1921c18
JK
521 for (r = local_refs; r; r = r->next) {
522 if (!r->peer_ref)
523 continue;
89f3bbdd 524 if (ref_transaction_create(t, r->peer_ref->name, &r->old_oid,
58f233ce
MH
525 0, NULL, &err))
526 die("%s", err.buf);
c1921c18 527 }
3e8aded2 528
58f233ce
MH
529 if (initial_ref_transaction_commit(t, &err))
530 die("%s", err.buf);
531
532 strbuf_release(&err);
533 ref_transaction_free(t);
8434c2f1
DB
534}
535
3e6e0edd
NTND
536static void write_followtags(const struct ref *refs, const char *msg)
537{
538 const struct ref *ref;
539 for (ref = refs; ref; ref = ref->next) {
59556548 540 if (!starts_with(ref->name, "refs/tags/"))
3e6e0edd 541 continue;
59556548 542 if (ends_with(ref->name, "^{}"))
3e6e0edd 543 continue;
167a575e
JK
544 if (!has_object_file_with_flags(&ref->old_oid,
545 OBJECT_INFO_QUICK |
546 OBJECT_INFO_SKIP_FETCH_OBJECT))
3e6e0edd 547 continue;
ae077771 548 update_ref(msg, ref->name, &ref->old_oid, NULL, 0,
549 UPDATE_REFS_DIE_ON_ERR);
3e6e0edd
NTND
550 }
551}
552
9fec7b21 553static const struct object_id *iterate_ref_map(void *cb_data)
0433ad12
JK
554{
555 struct ref **rm = cb_data;
556 struct ref *ref = *rm;
557
558 /*
559 * Skip anything missing a peer_ref, which we are not
560 * actually going to write a ref for.
561 */
562 while (ref && !ref->peer_ref)
563 ref = ref->next;
0433ad12 564 if (!ref)
9fec7b21 565 return NULL;
0433ad12 566
0433ad12 567 *rm = ref->next;
9fec7b21 568 return &ref->old_oid;
0433ad12
JK
569}
570
960b7d1c
NTND
571static void update_remote_refs(const struct ref *refs,
572 const struct ref *mapped_refs,
573 const struct ref *remote_head_points_at,
574 const char *branch_top,
c6807a40 575 const char *msg,
45ed4afa 576 struct transport *transport,
2b98478c 577 int check_connectivity)
960b7d1c 578{
0433ad12
JK
579 const struct ref *rm = mapped_refs;
580
125a05fd 581 if (check_connectivity) {
7043c707
JK
582 struct check_connected_options opt = CHECK_CONNECTED_INIT;
583
584 opt.transport = transport;
38e590ea 585 opt.progress = transport->progress;
7043c707 586
7043c707 587 if (check_connected(iterate_ref_map, &rm, &opt))
125a05fd
JK
588 die(_("remote did not send all necessary objects"));
589 }
0433ad12 590
960b7d1c 591 if (refs) {
960b7d1c 592 write_remote_refs(mapped_refs);
0dab2468 593 if (option_single_branch && !option_no_tags)
960b7d1c
NTND
594 write_followtags(refs, msg);
595 }
596
597 if (remote_head_points_at && !option_bare) {
598 struct strbuf head_ref = STRBUF_INIT;
599 strbuf_addstr(&head_ref, branch_top);
600 strbuf_addstr(&head_ref, "HEAD");
4be49d75
JK
601 if (create_symref(head_ref.buf,
602 remote_head_points_at->peer_ref->name,
603 msg) < 0)
39ad4f39 604 die(_("unable to update %s"), head_ref.buf);
4be49d75 605 strbuf_release(&head_ref);
960b7d1c
NTND
606 }
607}
608
f034d354 609static void update_head(const struct ref *our, const struct ref *remote,
daf7898a 610 const char *unborn, const char *msg)
f034d354 611{
cf4fff57
JK
612 const char *head;
613 if (our && skip_prefix(our->name, "refs/heads/", &head)) {
f034d354 614 /* Local default branch link */
4be49d75 615 if (create_symref("HEAD", our->name, NULL) < 0)
39ad4f39 616 die(_("unable to update HEAD"));
f034d354 617 if (!option_bare) {
ae077771 618 update_ref(msg, "HEAD", &our->old_oid, NULL, 0,
f4124112 619 UPDATE_REFS_DIE_ON_ERR);
75ca3906 620 install_branch_config(0, head, remote_name, our->name);
f034d354 621 }
5a7d5b68 622 } else if (our) {
2122f675
SB
623 struct commit *c = lookup_commit_reference(the_repository,
624 &our->old_oid);
5a7d5b68 625 /* --branch specifies a non-branch (i.e. tags), detach HEAD */
91774afc 626 update_ref(msg, "HEAD", &c->object.oid, NULL, REF_NO_DEREF,
ae077771 627 UPDATE_REFS_DIE_ON_ERR);
f034d354
NTND
628 } else if (remote) {
629 /*
630 * We know remote HEAD points to a non-branch, or
920b691f 631 * HEAD points to a branch but we don't know which one.
f034d354
NTND
632 * Detach HEAD in all these cases.
633 */
91774afc 634 update_ref(msg, "HEAD", &remote->old_oid, NULL, REF_NO_DEREF,
ae077771 635 UPDATE_REFS_DIE_ON_ERR);
daf7898a
JK
636 } else if (unborn && skip_prefix(unborn, "refs/heads/", &head)) {
637 /*
638 * Unborn head from remote; same as "our" case above except
639 * that we have no ref to update.
640 */
641 if (create_symref("HEAD", unborn, NULL) < 0)
642 die(_("unable to update HEAD"));
643 if (!option_bare)
644 install_branch_config(0, head, remote_name, unborn);
f034d354
NTND
645 }
646}
647
d89f09c8
DS
648static int git_sparse_checkout_init(const char *repo)
649{
22f9b7f3 650 struct strvec argv = STRVEC_INIT;
d89f09c8 651 int result = 0;
d3595416 652 strvec_pushl(&argv, "-C", repo, "sparse-checkout", "set", NULL);
d89f09c8
DS
653
654 /*
655 * We must apply the setting in the current process
656 * for the later checkout to use the sparse-checkout file.
657 */
658 core_apply_sparse_checkout = 1;
659
d70a9eb6 660 if (run_command_v_opt(argv.v, RUN_GIT_CMD)) {
d89f09c8
DS
661 error(_("failed to initialize sparse-checkout"));
662 result = 1;
663 }
664
22f9b7f3 665 strvec_clear(&argv);
d89f09c8
DS
666 return result;
667}
668
f05da2b4 669static int checkout(int submodule_progress, int filter_submodules)
c39852c1 670{
ddc2cc64 671 struct object_id oid;
c39852c1 672 char *head;
837e34eb 673 struct lock_file lock_file = LOCK_INIT;
c39852c1
NTND
674 struct unpack_trees_options opts;
675 struct tree *tree;
676 struct tree_desc t;
03b86647 677 int err = 0;
c39852c1
NTND
678
679 if (option_no_checkout)
680 return 0;
681
0f2dc722 682 head = resolve_refdup("HEAD", RESOLVE_REF_READING, &oid, NULL);
c39852c1
NTND
683 if (!head) {
684 warning(_("remote HEAD refers to nonexistent ref, "
f77710c5 685 "unable to checkout"));
c39852c1
NTND
686 return 0;
687 }
2857093b 688 if (!strcmp(head, "HEAD")) {
ed9bff08 689 if (advice_enabled(ADVICE_DETACHED_HEAD))
ddc2cc64 690 detach_advice(oid_to_hex(&oid));
dfc8cdc6 691 FREE_AND_NULL(head);
2857093b 692 } else {
59556548 693 if (!starts_with(head, "refs/heads/"))
c39852c1
NTND
694 die(_("HEAD not found below refs/heads!"));
695 }
c39852c1
NTND
696
697 /* We need to be in the new work tree for the checkout */
698 setup_work_tree();
699
837e34eb 700 hold_locked_index(&lock_file, LOCK_DIE_ON_ERROR);
c39852c1
NTND
701
702 memset(&opts, 0, sizeof opts);
703 opts.update = 1;
704 opts.merge = 1;
b878579a 705 opts.clone = 1;
1b5f3733 706 opts.preserve_ignored = 0;
c39852c1 707 opts.fn = oneway_merge;
8f63da13 708 opts.verbose_update = (option_verbosity >= 0);
c39852c1
NTND
709 opts.src_index = &the_index;
710 opts.dst_index = &the_index;
dfc8cdc6 711 init_checkout_metadata(&opts.meta, head, &oid, NULL);
c39852c1 712
a9dbc179 713 tree = parse_tree_indirect(&oid);
8d2eaf64
GC
714 if (!tree)
715 die(_("unable to parse commit %s"), oid_to_hex(&oid));
c39852c1
NTND
716 parse_tree(tree);
717 init_tree_desc(&t, tree->buffer, tree->size);
0aac7bb2
JK
718 if (unpack_trees(1, &t, &opts) < 0)
719 die(_("unable to checkout working tree"));
c39852c1 720
dfc8cdc6 721 free(head);
722
837e34eb 723 if (write_locked_index(&the_index, &lock_file, COMMIT_LOCK))
c39852c1
NTND
724 die(_("unable to write new index file"));
725
72ddf34d 726 err |= run_hooks_l("post-checkout", oid_to_hex(null_oid()),
ddc2cc64 727 oid_to_hex(&oid), "1", NULL);
c39852c1 728
bb62e0a9 729 if (!err && (option_recurse_submodules.nr > 0)) {
22f9b7f3
JK
730 struct strvec args = STRVEC_INIT;
731 strvec_pushl(&args, "submodule", "update", "--require-init", "--recursive", NULL);
72290d6a 732
18a74a09 733 if (option_shallow_submodules == 1)
22f9b7f3 734 strvec_push(&args, "--depth=1");
d22eb044 735
72290d6a 736 if (max_jobs != -1)
22f9b7f3 737 strvec_pushf(&args, "--jobs=%d", max_jobs);
72290d6a 738
72c5f883 739 if (submodule_progress)
22f9b7f3 740 strvec_push(&args, "--progress");
72c5f883 741
03c004c5 742 if (option_verbosity < 0)
22f9b7f3 743 strvec_push(&args, "--quiet");
03c004c5 744
4c691016 745 if (option_remote_submodules) {
22f9b7f3
JK
746 strvec_push(&args, "--remote");
747 strvec_push(&args, "--no-fetch");
4c691016
BA
748 }
749
f05da2b4
JS
750 if (filter_submodules && filter_options.choice)
751 strvec_pushf(&args, "--filter=%s",
752 expand_list_objects_filter_spec(&filter_options));
753
132f600b 754 if (option_single_branch >= 0)
22f9b7f3 755 strvec_push(&args, option_single_branch ?
132f600b
ES
756 "--single-branch" :
757 "--no-single-branch");
758
d70a9eb6 759 err = run_command_v_opt(args.v, RUN_GIT_CMD);
22f9b7f3 760 strvec_clear(&args);
72290d6a 761 }
c39852c1
NTND
762
763 return err;
764}
765
552955ed
SB
766static int git_clone_config(const char *k, const char *v, void *cb)
767{
de9ed3ef
SB
768 if (!strcmp(k, "clone.defaultremotename")) {
769 free(remote_name);
770 remote_name = xstrdup(v);
771 }
4fe788b1
LL
772 if (!strcmp(k, "clone.rejectshallow"))
773 config_reject_shallow = git_config_bool(k, v);
f05da2b4
JS
774 if (!strcmp(k, "clone.filtersubmodules"))
775 config_filter_submodules = git_config_bool(k, v);
4fe788b1 776
552955ed
SB
777 return git_default_config(k, v, cb);
778}
779
84054f79
JK
780static int write_one_config(const char *key, const char *value, void *data)
781{
552955ed
SB
782 /*
783 * give git_clone_config a chance to write config values back to the
784 * environment, since git_config_set_multivar_gently only deals with
785 * config-file writes
786 */
787 int apply_failed = git_clone_config(key, value, data);
788 if (apply_failed)
789 return apply_failed;
790
db4eca1f
JN
791 return git_config_set_multivar_gently(key,
792 value ? value : "true",
793 CONFIG_REGEX_NONE, 0);
84054f79
JK
794}
795
796static void write_config(struct string_list *config)
797{
798 int i;
799
800 for (i = 0; i < config->nr; i++) {
801 if (git_config_parse_parameter(config->items[i].string,
802 write_one_config, NULL) < 0)
39ad4f39 803 die(_("unable to write parameters to config file"));
84054f79
JK
804 }
805}
806
24d36f14
DA
807static void write_refspec_config(const char *src_ref_prefix,
808 const struct ref *our_head_points_at,
809 const struct ref *remote_head_points_at,
810 struct strbuf *branch_top)
31b808a0
RT
811{
812 struct strbuf key = STRBUF_INIT;
813 struct strbuf value = STRBUF_INIT;
814
815 if (option_mirror || !option_bare) {
816 if (option_single_branch && !option_mirror) {
817 if (option_branch) {
60a5f5fc 818 if (starts_with(our_head_points_at->name, "refs/tags/"))
31b808a0
RT
819 strbuf_addf(&value, "+%s:%s", our_head_points_at->name,
820 our_head_points_at->name);
821 else
822 strbuf_addf(&value, "+%s:%s%s", our_head_points_at->name,
823 branch_top->buf, option_branch);
824 } else if (remote_head_points_at) {
cf4fff57
JK
825 const char *head = remote_head_points_at->name;
826 if (!skip_prefix(head, "refs/heads/", &head))
033abf97 827 BUG("remote HEAD points at non-head?");
cf4fff57 828
31b808a0 829 strbuf_addf(&value, "+%s:%s%s", remote_head_points_at->name,
cf4fff57 830 branch_top->buf, head);
31b808a0
RT
831 }
832 /*
833 * otherwise, the next "git fetch" will
834 * simply fetch from HEAD without updating
d6ac1d21 835 * any remote-tracking branch, which is what
31b808a0
RT
836 * we want.
837 */
838 } else {
839 strbuf_addf(&value, "+%s*:%s*", src_ref_prefix, branch_top->buf);
840 }
841 /* Configure the remote */
842 if (value.len) {
75ca3906 843 strbuf_addf(&key, "remote.%s.fetch", remote_name);
31b808a0
RT
844 git_config_set_multivar(key.buf, value.buf, "^$", 0);
845 strbuf_reset(&key);
846
847 if (option_mirror) {
75ca3906 848 strbuf_addf(&key, "remote.%s.mirror", remote_name);
31b808a0
RT
849 git_config_set(key.buf, "true");
850 strbuf_reset(&key);
851 }
852 }
853 }
854
855 strbuf_release(&key);
856 strbuf_release(&value);
857}
858
fb1d6dab
JH
859static void dissociate_from_references(void)
860{
861 static const char* argv[] = { "repack", "-a", "-d", NULL };
0181681e 862 char *alternates = git_pathdup("objects/info/alternates");
fb1d6dab 863
0181681e
AR
864 if (!access(alternates, F_OK)) {
865 if (run_command_v_opt(argv, RUN_GIT_CMD|RUN_COMMAND_NO_STDIN))
866 die(_("cannot repack to clean up"));
867 if (unlink(alternates) && errno != ENOENT)
868 die_errno(_("cannot unlink temporary alternates file"));
869 }
870 free(alternates);
fb1d6dab
JH
871}
872
6c020421 873static int path_exists(const char *path)
f9e377ad
JK
874{
875 struct stat sb;
876 return !stat(path, &sb);
877}
878
8434c2f1
DB
879int cmd_clone(int argc, const char **argv, const char *prefix)
880{
24c61c44 881 int is_bundle = 0, is_local;
4fe788b1 882 int reject_shallow = 0;
8434c2f1 883 const char *repo_name, *repo, *work_tree, *git_dir;
0c454273 884 char *path = NULL, *dir, *display_repo = NULL;
dfaa209a 885 int dest_exists, real_dest_exists = 0;
37148311 886 const struct ref *refs, *remote_head;
0c454273 887 struct ref *remote_head_points_at = NULL;
7a4ee28f 888 const struct ref *our_head_points_at;
daf7898a 889 char *unborn_head = NULL;
dccea605 890 struct ref *mapped_refs = NULL;
90498161 891 const struct ref *ref;
3e42cb3b 892 struct strbuf key = STRBUF_INIT;
b5ff37ac 893 struct strbuf branch_top = STRBUF_INIT, reflog_msg = STRBUF_INIT;
1db4a75c 894 struct transport *transport = NULL;
9e585046 895 const char *src_ref_prefix = "refs/heads/";
6f48d39f 896 struct remote *remote;
90498161 897 int err = 0, complete_refs_before_fetch = 1;
72c5f883 898 int submodule_progress;
f05da2b4 899 int filter_submodules = 0;
8434c2f1 900
39835409
JT
901 struct transport_ls_refs_options transport_ls_refs_options =
902 TRANSPORT_LS_REFS_OPTIONS_INIT;
8434c2f1 903
bbc30f99 904 packet_trace_identity("clone");
552955ed
SB
905
906 git_config(git_clone_config, NULL);
907
37782920 908 argc = parse_options(argc, argv, prefix, builtin_clone_options,
8434c2f1
DB
909 builtin_clone_usage, 0);
910
d52dc4b1 911 if (argc > 2)
e84d7b74 912 usage_msg_opt(_("Too many arguments."),
d52dc4b1
JN
913 builtin_clone_usage, builtin_clone_options);
914
8434c2f1 915 if (argc == 0)
e84d7b74 916 usage_msg_opt(_("You must specify a repository to clone."),
d52dc4b1 917 builtin_clone_usage, builtin_clone_options);
8434c2f1 918
859e5df9 919 if (option_depth || option_since || option_not.nr)
994c2aaf 920 deepen = 1;
3e6e0edd 921 if (option_single_branch == -1)
994c2aaf 922 option_single_branch = deepen ? 1 : 0;
3e6e0edd 923
bc699afc
JS
924 if (option_mirror)
925 option_bare = 1;
926
8434c2f1
DB
927 if (option_bare) {
928 if (option_origin)
246cac85
JNA
929 die(_("options '%s' and '%s %s' cannot be used together"),
930 "--bare", "--origin", option_origin);
95b63f1e 931 if (real_git_dir)
12909b6b 932 die(_("options '%s' and '%s' cannot be used together"), "--bare", "--separate-git-dir");
8434c2f1 933 option_no_checkout = 1;
8434c2f1
DB
934 }
935
8434c2f1
DB
936 repo_name = argv[0];
937
938 path = get_repo_path(repo_name, &is_bundle);
0c454273
AH
939 if (path) {
940 FREE_AND_NULL(path);
0aaad415 941 repo = absolute_pathdup(repo_name);
0c454273 942 } else if (strchr(repo_name, ':')) {
8434c2f1 943 repo = repo_name;
46da295a
JS
944 display_repo = transport_anonymize_url(repo);
945 } else
946 die(_("repository '%s' does not exist"), repo_name);
8434c2f1 947
5594bcad
NTND
948 /* no need to be strict, transport_set_option() will validate it again */
949 if (option_depth && atoi(option_depth) < 1)
950 die(_("depth %s is not a positive number"), option_depth);
951
8434c2f1
DB
952 if (argc == 2)
953 dir = xstrdup(argv[1]);
954 else
ed86301f
AR
955 dir = git_url_basename(repo_name, is_bundle, option_bare);
956 strip_dir_trailing_slashes(dir);
8434c2f1 957
6c020421 958 dest_exists = path_exists(dir);
55892d23 959 if (dest_exists && !is_empty_dir(dir))
e84d7b74
ÆAB
960 die(_("destination path '%s' already exists and is not "
961 "an empty directory."), dir);
8434c2f1 962
dfaa209a
BW
963 if (real_git_dir) {
964 real_dest_exists = path_exists(real_git_dir);
965 if (real_dest_exists && !is_empty_dir(real_git_dir))
966 die(_("repository path '%s' already exists and is not "
967 "an empty directory."), real_git_dir);
968 }
969
970
46da295a
JS
971 strbuf_addf(&reflog_msg, "clone: from %s",
972 display_repo ? display_repo : repo);
973 free(display_repo);
8434c2f1
DB
974
975 if (option_bare)
976 work_tree = NULL;
977 else {
978 work_tree = getenv("GIT_WORK_TREE");
6c020421 979 if (work_tree && path_exists(work_tree))
e84d7b74 980 die(_("working tree '%s' already exists."), work_tree);
8434c2f1
DB
981 }
982
983 if (option_bare || work_tree)
984 git_dir = xstrdup(dir);
985 else {
986 work_tree = dir;
4e2d094d 987 git_dir = mkpathdup("%s/.git", dir);
8434c2f1
DB
988 }
989
ee0e3872
JK
990 atexit(remove_junk);
991 sigchain_push_common(remove_junk_on_signal);
992
8434c2f1 993 if (!option_bare) {
8e21d63b 994 if (safe_create_leading_directories_const(work_tree) < 0)
e84d7b74 995 die_errno(_("could not create leading directories of '%s'"),
d824cbba 996 work_tree);
d45420c1
JK
997 if (dest_exists)
998 junk_work_tree_flags |= REMOVE_DIR_KEEP_TOPLEVEL;
999 else if (mkdir(work_tree, 0777))
16eff6c0 1000 die_errno(_("could not create work tree dir '%s'"),
d824cbba 1001 work_tree);
ee0e3872 1002 junk_work_tree = work_tree;
8434c2f1
DB
1003 set_git_work_tree(work_tree);
1004 }
8434c2f1 1005
d45420c1 1006 if (real_git_dir) {
dfaa209a 1007 if (real_dest_exists)
d45420c1
JK
1008 junk_git_dir_flags |= REMOVE_DIR_KEEP_TOPLEVEL;
1009 junk_git_dir = real_git_dir;
1010 } else {
1011 if (dest_exists)
1012 junk_git_dir_flags |= REMOVE_DIR_KEEP_TOPLEVEL;
1013 junk_git_dir = git_dir;
1014 }
8e21d63b 1015 if (safe_create_leading_directories_const(git_dir) < 0)
e84d7b74 1016 die(_("could not create leading directories of '%s'"), git_dir);
b57fb80a 1017
3781fcce
ÆAB
1018 if (0 <= option_verbosity) {
1019 if (option_bare)
68b939b2 1020 fprintf(stderr, _("Cloning into bare repository '%s'...\n"), dir);
3781fcce 1021 else
68b939b2 1022 fprintf(stderr, _("Cloning into '%s'...\n"), dir);
3781fcce 1023 }
31224cbd 1024
bb62e0a9
BW
1025 if (option_recurse_submodules.nr > 0) {
1026 struct string_list_item *item;
1027 struct strbuf sb = STRBUF_INIT;
48072e3d 1028 int val;
bb62e0a9
BW
1029
1030 /* remove duplicates */
1031 string_list_sort(&option_recurse_submodules);
1032 string_list_remove_duplicates(&option_recurse_submodules, 0);
1033
1034 /*
1035 * NEEDSWORK: In a multi-working-tree world, this needs to be
1036 * set in the per-worktree config.
1037 */
1038 for_each_string_list_item(item, &option_recurse_submodules) {
1039 strbuf_addf(&sb, "submodule.active=%s",
1040 item->string);
1041 string_list_append(&option_config,
1042 strbuf_detach(&sb, NULL));
1043 }
1044
48072e3d
MK
1045 if (!git_config_get_bool("submodule.stickyRecursiveClone", &val) &&
1046 val)
1047 string_list_append(&option_config, "submodule.recurse=true");
1048
31224cbd
SB
1049 if (option_required_reference.nr &&
1050 option_optional_reference.nr)
1051 die(_("clone --recursive is not compatible with "
1052 "both --reference and --reference-if-able"));
1053 else if (option_required_reference.nr) {
1054 string_list_append(&option_config,
1055 "submodule.alternateLocation=superproject");
1056 string_list_append(&option_config,
1057 "submodule.alternateErrorStrategy=die");
1058 } else if (option_optional_reference.nr) {
1059 string_list_append(&option_config,
1060 "submodule.alternateLocation=superproject");
1061 string_list_append(&option_config,
1062 "submodule.alternateErrorStrategy=info");
1063 }
1064 }
1065
32ba12da
JS
1066 init_db(git_dir, real_git_dir, option_template, GIT_HASH_UNKNOWN, NULL,
1067 INIT_DB_QUIET);
33158701 1068
27ff1fbc
ÆAB
1069 if (real_git_dir) {
1070 free((char *)git_dir);
33158701 1071 git_dir = real_git_dir;
27ff1fbc 1072 }
33158701 1073
552955ed
SB
1074 /*
1075 * additional config can be injected with -c, make sure it's included
1076 * after init_db, which clears the entire config environment.
1077 */
84054f79 1078 write_config(&option_config);
8434c2f1 1079
552955ed
SB
1080 /*
1081 * re-read config after init_db and write_config to pick up any config
1082 * injected by --template and --config, respectively.
1083 */
1084 git_config(git_clone_config, NULL);
8434c2f1 1085
4fe788b1
LL
1086 /*
1087 * If option_reject_shallow is specified from CLI option,
1088 * ignore config_reject_shallow from git_clone_config.
1089 */
1090 if (config_reject_shallow != -1)
1091 reject_shallow = config_reject_shallow;
1092 if (option_reject_shallow != -1)
1093 reject_shallow = option_reject_shallow;
1094
f05da2b4
JS
1095 /*
1096 * If option_filter_submodules is specified from CLI option,
1097 * ignore config_filter_submodules from git_clone_config.
1098 */
1099 if (config_filter_submodules != -1)
1100 filter_submodules = config_filter_submodules;
1101 if (option_filter_submodules != -1)
1102 filter_submodules = option_filter_submodules;
1103
1104 /*
1105 * Exit if the user seems to be doing something silly with submodule
1106 * filter flags (but not with filter configs, as those should be
1107 * set-and-forget).
1108 */
1109 if (option_filter_submodules > 0 && !filter_options.choice)
1110 die(_("the option '%s' requires '%s'"),
1111 "--also-filter-submodules", "--filter");
1112 if (option_filter_submodules > 0 && !option_recurse_submodules.nr)
1113 die(_("the option '%s' requires '%s'"),
1114 "--also-filter-submodules", "--recurse-submodules");
1115
de9ed3ef
SB
1116 /*
1117 * apply the remote name provided by --origin only after this second
1118 * call to git_config, to ensure it overrides all config-based values.
1119 */
538dc459 1120 if (option_origin) {
6dfadc89 1121 free(remote_name);
de9ed3ef 1122 remote_name = xstrdup(option_origin);
6dfadc89 1123 }
de9ed3ef 1124
afe8a907 1125 if (!remote_name)
de9ed3ef
SB
1126 remote_name = xstrdup("origin");
1127
1128 if (!valid_remote_name(remote_name))
1129 die(_("'%s' is not a valid remote name"), remote_name);
8434c2f1
DB
1130
1131 if (option_bare) {
bc699afc
JS
1132 if (option_mirror)
1133 src_ref_prefix = "refs/";
b5ff37ac 1134 strbuf_addstr(&branch_top, src_ref_prefix);
8434c2f1
DB
1135
1136 git_config_set("core.bare", "true");
1137 } else {
75ca3906 1138 strbuf_addf(&branch_top, "refs/remotes/%s/", remote_name);
bc699afc 1139 }
8434c2f1 1140
75ca3906 1141 strbuf_addf(&key, "remote.%s.url", remote_name);
df61c889
SR
1142 git_config_set(key.buf, repo);
1143 strbuf_reset(&key);
1144
0dab2468 1145 if (option_no_tags) {
75ca3906 1146 strbuf_addf(&key, "remote.%s.tagOpt", remote_name);
0dab2468
ÆAB
1147 git_config_set(key.buf, "--no-tags");
1148 strbuf_reset(&key);
1149 }
1150
f7415b4d 1151 if (option_required_reference.nr || option_optional_reference.nr)
dbc92b07 1152 setup_reference();
766ac6a6 1153
47dbf10d 1154 if (option_sparse_checkout && git_sparse_checkout_init(dir))
d89f09c8
DS
1155 return 1;
1156
75ca3906 1157 remote = remote_get(remote_name);
689f0396 1158
1af8b8c0
RS
1159 refspec_appendf(&remote->fetch, "+%s*:%s*", src_ref_prefix,
1160 branch_top.buf);
8434c2f1 1161
6f48d39f 1162 transport = transport_get(remote, remote->url[0]);
822f0c4f 1163 transport_set_verbosity(transport, option_verbosity, option_progress);
c915f11e 1164 transport->family = family;
822f0c4f 1165
f38aa83f
MB
1166 path = get_repo_path(remote->url[0], &is_bundle);
1167 is_local = option_local != 0 && path && !is_bundle;
1168 if (is_local) {
1169 if (option_depth)
1170 warning(_("--depth is ignored in local clones; use file:// instead."));
994c2aaf
NTND
1171 if (option_since)
1172 warning(_("--shallow-since is ignored in local clones; use file:// instead."));
859e5df9
NTND
1173 if (option_not.nr)
1174 warning(_("--shallow-exclude is ignored in local clones; use file:// instead."));
548719fb
JT
1175 if (filter_options.choice)
1176 warning(_("--filter is ignored in local clones; use file:// instead."));
f38aa83f 1177 if (!access(mkpath("%s/shallow", path), F_OK)) {
4fe788b1
LL
1178 if (reject_shallow)
1179 die(_("source repository is shallow, reject to clone."));
f38aa83f
MB
1180 if (option_local > 0)
1181 warning(_("source repository is shallow, ignoring --local"));
1182 is_local = 0;
1183 }
1184 }
1185 if (option_local > 0 && !is_local)
1186 warning(_("--local is ignored"));
beea4152 1187 transport->cloning = 1;
8434c2f1 1188
86fdd94d
DS
1189 if (is_bundle) {
1190 struct bundle_header header = BUNDLE_HEADER_INIT;
1191 int fd = read_bundle_header(path, &header);
1192 int has_filter = header.filter.choice != LOFC_DISABLED;
1193
1194 if (fd > 0)
1195 close(fd);
1196 bundle_header_release(&header);
1197 if (has_filter)
1198 die(_("cannot clone from filtered bundle"));
1199 }
1200
643f918d 1201 transport_set_option(transport, TRANS_OPT_KEEP, "yes");
8434c2f1 1202
4fe788b1
LL
1203 if (reject_shallow)
1204 transport_set_option(transport, TRANS_OPT_REJECT_SHALLOW, "1");
643f918d
JK
1205 if (option_depth)
1206 transport_set_option(transport, TRANS_OPT_DEPTH,
1207 option_depth);
994c2aaf
NTND
1208 if (option_since)
1209 transport_set_option(transport, TRANS_OPT_DEEPEN_SINCE,
1210 option_since);
859e5df9
NTND
1211 if (option_not.nr)
1212 transport_set_option(transport, TRANS_OPT_DEEPEN_NOT,
1213 (const char *)&option_not);
643f918d
JK
1214 if (option_single_branch)
1215 transport_set_option(transport, TRANS_OPT_FOLLOWTAGS, "1");
8434c2f1 1216
643f918d
JK
1217 if (option_upload_pack)
1218 transport_set_option(transport, TRANS_OPT_UPLOADPACK,
1219 option_upload_pack);
c6807a40 1220
6e983059
JT
1221 if (server_options.nr)
1222 transport->server_options = &server_options;
1223
548719fb 1224 if (filter_options.choice) {
cf9ceb5a
MD
1225 const char *spec =
1226 expand_list_objects_filter_spec(&filter_options);
548719fb 1227 transport_set_option(transport, TRANS_OPT_LIST_OBJECTS_FILTER,
cf9ceb5a 1228 spec);
548719fb
JT
1229 transport_set_option(transport, TRANS_OPT_FROM_PROMISOR, "1");
1230 }
1231
1232 if (transport->smart_options && !deepen && !filter_options.choice)
643f918d 1233 transport->smart_options->check_self_contained_and_connected = 1;
8434c2f1 1234
402c47d9 1235
39835409
JT
1236 strvec_push(&transport_ls_refs_options.ref_prefixes, "HEAD");
1237 refspec_ref_prefixes(&remote->fetch,
1238 &transport_ls_refs_options.ref_prefixes);
402c47d9 1239 if (option_branch)
39835409
JT
1240 expand_ref_prefix(&transport_ls_refs_options.ref_prefixes,
1241 option_branch);
402c47d9 1242 if (!option_no_tags)
39835409
JT
1243 strvec_push(&transport_ls_refs_options.ref_prefixes,
1244 "refs/tags/");
402c47d9 1245
39835409 1246 refs = transport_get_remote_refs(transport, &transport_ls_refs_options);
8434c2f1 1247
dccea605
JT
1248 if (refs)
1249 mapped_refs = wanted_peer_refs(refs, &remote->fetch);
1250
1251 if (mapped_refs) {
b65dc2ce 1252 int hash_algo = hash_algo_by_ptr(transport_get_hash_algo(transport));
1253
1254 /*
1255 * Now that we know what algorithm the remote side is using,
1256 * let's set ours to the same thing.
1257 */
47ac9703 1258 initialize_repository_version(hash_algo, 1);
b65dc2ce 1259 repo_set_hash_algo(the_repository, hash_algo);
5b05795c
MH
1260 /*
1261 * transport_get_remote_refs() may return refs with null sha-1
1262 * in mapped_refs (see struct transport->get_refs_list
1263 * comment). In that case we need fetch it early because
1264 * remote_head code below relies on it.
1265 *
1266 * for normal clones, transport_get_remote_refs() should
1267 * return reliable ref set, we can delay cloning until after
1268 * remote HEAD check.
1269 */
1270 for (ref = refs; ref; ref = ref->next)
f4e54d02 1271 if (is_null_oid(&ref->old_oid)) {
5b05795c
MH
1272 complete_refs_before_fetch = 0;
1273 break;
1274 }
90498161 1275
aab179d9 1276 if (!is_local && !complete_refs_before_fetch) {
6aacb7d8
JK
1277 if (transport_fetch_refs(transport, mapped_refs))
1278 die(_("remote transport reported error"));
aab179d9 1279 }
86ac7518 1280 }
6b58df54 1281
3d8314f8
JK
1282 remote_head = find_ref_by_name(refs, "HEAD");
1283 remote_head_points_at = guess_remote_head(remote_head, mapped_refs, 0);
a3552aba 1284
3d8314f8
JK
1285 if (option_branch) {
1286 our_head_points_at = find_remote_branch(mapped_refs, option_branch);
1287 if (!our_head_points_at)
1288 die(_("Remote branch %s not found in upstream %s"),
1289 option_branch, remote_name);
1290 } else if (remote_head_points_at) {
1291 our_head_points_at = remote_head_points_at;
1292 } else if (remote_head) {
7a4ee28f 1293 our_head_points_at = NULL;
3d8314f8 1294 } else {
6b58df54 1295 const char *branch;
6b58df54 1296
3d8314f8
JK
1297 if (!mapped_refs) {
1298 warning(_("You appear to have cloned an empty repository."));
1299 option_no_checkout = 1;
1300 }
0cc1b475 1301
6b58df54
JK
1302 if (transport_ls_refs_options.unborn_head_target &&
1303 skip_prefix(transport_ls_refs_options.unborn_head_target,
1304 "refs/heads/", &branch)) {
daf7898a 1305 unborn_head = xstrdup(transport_ls_refs_options.unborn_head_target);
6b58df54
JK
1306 } else {
1307 branch = git_default_branch_name(0);
daf7898a 1308 unborn_head = xstrfmt("refs/heads/%s", branch);
0cc1b475 1309 }
6b58df54 1310
cc8fcd1e
JK
1311 /*
1312 * We may have selected a local default branch name "foo",
1313 * and even though the remote's HEAD does not point there,
1314 * it may still have a "foo" branch. If so, set it up so
1315 * that we can follow the usual checkout code later.
1316 *
1317 * Note that for an empty repo we'll already have set
1318 * option_no_checkout above, which would work against us here.
1319 * But for an empty repo, find_remote_branch() can never find
1320 * a match.
1321 */
1322 our_head_points_at = find_remote_branch(mapped_refs, branch);
86ac7518 1323 }
8434c2f1 1324
31b808a0
RT
1325 write_refspec_config(src_ref_prefix, our_head_points_at,
1326 remote_head_points_at, &branch_top);
1327
548719fb 1328 if (filter_options.choice)
75ca3906 1329 partial_clone_register(remote_name, &filter_options);
548719fb 1330
6f48d39f
NTND
1331 if (is_local)
1332 clone_local(path, git_dir);
dccea605 1333 else if (mapped_refs && complete_refs_before_fetch) {
6aacb7d8
JK
1334 if (transport_fetch_refs(transport, mapped_refs))
1335 die(_("remote transport reported error"));
aab179d9 1336 }
8434c2f1 1337
960b7d1c 1338 update_remote_refs(refs, mapped_refs, remote_head_points_at,
548719fb 1339 branch_top.buf, reflog_msg.buf, transport,
2b98478c 1340 !is_local);
8434c2f1 1341
daf7898a 1342 update_head(our_head_points_at, remote_head, unborn_head, reflog_msg.buf);
1db4a75c 1343
72c5f883
JK
1344 /*
1345 * We want to show progress for recursive submodule clones iff
1346 * we did so for the main clone. But only the transport knows
1347 * the final decision for this flag, so we need to rescue the value
1348 * before we free the transport.
1349 */
1350 submodule_progress = transport->progress;
1351
58d4d7f1 1352 transport_unlock_pack(transport, 0);
6f48d39f 1353 transport_disconnect(transport);
1db4a75c 1354
786b150c 1355 if (option_dissociate) {
2d511cfc 1356 close_object_store(the_repository->objects);
fb1d6dab 1357 dissociate_from_references();
786b150c 1358 }
fb1d6dab 1359
d3b34622 1360 junk_mode = JUNK_LEAVE_REPO;
f05da2b4 1361 err = checkout(submodule_progress, filter_submodules);
8434c2f1 1362
de9ed3ef 1363 free(remote_name);
8434c2f1 1364 strbuf_release(&reflog_msg);
b5ff37ac
MV
1365 strbuf_release(&branch_top);
1366 strbuf_release(&key);
0c454273
AH
1367 free_refs(mapped_refs);
1368 free_refs(remote_head_points_at);
daf7898a 1369 free(unborn_head);
0c454273
AH
1370 free(dir);
1371 free(path);
1372 UNLEAK(repo);
d3b34622 1373 junk_mode = JUNK_LEAVE_ALL;
50b67732 1374
f36d4f83 1375 transport_ls_refs_options_release(&transport_ls_refs_options);
dfa7a6c5 1376 return err;
8434c2f1 1377}