clone.c 13.6 KB
Newer Older
1
/*
Edward Thomson committed
2
 * Copyright (C) the libgit2 contributors. All rights reserved.
3 4 5 6 7 8
 *
 * This file is part of libgit2, distributed under the GNU GPL v2 with
 * a Linking Exception. For full terms see the included COPYING file.
 */

#include <assert.h>
9

10 11
#include "git2/clone.h"
#include "git2/remote.h"
12
#include "git2/revparse.h"
13 14
#include "git2/branch.h"
#include "git2/config.h"
15
#include "git2/checkout.h"
16 17
#include "git2/commit.h"
#include "git2/tree.h"
18 19 20 21

#include "common.h"
#include "remote.h"
#include "fileops.h"
22
#include "refs.h"
23
#include "path.h"
24
#include "repository.h"
25
#include "odb.h"
26

27
static int clone_local_into(git_repository *repo, git_remote *remote, const git_fetch_options *fetch_opts, const git_checkout_options *co_opts, const char *branch, int link);
28

29
static int create_branch(
30 31 32
	git_reference **branch,
	git_repository *repo,
	const git_oid *target,
33 34
	const char *name,
	const char *log_message)
35
{
Vicent Marti committed
36
	git_commit *head_obj = NULL;
37
	git_reference *branch_ref = NULL;
38
	git_buf refname = GIT_BUF_INIT;
39
	int error;
Ben Straub committed
40 41

	/* Find the target commit */
Vicent Marti committed
42
	if ((error = git_commit_lookup(&head_obj, repo, target)) < 0)
43
		return error;
Ben Straub committed
44 45

	/* Create the new branch */
46 47
	if ((error = git_buf_printf(&refname, GIT_REFS_HEADS_DIR "%s", name)) < 0)
		return error;
Ben Straub committed
48

49 50
	error = git_reference_create(&branch_ref, repo, git_buf_cstr(&refname), target, 0, log_message);
	git_buf_free(&refname);
Vicent Marti committed
51
	git_commit_free(head_obj);
52

53
	if (!error)
54 55 56 57
		*branch = branch_ref;
	else
		git_reference_free(branch_ref);

58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97
	return error;
}

static int setup_tracking_config(
	git_repository *repo,
	const char *branch_name,
	const char *remote_name,
	const char *merge_target)
{
	git_config *cfg;
	git_buf remote_key = GIT_BUF_INIT, merge_key = GIT_BUF_INIT;
	int error = -1;

	if (git_repository_config__weakptr(&cfg, repo) < 0)
		return -1;

	if (git_buf_printf(&remote_key, "branch.%s.remote", branch_name) < 0)
		goto cleanup;

	if (git_buf_printf(&merge_key, "branch.%s.merge", branch_name) < 0)
		goto cleanup;

	if (git_config_set_string(cfg, git_buf_cstr(&remote_key), remote_name) < 0)
		goto cleanup;

	if (git_config_set_string(cfg, git_buf_cstr(&merge_key), merge_target) < 0)
		goto cleanup;

	error = 0;

cleanup:
	git_buf_free(&remote_key);
	git_buf_free(&merge_key);
	return error;
}

static int create_tracking_branch(
	git_reference **branch,
	git_repository *repo,
	const git_oid *target,
98 99
	const char *branch_name,
	const char *log_message)
100 101 102
{
	int error;

103
	if ((error = create_branch(branch, repo, target, branch_name, log_message)) < 0)
104 105 106 107 108 109 110
		return error;

	return setup_tracking_config(
		repo,
		branch_name,
		GIT_REMOTE_ORIGIN,
		git_reference_name(*branch));
111 112
}

113 114 115
static int update_head_to_new_branch(
	git_repository *repo,
	const git_oid *target,
116 117
	const char *name,
	const char *reflog_message)
118
{
Michael Schubert committed
119
	git_reference *tracking_branch = NULL;
120
	int error;
121 122 123 124

	if (!git__prefixcmp(name, GIT_REFS_HEADS_DIR))
		name += strlen(GIT_REFS_HEADS_DIR);

125
	error = create_tracking_branch(&tracking_branch, repo, target, name,
126
			reflog_message);
Ben Straub committed
127

128 129
	if (!error)
		error = git_repository_set_head(
130
			repo, git_reference_name(tracking_branch));
131 132 133

	git_reference_free(tracking_branch);

134 135 136 137
	/* if it already existed, then the user's refspec created it for us, ignore it' */
	if (error == GIT_EEXISTS)
		error = 0;

138
	return error;
139 140
}

141 142 143 144
static int update_head_to_remote(
		git_repository *repo,
		git_remote *remote,
		const char *reflog_message)
145
{
146
	int error = 0;
147
	size_t refs_len;
148
	git_refspec *refspec;
149
	const git_remote_head *remote_head, **refs;
150
	const git_oid *remote_head_id;
151
	git_buf remote_master_name = GIT_BUF_INIT;
152
	git_buf branch = GIT_BUF_INIT;
Ben Straub committed
153

154 155
	if ((error = git_remote_ls(&refs, &refs_len, remote)) < 0)
		return error;
156

157 158
	/* We cloned an empty repository or one with an unborn HEAD */
	if (refs_len == 0 || strcmp(refs[0]->name, GIT_HEAD_FILE))
159
		return setup_tracking_config(
160
			repo, "master", GIT_REMOTE_ORIGIN, GIT_REFS_HEADS_MASTER_FILE);
161

162
	/* We know we have HEAD, let's see where it points */
163
	remote_head = refs[0];
164 165
	assert(remote_head);

166
	remote_head_id = &remote_head->oid;
167 168 169 170

	error = git_remote_default_branch(&branch, remote);
	if (error == GIT_ENOTFOUND) {
		error = git_repository_set_head_detached(
171
			repo, remote_head_id);
172 173 174
		goto cleanup;
	}

175
	refspec = git_remote__matching_refspec(remote, git_buf_cstr(&branch));
176

177
	if (refspec == NULL) {
178 179 180
		giterr_set(GITERR_NET, "the remote's default branch does not fit the refspec configuration");
		error = GIT_EINVALIDSPEC;
		goto cleanup;
181
	}
182

183
	/* Determine the remote tracking reference name from the local master */
184
	if ((error = git_refspec_transform(
185
		&remote_master_name,
186
		refspec,
187
		git_buf_cstr(&branch))) < 0)
188
		goto cleanup;
189

190 191 192 193
	error = update_head_to_new_branch(
		repo,
		remote_head_id,
		git_buf_cstr(&branch),
194
		reflog_message);
Ben Straub committed
195

196
cleanup:
197
	git_buf_free(&remote_master_name);
198
	git_buf_free(&branch);
199

200
	return error;
201 202
}

203 204
static int update_head_to_branch(
		git_repository *repo,
205
		const char *remote_name,
206 207
		const char *branch,
		const char *reflog_message)
208 209 210 211
{
	int retcode;
	git_buf remote_branch_name = GIT_BUF_INIT;
	git_reference* remote_ref = NULL;
nulltoken committed
212

213
	assert(remote_name && branch);
214 215

	if ((retcode = git_buf_printf(&remote_branch_name, GIT_REFS_REMOTES_DIR "%s/%s",
216
		remote_name, branch)) < 0 )
217 218 219 220 221
		goto cleanup;

	if ((retcode = git_reference_lookup(&remote_ref, repo, git_buf_cstr(&remote_branch_name))) < 0)
		goto cleanup;

222
	retcode = update_head_to_new_branch(repo, git_reference_target(remote_ref), branch,
223
			reflog_message);
224 225 226

cleanup:
	git_reference_free(remote_ref);
Sascha Cunz committed
227
	git_buf_free(&remote_branch_name);
228 229 230
	return retcode;
}

231 232 233 234 235 236 237
static int default_repository_create(git_repository **out, const char *path, int bare, void *payload)
{
	GIT_UNUSED(payload);

	return git_repository_init(out, path, bare);
}

238 239 240 241 242 243 244
static int default_remote_create(
		git_remote **out,
		git_repository *repo,
		const char *name,
		const char *url,
		void *payload)
{
245
	GIT_UNUSED(payload);
246

247
	return git_remote_create(out, repo, name, url);
248 249
}

250 251 252 253
/*
 * submodules?
 */

254 255 256 257 258 259 260
static int create_and_configure_origin(
		git_remote **out,
		git_repository *repo,
		const char *url,
		const git_clone_options *options)
{
	int error;
Ben Straub committed
261
	git_remote *origin = NULL;
262
	char buf[GIT_PATH_MAX];
263 264
	git_remote_create_cb remote_create = options->remote_cb;
	void *payload = options->remote_cb_payload;
265 266 267 268 269 270 271 272

	/* If the path exists and is a dir, the url should be the absolute path */
	if (git_path_root(url) < 0 && git_path_exists(url) && git_path_isdir(url)) {
		if (p_realpath(url, buf) == NULL)
			return -1;

		url = buf;
	}
273

274 275
	if (!remote_create) {
		remote_create = default_remote_create;
276
		payload = NULL;
277
	}
278

279
	if ((error = remote_create(&origin, repo, "origin", url, payload)) < 0)
280 281 282 283 284 285
		goto on_error;

	*out = origin;
	return 0;

on_error:
Ben Straub committed
286
	git_remote_free(origin);
287 288
	return error;
}
289

290 291 292
static bool should_checkout(
	git_repository *repo,
	bool is_bare,
293
	const git_checkout_options *opts)
294 295 296 297 298 299 300
{
	if (is_bare)
		return false;

	if (!opts)
		return false;

301
	if (opts->checkout_strategy == GIT_CHECKOUT_NONE)
302 303
		return false;

304
	return !git_repository_head_unborn(repo);
305
}
Ben Straub committed
306

307
static int checkout_branch(git_repository *repo, git_remote *remote, const git_checkout_options *co_opts, const char *branch, const char *reflog_message)
308 309 310 311 312
{
	int error;

	if (branch)
		error = update_head_to_branch(repo, git_remote_name(remote), branch,
313
				reflog_message);
314 315
	/* Point HEAD to the same ref as the remote's head */
	else
316
		error = update_head_to_remote(repo, remote, reflog_message);
317 318 319 320 321 322 323

	if (!error && should_checkout(repo, git_repository_is_bare(repo), co_opts))
		error = git_checkout_head(repo, co_opts);

	return error;
}

324
static int clone_into(git_repository *repo, git_remote *_remote, const git_fetch_options *opts, const git_checkout_options *co_opts, const char *branch)
325
{
326
	int error;
327
	git_buf reflog_message = GIT_BUF_INIT;
328
	git_fetch_options fetch_opts;
329
	git_remote *remote;
330

331
	assert(repo && _remote);
332 333 334 335 336 337

	if (!git_repository_is_empty(repo)) {
		giterr_set(GITERR_INVALID, "the repository is not empty");
		return -1;
	}

338
	if ((error = git_remote_dup(&remote, _remote)) < 0)
339 340
		return error;

341 342
	memcpy(&fetch_opts, opts, sizeof(git_fetch_options));
	fetch_opts.update_fetchhead = 0;
343
	fetch_opts.download_tags = GIT_REMOTE_DOWNLOAD_TAGS_ALL;
344
	git_buf_printf(&reflog_message, "clone: from %s", git_remote_url(remote));
345

346
	if ((error = git_remote_fetch(remote, NULL, &fetch_opts, git_buf_cstr(&reflog_message))) != 0)
347 348
		goto cleanup;

349
	error = checkout_branch(repo, remote, co_opts, branch, git_buf_cstr(&reflog_message));
350 351

cleanup:
352
	git_remote_free(remote);
353
	git_buf_free(&reflog_message);
354 355 356 357

	return error;
}

358
int git_clone__should_clone_local(const char *url_or_path, git_clone_local_t local)
359
{
360 361 362
	git_buf fromurl = GIT_BUF_INIT;
	const char *path = url_or_path;
	bool is_url, is_local;
363 364

	if (local == GIT_CLONE_NO_LOCAL)
365
		return 0;
366

367
	if ((is_url = git_path_is_local_file_url(url_or_path)) != 0) {
368 369 370 371
		if (git_path_fromurl(&fromurl, url_or_path) < 0) {
			is_local = -1;
			goto done;
		}
372

373 374
		path = fromurl.ptr;
	}
375

376 377
	is_local = (!is_url || local != GIT_CLONE_LOCAL_AUTO) &&
		git_path_isdir(path);
378

379 380 381
done:
	git_buf_free(&fromurl);
	return is_local;
382 383
}

384
int git_clone(
385
	git_repository **out,
386 387
	const char *url,
	const char *local_path,
388
	const git_clone_options *_options)
389
{
390
	int error = 0;
Ben Straub committed
391
	git_repository *repo = NULL;
392
	git_remote *origin;
393
	git_clone_options options = GIT_CLONE_OPTIONS_INIT;
394
	uint32_t rmdir_flags = GIT_RMDIR_REMOVE_FILES;
395
	git_repository_create_cb repository_cb;
396 397

	assert(out && url && local_path);
Ben Straub committed
398

399 400 401 402
	if (_options)
		memcpy(&options, _options, sizeof(git_clone_options));

	GITERR_CHECK_VERSION(&options, GIT_CLONE_OPTIONS_VERSION, "git_clone_options");
403

404 405 406
	/* Only clone to a new directory or an empty directory */
	if (git_path_exists(local_path) && !git_path_is_empty_dir(local_path)) {
		giterr_set(GITERR_INVALID,
Russell Belfer committed
407
			"'%s' exists and is not an empty directory", local_path);
408
		return GIT_EEXISTS;
Ben Straub committed
409 410
	}

411 412 413
	/* Only remove the root directory on failure if we create it */
	if (git_path_exists(local_path))
		rmdir_flags |= GIT_RMDIR_SKIP_ROOT;
414

415 416 417 418 419 420
	if (options.repository_cb)
		repository_cb = options.repository_cb;
	else
		repository_cb = default_repository_create;

	if ((error = repository_cb(&repo, local_path, options.bare, options.repository_cb_payload)) < 0)
421
		return error;
422

423
	if (!(error = create_and_configure_origin(&origin, repo, url, &options))) {
424
		int clone_local = git_clone__should_clone_local(url, options.local);
425 426
		int link = options.local != GIT_CLONE_LOCAL_NO_LINKS;

427
		if (clone_local == 1)
428
			error = clone_local_into(
429
				repo, origin, &options.fetch_opts, &options.checkout_opts,
430
				options.checkout_branch, link);
431
		else if (clone_local == 0)
432
			error = clone_into(
433
				repo, origin, &options.fetch_opts, &options.checkout_opts,
434
				options.checkout_branch);
435 436
		else
			error = -1;
437

438 439
		git_remote_free(origin);
	}
440

441
	if (error != 0) {
442 443 444
		git_error_state last_error = {0};
		giterr_capture(&last_error, error);

445 446
		git_repository_free(repo);
		repo = NULL;
447

448
		(void)git_futils_rmdir_r(local_path, NULL, rmdir_flags);
449 450

		giterr_restore(&last_error);
451
	}
Ben Straub committed
452

453
	*out = repo;
454
	return error;
455
}
456

457
int git_clone_init_options(git_clone_options *opts, unsigned int version)
458
{
459 460 461
	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
		opts, version, git_clone_options, GIT_CLONE_OPTIONS_INIT);
	return 0;
462
}
463 464 465 466 467 468 469 470 471

static const char *repository_base(git_repository *repo)
{
	if (git_repository_is_bare(repo))
		return git_repository_path(repo);

	return git_repository_workdir(repo);
}

472 473 474
static bool can_link(const char *src, const char *dst, int link)
{
#ifdef GIT_WIN32
475 476 477
	GIT_UNUSED(src);
	GIT_UNUSED(dst);
	GIT_UNUSED(link);
478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495
	return false;
#else

	struct stat st_src, st_dst;

	if (!link)
		return false;

	if (p_stat(src, &st_src) < 0)
		return false;

	if (p_stat(dst, &st_dst) < 0)
		return false;

	return st_src.st_dev == st_dst.st_dev;
#endif
}

496
static int clone_local_into(git_repository *repo, git_remote *remote, const git_fetch_options *fetch_opts, const git_checkout_options *co_opts, const char *branch, int link)
497
{
498
	int error, flags;
499 500 501 502
	git_repository *src;
	git_buf src_odb = GIT_BUF_INIT, dst_odb = GIT_BUF_INIT, src_path = GIT_BUF_INIT;
	git_buf reflog_message = GIT_BUF_INIT;

503
	assert(repo && remote);
504 505 506 507 508 509 510 511 512 513 514

	if (!git_repository_is_empty(repo)) {
		giterr_set(GITERR_INVALID, "the repository is not empty");
		return -1;
	}

	/*
	 * Let's figure out what path we should use for the source
	 * repo, if it's not rooted, the path should be relative to
	 * the repository's worktree/gitdir.
	 */
515 516
	if ((error = git_path_from_url_or_path(&src_path, git_remote_url(remote))) < 0)
		return error;
517 518 519 520 521 522 523 524 525 526 527 528 529 530

	/* Copy .git/objects/ from the source to the target */
	if ((error = git_repository_open(&src, git_buf_cstr(&src_path))) < 0) {
		git_buf_free(&src_path);
		return error;
	}

	git_buf_joinpath(&src_odb, git_repository_path(src), GIT_OBJECTS_DIR);
	git_buf_joinpath(&dst_odb, git_repository_path(repo), GIT_OBJECTS_DIR);
	if (git_buf_oom(&src_odb) || git_buf_oom(&dst_odb)) {
		error = -1;
		goto cleanup;
	}

531 532 533 534
	flags = 0;
	if (can_link(git_repository_path(src), git_repository_path(repo), link))
		flags |= GIT_CPDIR_LINK_FILES;

535 536 537 538 539 540 541 542 543 544 545 546 547 548 549
	error = git_futils_cp_r(git_buf_cstr(&src_odb), git_buf_cstr(&dst_odb),
				flags, GIT_OBJECT_DIR_MODE);

	/*
	 * can_link() doesn't catch all variations, so if we hit an
	 * error and did want to link, let's try again without trying
	 * to link.
	 */
	if (error < 0 && link) {
		flags &= ~GIT_CPDIR_LINK_FILES;
		error = git_futils_cp_r(git_buf_cstr(&src_odb), git_buf_cstr(&dst_odb),
					flags, GIT_OBJECT_DIR_MODE);
	}

	if (error < 0)
550 551 552 553
		goto cleanup;

	git_buf_printf(&reflog_message, "clone: from %s", git_remote_url(remote));

554
	if ((error = git_remote_fetch(remote, NULL, fetch_opts, git_buf_cstr(&reflog_message))) != 0)
555 556
		goto cleanup;

557
	error = checkout_branch(repo, remote, co_opts, branch, git_buf_cstr(&reflog_message));
558 559 560 561 562 563 564 565 566

cleanup:
	git_buf_free(&reflog_message);
	git_buf_free(&src_path);
	git_buf_free(&src_odb);
	git_buf_free(&dst_odb);
	git_repository_free(src);
	return error;
}