submodule.c 55.9 KB
Newer Older
1
/*
Edward Thomson committed
2
 * Copyright (C) the libgit2 contributors. All rights reserved.
3 4 5 6 7 8 9
 *
 * 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 "common.h"
#include "git2/config.h"
10
#include "git2/sys/config.h"
11 12 13
#include "git2/types.h"
#include "git2/index.h"
#include "buffer.h"
14
#include "buf_text.h"
15 16 17 18 19
#include "vector.h"
#include "posix.h"
#include "config_file.h"
#include "config.h"
#include "repository.h"
Russell Belfer committed
20 21 22
#include "submodule.h"
#include "tree.h"
#include "iterator.h"
23 24
#include "path.h"
#include "index.h"
Russell Belfer committed
25 26

#define GIT_MODULES_FILE ".gitmodules"
27

28 29 30
static git_cvar_map _sm_update_map[] = {
	{GIT_CVAR_STRING, "checkout", GIT_SUBMODULE_UPDATE_CHECKOUT},
	{GIT_CVAR_STRING, "rebase", GIT_SUBMODULE_UPDATE_REBASE},
Russell Belfer committed
31 32
	{GIT_CVAR_STRING, "merge", GIT_SUBMODULE_UPDATE_MERGE},
	{GIT_CVAR_STRING, "none", GIT_SUBMODULE_UPDATE_NONE},
33 34
	{GIT_CVAR_FALSE, NULL, GIT_SUBMODULE_UPDATE_NONE},
	{GIT_CVAR_TRUE, NULL, GIT_SUBMODULE_UPDATE_CHECKOUT},
35 36
};

37
static git_cvar_map _sm_ignore_map[] = {
Russell Belfer committed
38
	{GIT_CVAR_STRING, "none", GIT_SUBMODULE_IGNORE_NONE},
39
	{GIT_CVAR_STRING, "untracked", GIT_SUBMODULE_IGNORE_UNTRACKED},
Russell Belfer committed
40 41
	{GIT_CVAR_STRING, "dirty", GIT_SUBMODULE_IGNORE_DIRTY},
	{GIT_CVAR_STRING, "all", GIT_SUBMODULE_IGNORE_ALL},
42 43
	{GIT_CVAR_FALSE, NULL, GIT_SUBMODULE_IGNORE_NONE},
	{GIT_CVAR_TRUE, NULL, GIT_SUBMODULE_IGNORE_ALL},
44 45
};

46 47 48 49 50 51
static git_cvar_map _sm_recurse_map[] = {
	{GIT_CVAR_STRING, "on-demand", GIT_SUBMODULE_RECURSE_ONDEMAND},
	{GIT_CVAR_FALSE, NULL, GIT_SUBMODULE_RECURSE_NO},
	{GIT_CVAR_TRUE, NULL, GIT_SUBMODULE_RECURSE_YES},
};

52 53 54 55 56 57 58 59 60 61
enum {
	CACHE_OK = 0,
	CACHE_REFRESH = 1,
	CACHE_FLUSH = 2
};
enum {
	GITMODULES_EXISTING = 0,
	GITMODULES_CREATE = 1,
};

62
static kh_inline khint_t str_hash_no_trailing_slash(const char *s)
63
{
64
	khint_t h;
65

66
	for (h = 0; *s; ++s)
67
		if (s[1] != '\0' || *s != '/')
68
			h = (h << 5) - h + *s;
69

70
	return h;
71 72
}

73
static kh_inline int str_equal_no_trailing_slash(const char *a, const char *b)
74
{
75 76
	size_t alen = a ? strlen(a) : 0;
	size_t blen = b ? strlen(b) : 0;
77

78
	if (alen > 0 && a[alen - 1] == '/')
79
		alen--;
80
	if (blen > 0 && b[blen - 1] == '/')
81 82
		blen--;

83
	return (alen == blen && strncmp(a, b, alen) == 0);
84 85
}

Russell Belfer committed
86 87
__KHASH_IMPL(
	str, static kh_inline, const char *, void *, 1,
88
	str_hash_no_trailing_slash, str_equal_no_trailing_slash)
Russell Belfer committed
89

90
static int submodule_cache_init(git_repository *repo, int refresh);
91 92
static void submodule_cache_free(git_submodule_cache *cache);

93
static git_config_backend *open_gitmodules(git_submodule_cache *, int gitmod);
94 95
static int get_url_base(git_buf *url, git_repository *repo);
static int lookup_head_remote_key(git_buf *remote_key, git_repository *repo);
96
static int submodule_get(git_submodule **, git_submodule_cache *, const char *, const char *);
97
static int submodule_load_from_config(const git_config_entry *, void *);
98
static int submodule_load_from_wd_lite(git_submodule *);
99 100
static void submodule_get_index_status(unsigned int *, git_submodule *);
static void submodule_get_wd_status(unsigned int *, git_submodule *, git_repository *, git_submodule_ignore_t);
Russell Belfer committed
101 102 103 104 105 106 107 108 109 110 111 112 113

static int submodule_cmp(const void *a, const void *b)
{
	return strcmp(((git_submodule *)a)->name, ((git_submodule *)b)->name);
}

static int submodule_config_key_trunc_puts(git_buf *key, const char *suffix)
{
	ssize_t idx = git_buf_rfind(key, '.');
	git_buf_truncate(key, (size_t)(idx + 1));
	return git_buf_puts(key, suffix);
}

114 115 116
/* lookup submodule or return ENOTFOUND if it doesn't exist */
static int submodule_lookup(
	git_submodule **out,
117
	git_submodule_cache *cache,
118 119 120 121 122 123 124
	const char *name,
	const char *alternate)
{
	khiter_t pos;

	/* lock cache */

125
	pos = git_strmap_lookup_index(cache->submodules, name);
126

127 128
	if (!git_strmap_valid_index(cache->submodules, pos) && alternate)
		pos = git_strmap_lookup_index(cache->submodules, alternate);
129

130
	if (!git_strmap_valid_index(cache->submodules, pos)) {
131 132 133 134 135
		/* unlock cache */
		return GIT_ENOTFOUND; /* don't set error - caller will cope */
	}

	if (out != NULL) {
136
		git_submodule *sm = git_strmap_value_at(cache->submodules, pos);
137 138 139 140 141 142 143 144 145
		GIT_REFCOUNT_INC(sm);
		*out = sm;
	}

	/* unlock cache */

	return 0;
}

146 147 148 149 150 151 152 153 154 155 156 157
/* clear a set of flags on all submodules */
static void submodule_cache_clear_flags(
	git_submodule_cache *cache, uint32_t mask)
{
	git_submodule *sm;
	uint32_t inverted_mask = ~mask;

	git_strmap_foreach_value(cache->submodules, sm, {
		sm->flags &= inverted_mask;
	});
}

Russell Belfer committed
158 159 160 161
/*
 * PUBLIC APIS
 */

162 163 164 165
bool git_submodule__is_submodule(git_repository *repo, const char *name)
{
	git_strmap *map;

166
	if (submodule_cache_init(repo, CACHE_OK) < 0) {
167 168 169 170
		giterr_clear();
		return false;
	}

171
	if (!repo->_submodules || !(map = repo->_submodules->submodules))
172 173 174 175 176
		return false;

	return git_strmap_valid_index(map, git_strmap_lookup_index(map, name));
}

177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195
static void submodule_set_lookup_error(int error, const char *name)
{
	if (!error)
		return;

	giterr_set(GITERR_SUBMODULE, (error == GIT_ENOTFOUND) ?
		"No submodule named '%s'" :
		"Submodule '%s' has not been added yet", name);
}

int git_submodule__lookup(
	git_submodule **out, /* NULL if user only wants to test existence */
	git_repository *repo,
	const char *name)    /* trailing slash is allowed */
{
	int error;

	assert(repo && name);

196
	if ((error = submodule_cache_init(repo, CACHE_OK)) < 0)
197 198 199 200 201 202 203 204
		return error;

	if ((error = submodule_lookup(out, repo->_submodules, name, NULL)) < 0)
		submodule_set_lookup_error(error, name);

	return error;
}

Russell Belfer committed
205
int git_submodule_lookup(
206
	git_submodule **out, /* NULL if user only wants to test existence */
Russell Belfer committed
207
	git_repository *repo,
208
	const char *name)    /* trailing slash is allowed */
Russell Belfer committed
209 210 211 212 213
{
	int error;

	assert(repo && name);

214
	if ((error = submodule_cache_init(repo, CACHE_REFRESH)) < 0)
Russell Belfer committed
215 216
		return error;

217
	if ((error = submodule_lookup(out, repo->_submodules, name, NULL)) < 0) {
Russell Belfer committed
218 219 220 221 222

		/* check if a plausible submodule exists at path */
		if (git_repository_workdir(repo)) {
			git_buf path = GIT_BUF_INIT;

223 224
			if (git_buf_join3(&path,
					'/', git_repository_workdir(repo), name, DOT_GIT) < 0)
Russell Belfer committed
225 226
				return -1;

227
			if (git_path_exists(path.ptr))
Russell Belfer committed
228 229 230 231 232
				error = GIT_EEXISTS;

			git_buf_free(&path);
		}

233
		submodule_set_lookup_error(error, name);
Russell Belfer committed
234 235
	}

236
	return error;
Russell Belfer committed
237
}
238

239 240 241 242 243
static void submodule_free_dup(void *sm)
{
	git_submodule_free(sm);
}

Russell Belfer committed
244 245 246 247 248 249
int git_submodule_foreach(
	git_repository *repo,
	int (*callback)(git_submodule *sm, const char *name, void *payload),
	void *payload)
{
	int error;
250
	size_t i;
Russell Belfer committed
251
	git_submodule *sm;
252 253
	git_submodule_cache *cache;
	git_vector snapshot = GIT_VECTOR_INIT;
Russell Belfer committed
254 255 256

	assert(repo && callback);

257
	if ((error = submodule_cache_init(repo, CACHE_REFRESH)) < 0)
Russell Belfer committed
258 259
		return error;

260 261 262 263 264 265 266 267 268 269 270 271
	cache = repo->_submodules;

	if (git_mutex_lock(&cache->lock) < 0) {
		giterr_set(GITERR_OS, "Unable to acquire lock on submodule cache");
		return -1;
	}

	if (!(error = git_vector_init(
			&snapshot, kh_size(cache->submodules), submodule_cmp))) {

		git_strmap_foreach_value(cache->submodules, sm, {
			if ((error = git_vector_insert(&snapshot, sm)) < 0)
Russell Belfer committed
272
				break;
273 274 275 276 277
			GIT_REFCOUNT_INC(sm);
		});
	}

	git_mutex_unlock(&cache->lock);
Russell Belfer committed
278

279 280 281 282 283 284
	if (error < 0)
		goto done;

	git_vector_uniq(&snapshot, submodule_free_dup);

	git_vector_foreach(&snapshot, i, sm) {
285
		if ((error = callback(sm, sm->name, payload)) != 0) {
286
			giterr_set_after_callback(error);
Russell Belfer committed
287
			break;
288
		}
289
	}
Russell Belfer committed
290

291 292 293 294
done:
	git_vector_foreach(&snapshot, i, sm)
		git_submodule_free(sm);
	git_vector_free(&snapshot);
Russell Belfer committed
295 296 297 298

	return error;
}

299
void git_submodule_cache_free(git_repository *repo)
Russell Belfer committed
300
{
301
	git_submodule_cache *cache;
Russell Belfer committed
302 303 304

	assert(repo);

305 306
	if ((cache = git__swap(repo->_submodules, NULL)) != NULL)
		submodule_cache_free(cache);
Russell Belfer committed
307 308
}

309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358
static int submodule_repo_init(
	git_repository **out,
	git_repository *parent_repo,
	const char *path,
	const char *url,
	bool use_gitlink)
{
	int error = 0;
	git_buf workdir = GIT_BUF_INIT, repodir = GIT_BUF_INIT;
	git_repository_init_options initopt = GIT_REPOSITORY_INIT_OPTIONS_INIT;
	git_repository *subrepo = NULL;

	error = git_buf_joinpath(&workdir, git_repository_workdir(parent_repo), path);
	if (error < 0)
		goto cleanup;

	initopt.flags = GIT_REPOSITORY_INIT_MKPATH | GIT_REPOSITORY_INIT_NO_REINIT;
	initopt.origin_url = url;

	/* init submodule repository and add origin remote as needed */

	/* New style: sub-repo goes in <repo-dir>/modules/<name>/ with a
	 * gitlink in the sub-repo workdir directory to that repository
	 *
	 * Old style: sub-repo goes directly into repo/<name>/.git/
	 */
	 if (use_gitlink) {
		error = git_buf_join3(
			&repodir, '/', git_repository_path(parent_repo), "modules", path);
		if (error < 0)
			goto cleanup;

		initopt.workdir_path = workdir.ptr;
		initopt.flags |=
			GIT_REPOSITORY_INIT_NO_DOTGIT_DIR |
			GIT_REPOSITORY_INIT_RELATIVE_GITLINK;

		error = git_repository_init_ext(&subrepo, repodir.ptr, &initopt);
	} else
		error = git_repository_init_ext(&subrepo, workdir.ptr, &initopt);

cleanup:
	git_buf_free(&workdir);
	git_buf_free(&repodir);

	*out = subrepo;

	return error;
}

Russell Belfer committed
359
int git_submodule_add_setup(
360
	git_submodule **out,
Russell Belfer committed
361 362 363 364 365 366
	git_repository *repo,
	const char *url,
	const char *path,
	int use_gitlink)
{
	int error = 0;
Ben Straub committed
367
	git_config_backend *mods = NULL;
368
	git_submodule *sm = NULL;
Russell Belfer committed
369 370 371 372 373 374 375
	git_buf name = GIT_BUF_INIT, real_url = GIT_BUF_INIT;
	git_repository *subrepo = NULL;

	assert(repo && url && path);

	/* see if there is already an entry for this submodule */

376
	if (git_submodule_lookup(NULL, repo, path) < 0)
Russell Belfer committed
377 378 379
		giterr_clear();
	else {
		giterr_set(GITERR_SUBMODULE,
380
			"Attempt to add submodule '%s' that already exists", path);
Russell Belfer committed
381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396
		return GIT_EEXISTS;
	}

	/* validate and normalize path */

	if (git__prefixcmp(path, git_repository_workdir(repo)) == 0)
		path += strlen(git_repository_workdir(repo));

	if (git_path_root(path) >= 0) {
		giterr_set(GITERR_SUBMODULE, "Submodule path must be a relative path");
		error = -1;
		goto cleanup;
	}

	/* update .gitmodules */

397
	if (!(mods = open_gitmodules(repo->_submodules, GITMODULES_CREATE))) {
Russell Belfer committed
398
		giterr_set(GITERR_SUBMODULE,
399
			"Adding submodules to a bare repository is not supported");
Russell Belfer committed
400 401 402 403 404 405 406 407
		return -1;
	}

	if ((error = git_buf_printf(&name, "submodule.%s.path", path)) < 0 ||
		(error = git_config_file_set_string(mods, name.ptr, path)) < 0)
		goto cleanup;

	if ((error = submodule_config_key_trunc_puts(&name, "url")) < 0 ||
408
		(error = git_config_file_set_string(mods, name.ptr, url)) < 0)
Russell Belfer committed
409 410 411 412 413 414 415 416 417 418
		goto cleanup;

	git_buf_clear(&name);

	/* init submodule repository and add origin remote as needed */

	error = git_buf_joinpath(&name, git_repository_workdir(repo), path);
	if (error < 0)
		goto cleanup;

419 420
	/* if the repo does not already exist, then init a new repo and add it.
	 * Otherwise, just add the existing repo.
Russell Belfer committed
421
	 */
422 423
	if (!(git_path_exists(name.ptr) &&
		git_path_contains(&name, DOT_GIT))) {
424 425 426 427 428 429

		/* resolve the actual URL to use */
		if ((error = git_submodule_resolve_url(&real_url, repo, url)) < 0)
			goto cleanup;

		 if ((error = submodule_repo_init(&subrepo, repo, path, real_url.ptr, use_gitlink)) < 0)
Russell Belfer committed
430 431 432 433 434
			goto cleanup;
	}

	/* add submodule to hash and "reload" it */

435 436 437 438 439 440
	if (git_mutex_lock(&repo->_submodules->lock) < 0) {
		giterr_set(GITERR_OS, "Unable to acquire lock on submodule cache");
		error = -1;
		goto cleanup;
	}

441
	if (!(error = submodule_get(&sm, repo->_submodules, path, NULL)) &&
442
		!(error = git_submodule_reload(sm, false)))
443
		error = git_submodule_init(sm, false);
Russell Belfer committed
444

445 446
	git_mutex_unlock(&repo->_submodules->lock);

Russell Belfer committed
447
cleanup:
448 449 450 451 452 453
	if (error && sm) {
		git_submodule_free(sm);
		sm = NULL;
	}
	if (out != NULL)
		*out = sm;
Russell Belfer committed
454

455
	git_config_file_free(mods);
Russell Belfer committed
456 457 458 459 460 461 462
	git_repository_free(subrepo);
	git_buf_free(&real_url);
	git_buf_free(&name);

	return error;
}

463 464 465 466 467 468 469
int git_submodule_repo_init(
	git_repository **out,
	const git_submodule *sm,
	int use_gitlink)
{
	int error;
	git_repository *sub_repo = NULL;
470 471 472
	const char *configured_url;
	git_config *cfg = NULL;
	git_buf buf = GIT_BUF_INIT;
473 474 475

	assert(out && sm);

476 477
	/* get the configured remote url of the submodule */
	if ((error = git_buf_printf(&buf, "submodule.%s.url", sm->name)) < 0 ||
478
		(error = git_repository_config_snapshot(&cfg, sm->repo)) < 0 ||
479 480 481
		(error = git_config_get_string(&configured_url, cfg, buf.ptr)) < 0 ||
		(error = submodule_repo_init(&sub_repo, sm->repo, sm->path, configured_url, use_gitlink)) < 0)
		goto done;
482 483 484

	*out = sub_repo;

485 486 487
done:
	git_config_free(cfg);
	git_buf_free(&buf);
488 489 490
	return error;
}

Russell Belfer committed
491 492 493 494 495 496 497
int git_submodule_add_finalize(git_submodule *sm)
{
	int error;
	git_index *index;

	assert(sm);

498
	if ((error = git_repository_index__weakptr(&index, sm->repo)) < 0 ||
499
		(error = git_index_add_bypath(index, GIT_MODULES_FILE)) < 0)
Russell Belfer committed
500 501
		return error;

502
	return git_submodule_add_to_index(sm, true);
Russell Belfer committed
503 504
}

505
int git_submodule_add_to_index(git_submodule *sm, int write_index)
Russell Belfer committed
506 507
{
	int error;
508
	git_repository *sm_repo = NULL;
Russell Belfer committed
509 510 511 512 513 514 515 516
	git_index *index;
	git_buf path = GIT_BUF_INIT;
	git_commit *head;
	git_index_entry entry;
	struct stat st;

	assert(sm);

517 518 519
	/* force reload of wd OID by git_submodule_open */
	sm->flags = sm->flags & ~GIT_SUBMODULE_STATUS__WD_OID_VALID;

520
	if ((error = git_repository_index__weakptr(&index, sm->repo)) < 0 ||
Russell Belfer committed
521
		(error = git_buf_joinpath(
522
			&path, git_repository_workdir(sm->repo), sm->path)) < 0 ||
Russell Belfer committed
523 524 525 526 527 528 529 530 531 532
		(error = git_submodule_open(&sm_repo, sm)) < 0)
		goto cleanup;

	/* read stat information for submodule working directory */
	if (p_stat(path.ptr, &st) < 0) {
		giterr_set(GITERR_SUBMODULE,
			"Cannot add submodule without working directory");
		error = -1;
		goto cleanup;
	}
533 534

	memset(&entry, 0, sizeof(entry));
535
	entry.path = sm->path;
536 537
	git_index_entry__init_from_stat(
		&entry, &st, !(git_index_caps(index) & GIT_INDEXCAP_NO_FILEMODE));
Russell Belfer committed
538 539 540 541 542 543 544 545

	/* calling git_submodule_open will have set sm->wd_oid if possible */
	if ((sm->flags & GIT_SUBMODULE_STATUS__WD_OID_VALID) == 0) {
		giterr_set(GITERR_SUBMODULE,
			"Cannot add submodule without HEAD to index");
		error = -1;
		goto cleanup;
	}
546
	git_oid_cpy(&entry.id, &sm->wd_oid);
Russell Belfer committed
547 548 549 550 551 552 553 554 555 556 557

	if ((error = git_commit_lookup(&head, sm_repo, &sm->wd_oid)) < 0)
		goto cleanup;

	entry.ctime.seconds = git_commit_time(head);
	entry.ctime.nanoseconds = 0;
	entry.mtime.seconds = git_commit_time(head);
	entry.mtime.nanoseconds = 0;

	git_commit_free(head);

558
	/* add it */
Edward Thomson committed
559
	error = git_index_add(index, &entry);
Russell Belfer committed
560

561 562 563 564 565 566 567 568
	/* write it, if requested */
	if (!error && write_index) {
		error = git_index_write(index);

		if (!error)
			git_oid_cpy(&sm->index_oid, &sm->wd_oid);
	}

Russell Belfer committed
569 570 571 572 573 574
cleanup:
	git_repository_free(sm_repo);
	git_buf_free(&path);
	return error;
}

575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592
const char *git_submodule_ignore_to_str(git_submodule_ignore_t ignore)
{
	int i;
	for (i = 0; i < (int)ARRAY_SIZE(_sm_ignore_map); ++i)
		if (_sm_ignore_map[i].map_value == ignore)
			return _sm_ignore_map[i].str_match;
	return NULL;
}

const char *git_submodule_update_to_str(git_submodule_update_t update)
{
	int i;
	for (i = 0; i < (int)ARRAY_SIZE(_sm_update_map); ++i)
		if (_sm_update_map[i].map_value == update)
			return _sm_update_map[i].str_match;
	return NULL;
}

593 594 595 596 597 598 599 600 601
const char *git_submodule_recurse_to_str(git_submodule_recurse_t recurse)
{
	int i;
	for (i = 0; i < (int)ARRAY_SIZE(_sm_recurse_map); ++i)
		if (_sm_recurse_map[i].map_value == recurse)
			return _sm_recurse_map[i].str_match;
	return NULL;
}

Russell Belfer committed
602 603 604
int git_submodule_save(git_submodule *submodule)
{
	int error = 0;
Ben Straub committed
605
	git_config_backend *mods;
Russell Belfer committed
606
	git_buf key = GIT_BUF_INIT;
607
	const char *val;
Russell Belfer committed
608 609 610

	assert(submodule);

611
	mods = open_gitmodules(submodule->repo->_submodules, GITMODULES_CREATE);
Russell Belfer committed
612 613
	if (!mods) {
		giterr_set(GITERR_SUBMODULE,
614
			"Adding submodules to a bare repository is not supported");
Russell Belfer committed
615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630
		return -1;
	}

	if ((error = git_buf_printf(&key, "submodule.%s.", submodule->name)) < 0)
		goto cleanup;

	/* save values for path, url, update, ignore, fetchRecurseSubmodules */

	if ((error = submodule_config_key_trunc_puts(&key, "path")) < 0 ||
		(error = git_config_file_set_string(mods, key.ptr, submodule->path)) < 0)
		goto cleanup;

	if ((error = submodule_config_key_trunc_puts(&key, "url")) < 0 ||
		(error = git_config_file_set_string(mods, key.ptr, submodule->url)) < 0)
		goto cleanup;

631 632 633 634 635 636 637 638 639 640 641
	if ((error = submodule_config_key_trunc_puts(&key, "branch")) < 0)
		goto cleanup;
	if (submodule->branch == NULL)
		error = git_config_file_delete(mods, key.ptr);
	else
		error = git_config_file_set_string(mods, key.ptr, submodule->branch);
	if (error == GIT_ENOTFOUND) {
		error = 0;
		giterr_clear();
	}
	if (error < 0)
642 643
		goto cleanup;

Russell Belfer committed
644
	if (!(error = submodule_config_key_trunc_puts(&key, "update")) &&
645
		(val = git_submodule_update_to_str(submodule->update)) != NULL)
Russell Belfer committed
646 647 648 649 650
		error = git_config_file_set_string(mods, key.ptr, val);
	if (error < 0)
		goto cleanup;

	if (!(error = submodule_config_key_trunc_puts(&key, "ignore")) &&
651
		(val = git_submodule_ignore_to_str(submodule->ignore)) != NULL)
Russell Belfer committed
652 653 654 655
		error = git_config_file_set_string(mods, key.ptr, val);
	if (error < 0)
		goto cleanup;

656 657 658 659
	if (!(error = submodule_config_key_trunc_puts(&key, "fetchRecurseSubmodules")) &&
		(val = git_submodule_recurse_to_str(submodule->fetch_recurse)) != NULL)
		error = git_config_file_set_string(mods, key.ptr, val);
	if (error < 0)
Russell Belfer committed
660 661 662 663 664 665
		goto cleanup;

	/* update internal defaults */

	submodule->ignore_default = submodule->ignore;
	submodule->update_default = submodule->update;
666
	submodule->fetch_recurse_default = submodule->fetch_recurse;
Russell Belfer committed
667 668 669
	submodule->flags |= GIT_SUBMODULE_STATUS_IN_CONFIG;

cleanup:
670
	git_config_file_free(mods);
Russell Belfer committed
671 672 673 674 675 676 677 678
	git_buf_free(&key);

	return error;
}

git_repository *git_submodule_owner(git_submodule *submodule)
{
	assert(submodule);
679
	return submodule->repo;
Russell Belfer committed
680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699
}

const char *git_submodule_name(git_submodule *submodule)
{
	assert(submodule);
	return submodule->name;
}

const char *git_submodule_path(git_submodule *submodule)
{
	assert(submodule);
	return submodule->path;
}

const char *git_submodule_url(git_submodule *submodule)
{
	assert(submodule);
	return submodule->url;
}

700 701 702 703
int git_submodule_resolve_url(git_buf *out, git_repository *repo, const char *url)
{
	int error = 0;

704 705 706
	assert(out && repo && url);

	git_buf_sanitize(out);
Carlos Martín Nieto committed
707

708
	if (git_path_is_relative(url)) {
709
		if (!(error = get_url_base(out, repo)))
710 711 712 713 714 715 716 717 718 719 720
			error = git_path_apply_relative(out, url);
	} else if (strchr(url, ':') != NULL || url[0] == '/') {
		error = git_buf_sets(out, url);
	} else {
		giterr_set(GITERR_SUBMODULE, "Invalid format for submodule URL");
		error = -1;
	}

	return error;
}

721 722 723 724 725 726
const char *git_submodule_branch(git_submodule *submodule)
{
	assert(submodule);
	return submodule->branch;
}

727 728 729 730 731 732 733 734 735 736 737 738 739 740 741
int git_submodule_set_branch(git_submodule *submodule, const char *branch)
{
	assert(submodule);

	git__free(submodule->branch);
	submodule->branch = NULL;

	if (branch != NULL) {
		submodule->branch = git__strdup(branch);
		GITERR_CHECK_ALLOC(submodule->branch);
	}

	return 0;
}

Russell Belfer committed
742 743 744 745 746 747 748 749 750 751 752 753
int git_submodule_set_url(git_submodule *submodule, const char *url)
{
	assert(submodule && url);

	git__free(submodule->url);

	submodule->url = git__strdup(url);
	GITERR_CHECK_ALLOC(submodule->url);

	return 0;
}

754
const git_oid *git_submodule_index_id(git_submodule *submodule)
Russell Belfer committed
755 756 757 758 759 760 761 762 763
{
	assert(submodule);

	if (submodule->flags & GIT_SUBMODULE_STATUS__INDEX_OID_VALID)
		return &submodule->index_oid;
	else
		return NULL;
}

764
const git_oid *git_submodule_head_id(git_submodule *submodule)
Russell Belfer committed
765 766 767 768 769 770 771 772 773
{
	assert(submodule);

	if (submodule->flags & GIT_SUBMODULE_STATUS__HEAD_OID_VALID)
		return &submodule->head_oid;
	else
		return NULL;
}

774
const git_oid *git_submodule_wd_id(git_submodule *submodule)
Russell Belfer committed
775 776 777
{
	assert(submodule);

778
	/* load unless we think we have a valid oid */
Russell Belfer committed
779 780 781 782
	if (!(submodule->flags & GIT_SUBMODULE_STATUS__WD_OID_VALID)) {
		git_repository *subrepo;

		/* calling submodule open grabs the HEAD OID if possible */
783
		if (!git_submodule_open_bare(&subrepo, submodule))
Russell Belfer committed
784
			git_repository_free(subrepo);
785 786
		else
			giterr_clear();
Russell Belfer committed
787 788 789 790 791 792 793 794 795 796 797
	}

	if (submodule->flags & GIT_SUBMODULE_STATUS__WD_OID_VALID)
		return &submodule->wd_oid;
	else
		return NULL;
}

git_submodule_ignore_t git_submodule_ignore(git_submodule *submodule)
{
	assert(submodule);
798 799
	return (submodule->ignore < GIT_SUBMODULE_IGNORE_NONE) ?
		GIT_SUBMODULE_IGNORE_NONE : submodule->ignore;
Russell Belfer committed
800 801 802 803 804 805 806 807 808
}

git_submodule_ignore_t git_submodule_set_ignore(
	git_submodule *submodule, git_submodule_ignore_t ignore)
{
	git_submodule_ignore_t old;

	assert(submodule);

809
	if (ignore == GIT_SUBMODULE_IGNORE_RESET)
Russell Belfer committed
810 811 812 813 814 815 816
		ignore = submodule->ignore_default;

	old = submodule->ignore;
	submodule->ignore = ignore;
	return old;
}

817
git_submodule_update_t git_submodule_update_strategy(git_submodule *submodule)
Russell Belfer committed
818 819
{
	assert(submodule);
820 821
	return (submodule->update < GIT_SUBMODULE_UPDATE_CHECKOUT) ?
		GIT_SUBMODULE_UPDATE_CHECKOUT : submodule->update;
Russell Belfer committed
822 823 824 825 826 827 828 829 830
}

git_submodule_update_t git_submodule_set_update(
	git_submodule *submodule, git_submodule_update_t update)
{
	git_submodule_update_t old;

	assert(submodule);

831
	if (update == GIT_SUBMODULE_UPDATE_RESET)
Russell Belfer committed
832 833 834 835 836 837 838
		update = submodule->update_default;

	old = submodule->update;
	submodule->update = update;
	return old;
}

839
git_submodule_recurse_t git_submodule_fetch_recurse_submodules(
840 841 842 843 844 845
	git_submodule *submodule)
{
	assert(submodule);
	return submodule->fetch_recurse;
}

846
git_submodule_recurse_t git_submodule_set_fetch_recurse_submodules(
847
	git_submodule *submodule,
848
	git_submodule_recurse_t fetch_recurse_submodules)
849
{
850
	git_submodule_recurse_t old;
851 852 853

	assert(submodule);

854 855 856
	if (fetch_recurse_submodules == GIT_SUBMODULE_RECURSE_RESET)
		fetch_recurse_submodules = submodule->fetch_recurse_default;

857
	old = submodule->fetch_recurse;
858
	submodule->fetch_recurse = fetch_recurse_submodules;
859 860 861
	return old;
}

862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915
static int submodule_repo_create(
	git_repository **out,
	git_repository *parent_repo,
	const char *path)
{
	int error = 0;
	git_buf workdir = GIT_BUF_INIT, repodir = GIT_BUF_INIT;
	git_repository_init_options initopt = GIT_REPOSITORY_INIT_OPTIONS_INIT;
	git_repository *subrepo = NULL;

	initopt.flags =
		GIT_REPOSITORY_INIT_MKPATH |
		GIT_REPOSITORY_INIT_NO_REINIT |
		GIT_REPOSITORY_INIT_NO_DOTGIT_DIR |
		GIT_REPOSITORY_INIT_RELATIVE_GITLINK;

	/* Workdir: path to sub-repo working directory */
	error = git_buf_joinpath(&workdir, git_repository_workdir(parent_repo), path);
	if (error < 0)
		goto cleanup;

	initopt.workdir_path = workdir.ptr;

	/**
	 * Repodir: path to the sub-repo. sub-repo goes in:
	 * <repo-dir>/modules/<name>/ with a gitlink in the 
	 * sub-repo workdir directory to that repository.
	 */
	error = git_buf_join3(
		&repodir, '/', git_repository_path(parent_repo), "modules", path);
	if (error < 0)
		goto cleanup;

	error = git_repository_init_ext(&subrepo, repodir.ptr, &initopt);

cleanup:
	git_buf_free(&workdir);
	git_buf_free(&repodir);

	*out = subrepo;

	return error;
}

/**
 * Callback to override sub-repository creation when
 * cloning a sub-repository.
 */
static int git_submodule_update_repo_init_cb(
	git_repository **out,
	const char *path,
	int bare,
	void *payload)
{
916 917
	git_submodule *sm;

918
	GIT_UNUSED(bare);
919 920

	sm = payload;
921 922 923 924

	return submodule_repo_create(out, sm->repo, path);
}

925 926 927 928 929 930 931
int git_submodule_update_init_options(git_submodule_update_options *opts, unsigned int version)
{
	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
		opts, version, git_submodule_update_options, GIT_SUBMODULE_UPDATE_OPTIONS_INIT);
	return 0;
}

932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010
int git_submodule_update(git_submodule *sm, int init, git_submodule_update_options *_update_options)
{
	int error;
	unsigned int submodule_status;
	git_config *config = NULL;
	const char *submodule_url;
	git_repository *sub_repo = NULL;
	git_remote *remote = NULL;
	git_object *target_commit = NULL;
	git_buf buf = GIT_BUF_INIT;
	git_submodule_update_options update_options = GIT_SUBMODULE_UPDATE_OPTIONS_INIT;
	git_clone_options clone_options = GIT_CLONE_OPTIONS_INIT;

	assert(sm);

	if (_update_options)
		memcpy(&update_options, _update_options, sizeof(git_submodule_update_options));

	GITERR_CHECK_VERSION(&update_options, GIT_SUBMODULE_UPDATE_OPTIONS_VERSION, "git_submodule_update_options");

	/* Copy over the remote callbacks */
	clone_options.remote_callbacks = update_options.remote_callbacks;

	/* Get the status of the submodule to determine if it is already initialized  */
	if ((error = git_submodule_status(&submodule_status, sm)) < 0)
		goto done;

	/*
	 * If submodule work dir is not already initialized, check to see
	 * what we need to do (initialize, clone, return error...)
	 */
	if (submodule_status & GIT_SUBMODULE_STATUS_WD_UNINITIALIZED) {
		/*
		 * Work dir is not initialized, check to see if the submodule
		 * info has been copied into .git/config
		 */
		if ((error = git_repository_config_snapshot(&config, sm->repo)) < 0 ||
			(error = git_buf_printf(&buf, "submodule.%s.url", git_submodule_name(sm))) < 0)
			goto done;

		if ((error = git_config_get_string(&submodule_url, config, git_buf_cstr(&buf))) < 0) {
			/*
			 * If the error is not "not found" or if it is "not found" and we are not
			 * initializing the submodule, then return error.
			 */
			if (error != GIT_ENOTFOUND)
				goto done;

			if (error == GIT_ENOTFOUND && !init) {
				giterr_set(GITERR_SUBMODULE, "Submodule is not initialized.");
				error = GIT_ERROR;
				goto done;
			}

			/* The submodule has not been initialized yet - initialize it now.*/
			if ((error = git_submodule_init(sm, 0)) < 0)
				goto done;

			git_config_free(config);
			config = NULL;

			if ((error = git_repository_config_snapshot(&config, sm->repo)) < 0 ||
				(error = git_config_get_string(&submodule_url, config, git_buf_cstr(&buf))) < 0)
				goto done;
		}

		/** submodule is initialized - now clone it **/
		/* override repo creation */
		clone_options.repository_cb = git_submodule_update_repo_init_cb;
		clone_options.repository_cb_payload = sm;

		/*
		 * Do not perform checkout as part of clone, instead we 
		 * will checkout the specific commit manually.
		 */
		clone_options.checkout_opts.checkout_strategy = GIT_CHECKOUT_NONE;
		update_options.checkout_opts.checkout_strategy = update_options.clone_checkout_strategy;

		if ((error = git_clone(&sub_repo, submodule_url, sm->path, &clone_options)) < 0 ||
1011
			(error = git_repository_set_head_detached(sub_repo, git_submodule_index_id(sm))) < 0 ||
1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022
			(error = git_checkout_head(sub_repo, &update_options.checkout_opts)) != 0)
			goto done;
	} else {
		/**
		 * Work dir is initialized - look up the commit in the parent repository's index,
		 * update the workdir contents of the subrepository, and set the subrepository's
		 * head to the new commit.
		 */
		if ((error = git_submodule_open(&sub_repo, sm)) < 0 ||
			(error = git_object_lookup(&target_commit, sub_repo, git_submodule_index_id(sm), GIT_OBJ_COMMIT)) < 0 ||
			(error = git_checkout_tree(sub_repo, target_commit, &update_options.checkout_opts)) != 0 ||
1023
			(error = git_repository_set_head_detached(sub_repo, git_submodule_index_id(sm))) < 0)
1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042
			goto done;

		/* Invalidate the wd flags as the workdir has been updated. */
		sm->flags = sm->flags &
			~(GIT_SUBMODULE_STATUS_IN_WD |
		  	GIT_SUBMODULE_STATUS__WD_OID_VALID |
		  	GIT_SUBMODULE_STATUS__WD_SCANNED);
	}

done:
	git_buf_free(&buf);
	git_config_free(config);
	git_object_free(target_commit);
	git_remote_free(remote);
	git_repository_free(sub_repo);

	return error;
}

1043
int git_submodule_init(git_submodule *sm, int overwrite)
Russell Belfer committed
1044 1045
{
	int error;
1046
	const char *val;
1047
	git_buf key = GIT_BUF_INIT, effective_submodule_url = GIT_BUF_INIT;
1048
	git_config *cfg = NULL;
Russell Belfer committed
1049

1050
	if (!sm->url) {
Russell Belfer committed
1051
		giterr_set(GITERR_SUBMODULE,
1052
			"No URL configured for submodule '%s'", sm->name);
Russell Belfer committed
1053 1054 1055
		return -1;
	}

1056
	if ((error = git_repository_config(&cfg, sm->repo)) < 0)
Russell Belfer committed
1057 1058
		return error;

1059 1060
	/* write "submodule.NAME.url" */

1061
	if ((error = git_submodule_resolve_url(&effective_submodule_url, sm->repo, sm->url)) < 0 ||
1062
		(error = git_buf_printf(&key, "submodule.%s.url", sm->name)) < 0 ||
1063
		(error = git_config__update_entry(
1064
			cfg, key.ptr, effective_submodule_url.ptr, overwrite != 0, false)) < 0)
1065 1066
		goto cleanup;

Russell Belfer committed
1067 1068
	/* write "submodule.NAME.update" if not default */

1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081
	val = (sm->update == GIT_SUBMODULE_UPDATE_CHECKOUT) ?
		NULL : git_submodule_update_to_str(sm->update);

	if ((error = git_buf_printf(&key, "submodule.%s.update", sm->name)) < 0 ||
		(error = git_config__update_entry(
			cfg, key.ptr, val, overwrite != 0, false)) < 0)
		goto cleanup;

	/* success */

cleanup:
	git_config_free(cfg);
	git_buf_free(&key);
1082
	git_buf_free(&effective_submodule_url);
Russell Belfer committed
1083 1084 1085 1086

	return error;
}

1087
int git_submodule_sync(git_submodule *sm)
Russell Belfer committed
1088
{
1089 1090 1091
	int error = 0;
	git_config *cfg = NULL;
	git_buf key = GIT_BUF_INIT;
1092
	git_repository *smrepo = NULL;
1093 1094

	if (!sm->url) {
Russell Belfer committed
1095
		giterr_set(GITERR_SUBMODULE,
1096
			"No URL configured for submodule '%s'", sm->name);
Russell Belfer committed
1097 1098 1099 1100 1101
		return -1;
	}

	/* copy URL over to config only if it already exists */

1102 1103 1104 1105 1106 1107
	if (!(error = git_repository_config__weakptr(&cfg, sm->repo)) &&
		!(error = git_buf_printf(&key, "submodule.%s.url", sm->name)))
		error = git_config__update_entry(cfg, key.ptr, sm->url, true, true);

	/* if submodule exists in the working directory, update remote url */

1108 1109 1110 1111
	if (!error &&
		(sm->flags & GIT_SUBMODULE_STATUS_IN_WD) != 0 &&
		!(error = git_submodule_open(&smrepo, sm)))
	{
1112 1113 1114 1115 1116
		git_buf remote_name = GIT_BUF_INIT;

		if ((error = git_repository_config__weakptr(&cfg, smrepo)) < 0)
			/* return error from reading submodule config */;
		else if ((error = lookup_head_remote_key(&remote_name, smrepo)) < 0) {
1117
			giterr_clear();
1118
			error = git_buf_sets(&key, "remote.origin.url");
1119 1120
		} else {
			error = git_buf_join3(
1121
				&key, '.', "remote", remote_name.ptr, "url");
1122
			git_buf_free(&remote_name);
1123 1124
		}

1125 1126
		if (!error)
			error = git_config__update_entry(cfg, key.ptr, sm->url, true, false);
1127 1128 1129 1130 1131 1132 1133

		git_repository_free(smrepo);
	}

	git_buf_free(&key);

	return error;
Russell Belfer committed
1134 1135
}

1136 1137
static int git_submodule__open(
	git_repository **subrepo, git_submodule *sm, bool bare)
Russell Belfer committed
1138 1139 1140
{
	int error;
	git_buf path = GIT_BUF_INIT;
1141 1142
	unsigned int flags = GIT_REPOSITORY_OPEN_NO_SEARCH;
	const char *wd;
Russell Belfer committed
1143

1144
	assert(sm && subrepo);
Russell Belfer committed
1145

1146 1147 1148
	if (git_repository__ensure_not_bare(
			sm->repo, "open submodule repository") < 0)
		return GIT_EBAREREPO;
Russell Belfer committed
1149

1150
	wd = git_repository_workdir(sm->repo);
Russell Belfer committed
1151

1152 1153
	if (git_buf_joinpath(&path, wd, sm->path) < 0 ||
		git_buf_joinpath(&path, path.ptr, DOT_GIT) < 0)
Russell Belfer committed
1154 1155
		return -1;

1156 1157 1158 1159
	sm->flags = sm->flags &
		~(GIT_SUBMODULE_STATUS_IN_WD |
		  GIT_SUBMODULE_STATUS__WD_OID_VALID |
		  GIT_SUBMODULE_STATUS__WD_SCANNED);
Russell Belfer committed
1160

1161 1162
	if (bare)
		flags |= GIT_REPOSITORY_OPEN_BARE;
Russell Belfer committed
1163

1164
	error = git_repository_open_ext(subrepo, path.ptr, flags, wd);
1165

1166 1167 1168 1169
	/* if we opened the submodule successfully, grab HEAD OID, etc. */
	if (!error) {
		sm->flags |= GIT_SUBMODULE_STATUS_IN_WD |
			GIT_SUBMODULE_STATUS__WD_SCANNED;
1170

1171 1172 1173 1174 1175 1176 1177 1178 1179
		if (!git_reference_name_to_id(&sm->wd_oid, *subrepo, GIT_HEAD_FILE))
			sm->flags |= GIT_SUBMODULE_STATUS__WD_OID_VALID;
		else
			giterr_clear();
	} else if (git_path_exists(path.ptr)) {
		sm->flags |= GIT_SUBMODULE_STATUS__WD_SCANNED |
			GIT_SUBMODULE_STATUS_IN_WD;
	} else {
		git_buf_rtruncate_at_char(&path, '/'); /* remove "/.git" */
1180

1181 1182 1183
		if (git_path_isdir(path.ptr))
			sm->flags |= GIT_SUBMODULE_STATUS__WD_SCANNED;
	}
1184

1185
	git_buf_free(&path);
1186

1187 1188
	return error;
}
1189

1190 1191 1192 1193
int git_submodule_open_bare(git_repository **subrepo, git_submodule *sm)
{
	return git_submodule__open(subrepo, sm, true);
}
Russell Belfer committed
1194

1195 1196 1197
int git_submodule_open(git_repository **subrepo, git_submodule *sm)
{
	return git_submodule__open(subrepo, sm, false);
Russell Belfer committed
1198 1199
}

1200
int git_submodule_reload_all(git_repository *repo, int force)
Russell Belfer committed
1201
{
1202
	return submodule_cache_init(repo, force ? CACHE_FLUSH : CACHE_REFRESH);
Russell Belfer committed
1203 1204
}

1205 1206
static void submodule_update_from_index_entry(
	git_submodule *sm, const git_index_entry *ie)
Russell Belfer committed
1207
{
1208
	bool already_found = (sm->flags & GIT_SUBMODULE_STATUS_IN_INDEX) != 0;
Russell Belfer committed
1209

1210 1211 1212 1213 1214 1215 1216
	if (!S_ISGITLINK(ie->mode)) {
		if (!already_found)
			sm->flags |= GIT_SUBMODULE_STATUS__INDEX_NOT_SUBMODULE;
	} else {
		if (already_found)
			sm->flags |= GIT_SUBMODULE_STATUS__INDEX_MULTIPLE_ENTRIES;
		else
1217
			git_oid_cpy(&sm->index_oid, &ie->id);
Russell Belfer committed
1218

1219 1220 1221 1222 1223 1224 1225 1226 1227
		sm->flags |= GIT_SUBMODULE_STATUS_IN_INDEX |
			GIT_SUBMODULE_STATUS__INDEX_OID_VALID;
	}
}

static int submodule_update_index(git_submodule *sm)
{
	git_index *index;
	const git_index_entry *ie;
Russell Belfer committed
1228

1229
	if (git_repository_index__weakptr(&index, sm->repo) < 0)
Russell Belfer committed
1230 1231
		return -1;

1232
	sm->flags = sm->flags &
1233 1234 1235
		~(GIT_SUBMODULE_STATUS_IN_INDEX |
		  GIT_SUBMODULE_STATUS__INDEX_OID_VALID);

1236 1237
	if (!(ie = git_index_get_bypath(index, sm->path, 0)))
		return 0;
Russell Belfer committed
1238

1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253
	submodule_update_from_index_entry(sm, ie);

	return 0;
}

static void submodule_update_from_head_data(
	git_submodule *sm, mode_t mode, const git_oid *id)
{
	if (!S_ISGITLINK(mode))
		sm->flags |= GIT_SUBMODULE_STATUS__HEAD_NOT_SUBMODULE;
	else {
		git_oid_cpy(&sm->head_oid, id);

		sm->flags |= GIT_SUBMODULE_STATUS_IN_HEAD |
			GIT_SUBMODULE_STATUS__HEAD_OID_VALID;
Russell Belfer committed
1254
	}
1255
}
Russell Belfer committed
1256

1257 1258 1259
static int submodule_update_head(git_submodule *submodule)
{
	git_tree *head = NULL;
nulltoken committed
1260
	git_tree_entry *te = NULL;
Russell Belfer committed
1261

1262 1263 1264
	submodule->flags = submodule->flags &
		~(GIT_SUBMODULE_STATUS_IN_HEAD |
		  GIT_SUBMODULE_STATUS__HEAD_OID_VALID);
Russell Belfer committed
1265

1266 1267 1268 1269 1270 1271
	/* if we can't look up file in current head, then done */
	if (git_repository_head_tree(&head, submodule->repo) < 0 ||
		git_tree_entry_bypath(&te, head, submodule->path) < 0)
		giterr_clear();
	else
		submodule_update_from_head_data(submodule, te->attr, &te->oid);
Russell Belfer committed
1272

nulltoken committed
1273
	git_tree_entry_free(te);
1274 1275 1276
	git_tree_free(head);
	return 0;
}
1277

1278

1279
int git_submodule_reload(git_submodule *sm, int force)
1280 1281 1282
{
	int error = 0;
	git_config_backend *mods;
1283
	git_submodule_cache *cache;
Russell Belfer committed
1284

1285 1286
	GIT_UNUSED(force);

1287 1288 1289
	assert(sm);

	cache = sm->repo->_submodules;
Russell Belfer committed
1290

1291
	/* refresh index data */
1292
	if ((error = submodule_update_index(sm)) < 0)
1293
		return error;
1294 1295

	/* refresh HEAD tree data */
1296
	if ((error = submodule_update_head(sm)) < 0)
1297
		return error;
Russell Belfer committed
1298

1299
	/* done if bare */
1300
	if (git_repository_is_bare(sm->repo))
1301 1302
		return error;

Russell Belfer committed
1303
	/* refresh config data */
1304
	mods = open_gitmodules(cache, GITMODULES_EXISTING);
1305
	if (mods != NULL) {
Russell Belfer committed
1306 1307 1308
		git_buf path = GIT_BUF_INIT;

		git_buf_sets(&path, "submodule\\.");
1309
		git_buf_text_puts_escape_regex(&path, sm->name);
Russell Belfer committed
1310 1311 1312 1313
		git_buf_puts(&path, ".*");

		if (git_buf_oom(&path))
			error = -1;
1314
		else
Russell Belfer committed
1315
			error = git_config_file_foreach_match(
1316
				mods, path.ptr, submodule_load_from_config, cache);
Russell Belfer committed
1317 1318

		git_buf_free(&path);
1319
		git_config_file_free(mods);
Russell Belfer committed
1320

1321 1322 1323
		if (error < 0)
			return error;
	}
1324 1325

	/* refresh wd data */
1326 1327 1328
	sm->flags &=
		~(GIT_SUBMODULE_STATUS_IN_WD | GIT_SUBMODULE_STATUS__WD_OID_VALID |
		  GIT_SUBMODULE_STATUS__WD_FLAGS);
1329

1330
	return submodule_load_from_wd_lite(sm);
Russell Belfer committed
1331 1332
}

1333 1334
static void submodule_copy_oid_maybe(
	git_oid *tgt, const git_oid *src, bool valid)
Russell Belfer committed
1335
{
1336 1337 1338 1339 1340 1341 1342
	if (tgt) {
		if (valid)
			memcpy(tgt, src, sizeof(*tgt));
		else
			memset(tgt, 0, sizeof(*tgt));
	}
}
1343

1344 1345 1346 1347 1348 1349 1350 1351 1352 1353
int git_submodule__status(
	unsigned int *out_status,
	git_oid *out_head_id,
	git_oid *out_index_id,
	git_oid *out_wd_id,
	git_submodule *sm,
	git_submodule_ignore_t ign)
{
	unsigned int status;
	git_repository *smrepo = NULL;
Russell Belfer committed
1354

1355
	if (ign < GIT_SUBMODULE_IGNORE_NONE)
1356
		ign = sm->ignore;
1357

1358 1359 1360 1361
	/* only return location info if ignore == all */
	if (ign == GIT_SUBMODULE_IGNORE_ALL) {
		*out_status = (sm->flags & GIT_SUBMODULE_STATUS__IN_FLAGS);
		return 0;
1362
	}
Russell Belfer committed
1363

1364 1365 1366 1367 1368 1369 1370
	/* refresh the index OID */
	if (submodule_update_index(sm) < 0)
		return -1;

	/* refresh the HEAD OID */
	if (submodule_update_head(sm) < 0)
		return -1;
Russell Belfer committed
1371

1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401
	/* for ignore == dirty, don't scan the working directory */
	if (ign == GIT_SUBMODULE_IGNORE_DIRTY) {
		/* git_submodule_open_bare will load WD OID data */
		if (git_submodule_open_bare(&smrepo, sm) < 0)
			giterr_clear();
		else
			git_repository_free(smrepo);
		smrepo = NULL;
	} else if (git_submodule_open(&smrepo, sm) < 0) {
		giterr_clear();
		smrepo = NULL;
	}

	status = GIT_SUBMODULE_STATUS__CLEAR_INTERNAL(sm->flags);

	submodule_get_index_status(&status, sm);
	submodule_get_wd_status(&status, sm, smrepo, ign);

	git_repository_free(smrepo);

	*out_status = status;

	submodule_copy_oid_maybe(out_head_id, &sm->head_oid,
		(sm->flags & GIT_SUBMODULE_STATUS__HEAD_OID_VALID) != 0);
	submodule_copy_oid_maybe(out_index_id, &sm->index_oid,
		(sm->flags & GIT_SUBMODULE_STATUS__INDEX_OID_VALID) != 0);
	submodule_copy_oid_maybe(out_wd_id, &sm->wd_oid,
		(sm->flags & GIT_SUBMODULE_STATUS__WD_OID_VALID) != 0);

	return 0;
Russell Belfer committed
1402 1403
}

1404
int git_submodule_status(unsigned int *status, git_submodule *sm)
1405
{
1406
	assert(status && sm);
1407

1408
	return git_submodule__status(status, NULL, NULL, NULL, sm, 0);
1409
}
1410

1411 1412 1413 1414 1415 1416
int git_submodule_location(unsigned int *location, git_submodule *sm)
{
	assert(location && sm);

	return git_submodule__status(
		location, NULL, NULL, NULL, sm, GIT_SUBMODULE_IGNORE_ALL);
1417 1418 1419
}


Russell Belfer committed
1420 1421 1422 1423
/*
 * INTERNAL FUNCTIONS
 */

1424 1425
static int submodule_alloc(
	git_submodule **out, git_submodule_cache *cache, const char *name)
1426
{
1427
	size_t namelen;
1428
	git_submodule *sm;
1429

1430
	if (!name || !(namelen = strlen(name))) {
1431
		giterr_set(GITERR_SUBMODULE, "Invalid submodule name");
1432
		return -1;
1433 1434
	}

1435
	sm = git__calloc(1, sizeof(git_submodule));
1436
	GITERR_CHECK_ALLOC(sm);
1437

1438 1439 1440
	sm->name = sm->path = git__strdup(name);
	if (!sm->name) {
		git__free(sm);
1441
		return -1;
1442
	}
Russell Belfer committed
1443

1444
	GIT_REFCOUNT_INC(sm);
1445 1446
	sm->ignore = sm->ignore_default = GIT_SUBMODULE_IGNORE_NONE;
	sm->update = sm->update_default = GIT_SUBMODULE_UPDATE_CHECKOUT;
1447
	sm->fetch_recurse = sm->fetch_recurse_default = GIT_SUBMODULE_RECURSE_NO;
1448
	sm->repo   = cache->repo;
1449
	sm->branch = NULL;
1450

1451 1452
	*out = sm;
	return 0;
Russell Belfer committed
1453 1454
}

1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488
static void submodule_cache_remove_item(
	git_submodule_cache *cache,
	git_submodule *item,
	bool free_after_remove)
{
	git_strmap *map;
	const char *name, *alt;

	if (!cache || !(map = cache->submodules) || !item)
		return;

	name = item->name;
	alt  = (item->path != item->name) ? item->path : NULL;

	for (; name; name = alt, alt = NULL) {
		khiter_t pos = git_strmap_lookup_index(map, name);
		git_submodule *found;

		if (!git_strmap_valid_index(map, pos))
			continue;

		found = git_strmap_value_at(map, pos);

		if (found != item)
			continue;

		git_strmap_set_value_at(map, pos, NULL);
		git_strmap_delete_at(map, pos);

		if (free_after_remove)
			git_submodule_free(found);
	}
}

1489
static void submodule_release(git_submodule *sm)
Russell Belfer committed
1490 1491 1492 1493
{
	if (!sm)
		return;

1494 1495
	if (sm->repo) {
		git_submodule_cache *cache = sm->repo->_submodules;
1496
		sm->repo = NULL;
1497
		submodule_cache_remove_item(cache, sm, false);
1498 1499
	}

1500 1501 1502 1503
	if (sm->path != sm->name)
		git__free(sm->path);
	git__free(sm->name);
	git__free(sm->url);
1504
	git__free(sm->branch);
1505 1506 1507
	git__memzero(sm, sizeof(*sm));
	git__free(sm);
}
Russell Belfer committed
1508

1509 1510 1511 1512 1513
void git_submodule_free(git_submodule *sm)
{
	if (!sm)
		return;
	GIT_REFCOUNT_DEC(sm, submodule_release);
Russell Belfer committed
1514 1515
}

1516
static int submodule_get(
1517
	git_submodule **out,
1518
	git_submodule_cache *cache,
1519 1520
	const char *name,
	const char *alternate)
Russell Belfer committed
1521
{
1522
	int error = 0;
Russell Belfer committed
1523 1524 1525
	khiter_t pos;
	git_submodule *sm;

1526
	pos = git_strmap_lookup_index(cache->submodules, name);
Russell Belfer committed
1527

1528 1529
	if (!git_strmap_valid_index(cache->submodules, pos) && alternate)
		pos = git_strmap_lookup_index(cache->submodules, alternate);
Russell Belfer committed
1530

1531 1532 1533
	if (!git_strmap_valid_index(cache->submodules, pos)) {
		if ((error = submodule_alloc(&sm, cache, name)) < 0)
			return error;
Russell Belfer committed
1534

1535 1536 1537
		/* insert value at name - if another thread beats us to it, then use
		 * their record and release our own.
		 */
1538
		pos = kh_put(str, cache->submodules, sm->name, &error);
1539

1540 1541 1542
		if (error < 0)
			goto done;
		else if (error == 0) {
1543
			git_submodule_free(sm);
1544
			sm = git_strmap_value_at(cache->submodules, pos);
1545
		} else {
1546
			error = 0;
1547
			git_strmap_set_value_at(cache->submodules, pos, sm);
1548 1549
		}
	} else {
1550
		sm = git_strmap_value_at(cache->submodules, pos);
Russell Belfer committed
1551 1552
	}

1553 1554 1555 1556 1557 1558 1559
done:
	if (error < 0)
		git_submodule_free(sm);
	else if (out) {
		GIT_REFCOUNT_INC(sm);
		*out = sm;
	}
Russell Belfer committed
1560

1561
	return error;
1562 1563
}

1564 1565 1566 1567 1568
static int submodule_config_error(const char *property, const char *value)
{
	giterr_set(GITERR_INVALID,
		"Invalid value for submodule '%s' property: '%s'", property, value);
	return -1;
1569 1570
}

1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598
int git_submodule_parse_ignore(git_submodule_ignore_t *out, const char *value)
{
	int val;

	if (git_config_lookup_map_value(
			&val, _sm_ignore_map, ARRAY_SIZE(_sm_ignore_map), value) < 0) {
		*out = GIT_SUBMODULE_IGNORE_NONE;
		return submodule_config_error("ignore", value);
	}

	*out = (git_submodule_ignore_t)val;
	return 0;
}

int git_submodule_parse_update(git_submodule_update_t *out, const char *value)
{
	int val;

	if (git_config_lookup_map_value(
			&val, _sm_update_map, ARRAY_SIZE(_sm_update_map), value) < 0) {
		*out = GIT_SUBMODULE_UPDATE_CHECKOUT;
		return submodule_config_error("update", value);
	}

	*out = (git_submodule_update_t)val;
	return 0;
}

1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612
int git_submodule_parse_recurse(git_submodule_recurse_t *out, const char *value)
{
	int val;

	if (git_config_lookup_map_value(
			&val, _sm_recurse_map, ARRAY_SIZE(_sm_recurse_map), value) < 0) {
		*out = GIT_SUBMODULE_RECURSE_YES;
		return submodule_config_error("recurse", value);
	}

	*out = (git_submodule_recurse_t)val;
	return 0;
}

Russell Belfer committed
1613
static int submodule_load_from_config(
1614
	const git_config_entry *entry, void *payload)
1615
{
1616
	git_submodule_cache *cache = payload;
1617
	const char *namestart, *property;
1618
	const char *key = entry->name, *value = entry->value, *path;
1619
	char *alternate = NULL, *replaced = NULL;
1620
	git_buf name = GIT_BUF_INIT;
1621
	git_submodule *sm = NULL;
1622
	int error = 0;
1623 1624 1625 1626 1627 1628

	if (git__prefixcmp(key, "submodule.") != 0)
		return 0;

	namestart = key + strlen("submodule.");
	property  = strrchr(namestart, '.');
1629 1630

	if (!property || (property == namestart))
1631
		return 0;
1632

1633
	property++;
1634
	path = !strcasecmp(property, "path") ? value : NULL;
1635

1636
	if ((error = git_buf_set(&name, namestart, property - namestart - 1)) < 0 ||
1637
		(error = submodule_get(&sm, cache, name.ptr, path)) < 0)
1638
		goto done;
1639

Russell Belfer committed
1640 1641
	sm->flags |= GIT_SUBMODULE_STATUS_IN_CONFIG;

1642 1643 1644
	/* Only from config might we get differing names & paths.  If so, then
	 * update the submodule and insert under the alternative key.
	 */
1645

1646 1647 1648
	/* TODO: if case insensitive filesystem, then the following strcmps
	 * should be strcasecmp
	 */
1649

1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671
	if (strcmp(sm->name, name.ptr) != 0) { /* name changed */
		if (!strcmp(sm->path, name.ptr)) { /* already set as path */
			replaced = sm->name;
			sm->name = sm->path;
		} else {
			if (sm->name != sm->path)
				replaced = sm->name;
			alternate = sm->name = git_buf_detach(&name);
		}
	}
	else if (path && strcmp(path, sm->path) != 0) { /* path changed */
		if (!strcmp(sm->name, value)) { /* already set as name */
			replaced = sm->path;
			sm->path = sm->name;
		} else {
			if (sm->path != sm->name)
				replaced = sm->path;
			if ((alternate = git__strdup(value)) == NULL) {
				error = -1;
				goto done;
			}
			sm->path = alternate;
1672
		}
1673
	}
1674

1675 1676 1677 1678 1679 1680 1681 1682
	/* Deregister under name being replaced */
	if (replaced) {
		git_strmap_delete(cache->submodules, replaced);
		git_submodule_free(sm);
		git__free(replaced);
	}

	/* Insert under alternate key */
1683 1684
	if (alternate) {
		void *old_sm = NULL;
1685
		git_strmap_insert2(cache->submodules, alternate, sm, old_sm, error);
1686

1687 1688
		if (error < 0)
			goto done;
1689 1690 1691 1692
		if (error > 0)
			error = 0;

		GIT_REFCOUNT_INC(sm); /* increase refcount for new key */
1693 1694 1695

		/* if we replaced an old module under this key, release the old one */
		if (old_sm && ((git_submodule *)old_sm) != sm) {
1696
			git_submodule_free(old_sm);
1697 1698
			/* TODO: log warning about multiple submodules with same path */
		}
1699 1700
	}

Russell Belfer committed
1701 1702 1703 1704
	/* TODO: Look up path in index and if it is present but not a GITLINK
	 * then this should be deleted (at least to match git's behavior)
	 */

1705
	if (path)
1706
		goto done;
1707 1708

	/* copy other properties into submodule entry */
Russell Belfer committed
1709
	if (strcasecmp(property, "url") == 0) {
1710 1711 1712
		git__free(sm->url);
		sm->url = NULL;

1713 1714 1715 1716
		if (value != NULL && (sm->url = git__strdup(value)) == NULL) {
			error = -1;
			goto done;
		}
1717
	}
1718 1719 1720 1721 1722 1723 1724 1725 1726
	else if (strcasecmp(property, "branch") == 0) {
		git__free(sm->branch);
		sm->branch = NULL;

		if (value != NULL && (sm->branch = git__strdup(value)) == NULL) {
			error = -1;
			goto done;
		}
	}
Russell Belfer committed
1727
	else if (strcasecmp(property, "update") == 0) {
1728 1729
		if ((error = git_submodule_parse_update(&sm->update, value)) < 0)
			goto done;
1730
		sm->update_default = sm->update;
1731
	}
Russell Belfer committed
1732
	else if (strcasecmp(property, "fetchRecurseSubmodules") == 0) {
1733 1734
		if ((error = git_submodule_parse_recurse(&sm->fetch_recurse, value)) < 0)
			goto done;
1735
		sm->fetch_recurse_default = sm->fetch_recurse;
1736
	}
Russell Belfer committed
1737
	else if (strcasecmp(property, "ignore") == 0) {
1738 1739
		if ((error = git_submodule_parse_ignore(&sm->ignore, value)) < 0)
			goto done;
1740
		sm->ignore_default = sm->ignore;
1741 1742 1743
	}
	/* ignore other unknown submodule properties */

1744
done:
1745
	git_submodule_free(sm); /* offset refcount inc from submodule_get() */
1746
	git_buf_free(&name);
1747
	return error;
1748 1749
}

1750
static int submodule_load_from_wd_lite(git_submodule *sm)
Russell Belfer committed
1751 1752 1753
{
	git_buf path = GIT_BUF_INIT;

1754
	if (git_buf_joinpath(&path, git_repository_workdir(sm->repo), sm->path) < 0)
1755
		return -1;
Russell Belfer committed
1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766

	if (git_path_isdir(path.ptr))
		sm->flags |= GIT_SUBMODULE_STATUS__WD_SCANNED;

	if (git_path_contains(&path, DOT_GIT))
		sm->flags |= GIT_SUBMODULE_STATUS_IN_WD;

	git_buf_free(&path);
	return 0;
}

1767 1768
static int submodule_cache_refresh_from_index(
	git_submodule_cache *cache, git_index *idx)
1769 1770
{
	int error;
Russell Belfer committed
1771 1772
	git_iterator *i;
	const git_index_entry *entry;
1773

1774
	if ((error = git_iterator_for_index(&i, idx, 0, NULL, NULL)) < 0)
Russell Belfer committed
1775
		return error;
1776

1777
	while (!(error = git_iterator_advance(&entry, i))) {
1778
		khiter_t pos = git_strmap_lookup_index(cache->submodules, entry->path);
1779
		git_submodule *sm;
1780

1781 1782
		if (git_strmap_valid_index(cache->submodules, pos)) {
			sm = git_strmap_value_at(cache->submodules, pos);
1783

1784 1785 1786 1787 1788
			if (S_ISGITLINK(entry->mode))
				submodule_update_from_index_entry(sm, entry);
			else
				sm->flags |= GIT_SUBMODULE_STATUS__INDEX_NOT_SUBMODULE;
		} else if (S_ISGITLINK(entry->mode)) {
1789
			if (!submodule_get(&sm, cache, entry->path, NULL)) {
1790
				submodule_update_from_index_entry(sm, entry);
1791 1792
				git_submodule_free(sm);
			}
1793
		}
1794 1795
	}

1796 1797 1798
	if (error == GIT_ITEROVER)
		error = 0;

Russell Belfer committed
1799 1800 1801 1802 1803
	git_iterator_free(i);

	return error;
}

1804 1805
static int submodule_cache_refresh_from_head(
	git_submodule_cache *cache, git_tree *head)
Russell Belfer committed
1806 1807 1808 1809 1810
{
	int error;
	git_iterator *i;
	const git_index_entry *entry;

1811
	if ((error = git_iterator_for_tree(&i, head, 0, NULL, NULL)) < 0)
Russell Belfer committed
1812 1813
		return error;

1814
	while (!(error = git_iterator_advance(&entry, i))) {
1815
		khiter_t pos = git_strmap_lookup_index(cache->submodules, entry->path);
1816
		git_submodule *sm;
Russell Belfer committed
1817

1818 1819
		if (git_strmap_valid_index(cache->submodules, pos)) {
			sm = git_strmap_value_at(cache->submodules, pos);
1820

1821
			if (S_ISGITLINK(entry->mode))
1822
				submodule_update_from_head_data(sm, entry->mode, &entry->id);
1823 1824 1825
			else
				sm->flags |= GIT_SUBMODULE_STATUS__HEAD_NOT_SUBMODULE;
		} else if (S_ISGITLINK(entry->mode)) {
1826
			if (!submodule_get(&sm, cache, entry->path, NULL)) {
1827
				submodule_update_from_head_data(
1828
					sm, entry->mode, &entry->id);
1829 1830
				git_submodule_free(sm);
			}
1831
		}
Russell Belfer committed
1832 1833
	}

1834 1835 1836
	if (error == GIT_ITEROVER)
		error = 0;

Russell Belfer committed
1837 1838 1839 1840 1841
	git_iterator_free(i);

	return error;
}

Ben Straub committed
1842
static git_config_backend *open_gitmodules(
1843
	git_submodule_cache *cache,
1844
	int okay_to_create)
Russell Belfer committed
1845
{
1846
	const char *workdir = git_repository_workdir(cache->repo);
Russell Belfer committed
1847
	git_buf path = GIT_BUF_INIT;
Ben Straub committed
1848
	git_config_backend *mods = NULL;
Russell Belfer committed
1849 1850 1851 1852 1853 1854 1855 1856

	if (workdir != NULL) {
		if (git_buf_joinpath(&path, workdir, GIT_MODULES_FILE) != 0)
			return NULL;

		if (okay_to_create || git_path_isfile(path.ptr)) {
			/* git_config_file__ondisk should only fail if OOM */
			if (git_config_file__ondisk(&mods, path.ptr) < 0)
1857
				mods = NULL;
Russell Belfer committed
1858
			/* open should only fail here if the file is malformed */
1859
			else if (git_config_file_open(mods, GIT_CONFIG_LEVEL_LOCAL) < 0) {
Russell Belfer committed
1860 1861 1862
				git_config_file_free(mods);
				mods = NULL;
			}
1863 1864 1865
		}
	}

1866 1867
	git_buf_free(&path);

Russell Belfer committed
1868 1869 1870
	return mods;
}

1871
static void submodule_cache_free(git_submodule_cache *cache)
Russell Belfer committed
1872
{
1873
	git_submodule *sm;
Russell Belfer committed
1874

1875 1876
	if (!cache)
		return;
Russell Belfer committed
1877

1878 1879 1880 1881 1882
	git_strmap_foreach_value(cache->submodules, sm, {
		sm->repo = NULL; /* disconnect from repo */
		git_submodule_free(sm);
	});
	git_strmap_free(cache->submodules);
Russell Belfer committed
1883

1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900
	git_buf_free(&cache->gitmodules_path);
	git_mutex_free(&cache->lock);
	git__free(cache);
}

static int submodule_cache_alloc(
	git_submodule_cache **out, git_repository *repo)
{
	git_submodule_cache *cache = git__calloc(1, sizeof(git_submodule_cache));
	GITERR_CHECK_ALLOC(cache);

	if (git_mutex_init(&cache->lock) < 0) {
		giterr_set(GITERR_OS, "Unable to initialize submodule cache lock");
		git__free(cache);
		return -1;
	}

1901
	if (git_strmap_alloc(&cache->submodules) < 0) {
1902 1903
		submodule_cache_free(cache);
		return -1;
1904 1905
	}

1906 1907 1908 1909 1910 1911 1912
	cache->repo = repo;
	git_buf_init(&cache->gitmodules_path, 0);

	*out = cache;
	return 0;
}

1913
static int submodule_cache_refresh(git_submodule_cache *cache, int refresh)
1914
{
1915
	int error = 0, update_index, update_head, update_gitmod;
1916 1917
	git_index *idx = NULL;
	git_tree *head = NULL;
1918
	const char *wd = NULL;
1919
	git_buf path = GIT_BUF_INIT;
1920 1921 1922
	git_submodule *sm;
	git_config_backend *mods = NULL;
	uint32_t mask;
1923

1924
	if (!cache || !cache->repo || !refresh)
1925 1926
		return 0;

1927 1928 1929 1930
	if (git_mutex_lock(&cache->lock) < 0) {
		giterr_set(GITERR_OS, "Unable to acquire lock on submodule cache");
		return -1;
	}
1931

1932
	/* get sources that we will need to check */
1933

1934 1935 1936 1937
	if (git_repository_index(&idx, cache->repo) < 0)
		giterr_clear();
	if (git_repository_head_tree(&head, cache->repo) < 0)
		giterr_clear();
Russell Belfer committed
1938

1939 1940 1941
	wd = git_repository_workdir(cache->repo);
	if (wd && (error = git_buf_joinpath(&path, wd, GIT_MODULES_FILE)) < 0)
		goto cleanup;
1942

1943
	/* check for invalidation */
1944

1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955
	if (refresh == CACHE_FLUSH)
		update_index = update_head = update_gitmod = true;
	else {
		update_index =
			!idx || git_index__changed_relative_to(idx, &cache->index_stamp);
		update_head =
			!head || !git_oid_equal(&cache->head_id, git_tree_id(head));

		update_gitmod = (wd != NULL) ?
			git_futils_filestamp_check(&cache->gitmodules_stamp, path.ptr) :
			(cache->gitmodules_stamp.mtime != 0);
1956
	}
Russell Belfer committed
1957

1958
	/* clear submodule flags that are to be refreshed */
Russell Belfer committed
1959

1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975
	mask = 0;
	if (!idx || update_index)
		mask |= GIT_SUBMODULE_STATUS_IN_INDEX |
			GIT_SUBMODULE_STATUS__INDEX_FLAGS |
			GIT_SUBMODULE_STATUS__INDEX_OID_VALID |
			GIT_SUBMODULE_STATUS__INDEX_MULTIPLE_ENTRIES;
	if (!head || update_head)
		mask |= GIT_SUBMODULE_STATUS_IN_HEAD |
			GIT_SUBMODULE_STATUS__HEAD_OID_VALID;
	if (update_gitmod)
		mask |= GIT_SUBMODULE_STATUS_IN_CONFIG;
	if (mask != 0)
		mask |= GIT_SUBMODULE_STATUS_IN_WD |
			GIT_SUBMODULE_STATUS__WD_SCANNED |
			GIT_SUBMODULE_STATUS__WD_FLAGS |
			GIT_SUBMODULE_STATUS__WD_OID_VALID;
1976 1977
	else
		goto cleanup; /* nothing to do */
1978

1979 1980 1981 1982 1983 1984 1985
	submodule_cache_clear_flags(cache, mask);

	/* add back submodule information from index */

	if (idx && update_index) {
		if ((error = submodule_cache_refresh_from_index(cache, idx)) < 0)
			goto cleanup;
1986

1987 1988
		git_futils_filestamp_set(
			&cache->index_stamp, git_index__filestamp(idx));
1989
	}
Russell Belfer committed
1990

1991
	/* add submodule information from HEAD */
Russell Belfer committed
1992

1993 1994 1995
	if (head && update_head) {
		if ((error = submodule_cache_refresh_from_head(cache, head)) < 0)
			goto cleanup;
1996

1997 1998
		git_oid_cpy(&cache->head_id, git_tree_id(head));
	}
Russell Belfer committed
1999

2000
	/* add submodule information from .gitmodules */
2001

2002 2003 2004
	if (wd && update_gitmod > 0) {
		if ((mods = open_gitmodules(cache, false)) != NULL &&
			(error = git_config_file_foreach(
2005 2006 2007 2008
				mods, submodule_load_from_config, cache)) < 0)
			goto cleanup;
	}

2009
	/* shallow scan submodules in work tree as needed */
2010

2011
	if (wd && mask != 0) {
2012
		git_strmap_foreach_value(cache->submodules, sm, {
2013 2014 2015
			submodule_load_from_wd_lite(sm);
		});
	}
2016

2017 2018 2019
	/* remove submodules that no longer exist */

	git_strmap_foreach_value(cache->submodules, sm, {
2020 2021 2022 2023 2024 2025
		/* purge unless in HEAD, index, or .gitmodules; no sm for wd only */
		if (sm != NULL &&
			!(sm->flags &
			 (GIT_SUBMODULE_STATUS_IN_HEAD |
			  GIT_SUBMODULE_STATUS_IN_INDEX |
			  GIT_SUBMODULE_STATUS_IN_CONFIG)))
2026 2027 2028
			submodule_cache_remove_item(cache, sm, true);
	});

2029
cleanup:
2030
	git_config_file_free(mods);
Russell Belfer committed
2031

2032 2033
	/* TODO: if we got an error, mark submodule config as invalid? */

2034 2035 2036 2037 2038 2039
	git_mutex_unlock(&cache->lock);

	git_index_free(idx);
	git_tree_free(head);
	git_buf_free(&path);

2040 2041 2042
	return error;
}

2043
static int submodule_cache_init(git_repository *repo, int cache_refresh)
2044 2045 2046 2047 2048 2049
{
	int error = 0;
	git_submodule_cache *cache = NULL;

	/* if submodules already exist, just refresh as requested */
	if (repo->_submodules)
2050
		return submodule_cache_refresh(repo->_submodules, cache_refresh);
2051 2052 2053

	/* otherwise create a new cache, load it, and atomically swap it in */
	if (!(error = submodule_cache_alloc(&cache, repo)) &&
2054
		!(error = submodule_cache_refresh(cache, CACHE_FLUSH)))
2055 2056 2057 2058 2059
		cache = git__compare_and_swap(&repo->_submodules, NULL, cache);

	/* might have raced with another thread to set cache, so free if needed */
	if (cache)
		submodule_cache_free(cache);
Russell Belfer committed
2060

2061 2062 2063
	return error;
}

Russell Belfer committed
2064 2065
/* Lookup name of remote of the local tracking branch HEAD points to */
static int lookup_head_remote_key(git_buf *remote_name, git_repository *repo)
2066
{
Russell Belfer committed
2067
	int error;
Russell Belfer committed
2068 2069 2070 2071 2072 2073 2074
	git_reference *head = NULL;
	git_buf upstream_name = GIT_BUF_INIT;

	/* lookup and dereference HEAD */
	if ((error = git_repository_head(&head, repo)) < 0)
		return error;

2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086
	/**
	 * If head does not refer to a branch, then return
	 * GIT_ENOTFOUND to indicate that we could not find
	 * a remote key for the local tracking branch HEAD points to.
	 **/
	if (!git_reference_is_branch(head)) {
		giterr_set(GITERR_INVALID,
			"HEAD does not refer to a branch.");
		error = GIT_ENOTFOUND;
		goto done;
	}

Russell Belfer committed
2087
	/* lookup remote tracking branch of HEAD */
2088 2089 2090 2091 2092
	if ((error = git_branch_upstream_name(
		&upstream_name,
		repo,
		git_reference_name(head))) < 0)
		goto done;
Russell Belfer committed
2093

2094 2095 2096
	/* lookup remote of remote tracking branch */
	if ((error = git_branch_remote_name(remote_name, repo, upstream_name.ptr)) < 0)
		goto done;
Russell Belfer committed
2097

2098 2099
done:
	git_buf_free(&upstream_name);
Russell Belfer committed
2100
	git_reference_free(head);
2101

2102 2103
	return error;
}
2104

Russell Belfer committed
2105 2106
/* Lookup the remote of the local tracking branch HEAD points to */
static int lookup_head_remote(git_remote **remote, git_repository *repo)
2107 2108
{
	int error;
Russell Belfer committed
2109
	git_buf remote_name = GIT_BUF_INIT;
2110

Russell Belfer committed
2111 2112
	/* lookup remote of remote tracking branch name */
	if (!(error = lookup_head_remote_key(&remote_name, repo)))
2113
		error = git_remote_lookup(remote, repo, remote_name.ptr);
2114

Russell Belfer committed
2115
	git_buf_free(&remote_name);
Russell Belfer committed
2116

2117 2118
	return error;
}
Russell Belfer committed
2119

Russell Belfer committed
2120 2121
/* Lookup remote, either from HEAD or fall back on origin */
static int lookup_default_remote(git_remote **remote, git_repository *repo)
2122
{
Russell Belfer committed
2123
	int error = lookup_head_remote(remote, repo);
Russell Belfer committed
2124

Russell Belfer committed
2125 2126
	/* if that failed, use 'origin' instead */
	if (error == GIT_ENOTFOUND)
2127
		error = git_remote_lookup(remote, repo, "origin");
Russell Belfer committed
2128

Russell Belfer committed
2129 2130 2131 2132 2133
	if (error == GIT_ENOTFOUND)
		giterr_set(
			GITERR_SUBMODULE,
			"Cannot get default remote for submodule - no local tracking "
			"branch for HEAD and origin does not exist");
Russell Belfer committed
2134 2135

	return error;
2136 2137
}

Russell Belfer committed
2138
static int get_url_base(git_buf *url, git_repository *repo)
2139 2140
{
	int error;
Russell Belfer committed
2141
	git_remote *remote = NULL;
2142

Russell Belfer committed
2143 2144 2145 2146 2147 2148 2149 2150 2151
	if (!(error = lookup_default_remote(&remote, repo))) {
		error = git_buf_sets(url, git_remote_url(remote));
		git_remote_free(remote);
	}
	else if (error == GIT_ENOTFOUND) {
		/* if repository does not have a default remote, use workdir instead */
		giterr_clear();
		error = git_buf_sets(url, git_repository_workdir(repo));
	}
2152 2153 2154 2155

	return error;
}

2156
static void submodule_get_index_status(unsigned int *status, git_submodule *sm)
Russell Belfer committed
2157
{
2158 2159
	const git_oid *head_oid  = git_submodule_head_id(sm);
	const git_oid *index_oid = git_submodule_index_id(sm);
Russell Belfer committed
2160

2161 2162
	*status = *status & ~GIT_SUBMODULE_STATUS__INDEX_FLAGS;

2163 2164 2165 2166 2167 2168 2169 2170
	if (!head_oid) {
		if (index_oid)
			*status |= GIT_SUBMODULE_STATUS_INDEX_ADDED;
	}
	else if (!index_oid)
		*status |= GIT_SUBMODULE_STATUS_INDEX_DELETED;
	else if (!git_oid_equal(head_oid, index_oid))
		*status |= GIT_SUBMODULE_STATUS_INDEX_MODIFIED;
Russell Belfer committed
2171 2172
}

2173

2174 2175 2176 2177 2178
static void submodule_get_wd_status(
	unsigned int *status,
	git_submodule *sm,
	git_repository *sm_repo,
	git_submodule_ignore_t ign)
2179
{
2180 2181 2182 2183
	const git_oid *index_oid = git_submodule_index_id(sm);
	const git_oid *wd_oid =
		(sm->flags & GIT_SUBMODULE_STATUS__WD_OID_VALID) ? &sm->wd_oid : NULL;
	git_tree *sm_head = NULL;
2184
	git_index *index = NULL;
2185
	git_diff_options opt = GIT_DIFF_OPTIONS_INIT;
2186
	git_diff *diff;
2187

2188
	*status = *status & ~GIT_SUBMODULE_STATUS__WD_FLAGS;
Russell Belfer committed
2189

2190 2191 2192
	if (!index_oid) {
		if (wd_oid)
			*status |= GIT_SUBMODULE_STATUS_WD_ADDED;
Russell Belfer committed
2193
	}
2194 2195 2196 2197 2198 2199
	else if (!wd_oid) {
		if ((sm->flags & GIT_SUBMODULE_STATUS__WD_SCANNED) != 0 &&
			(sm->flags & GIT_SUBMODULE_STATUS_IN_WD) == 0)
			*status |= GIT_SUBMODULE_STATUS_WD_UNINITIALIZED;
		else
			*status |= GIT_SUBMODULE_STATUS_WD_DELETED;
Russell Belfer committed
2200
	}
2201 2202
	else if (!git_oid_equal(index_oid, wd_oid))
		*status |= GIT_SUBMODULE_STATUS_WD_MODIFIED;
Russell Belfer committed
2203

2204 2205 2206
	/* if we have no repo, then we're done */
	if (!sm_repo)
		return;
2207

2208 2209 2210 2211
	/* the diffs below could be optimized with an early termination
	 * option to the git_diff functions, but for now this is sufficient
	 * (and certainly no worse that what core git does).
	 */
2212

2213 2214
	if (ign == GIT_SUBMODULE_IGNORE_NONE)
		opt.flags |= GIT_DIFF_INCLUDE_UNTRACKED;
Russell Belfer committed
2215

2216 2217
	(void)git_repository_index__weakptr(&index, sm_repo);

2218
	/* if we don't have an unborn head, check diff with index */
2219 2220 2221 2222
	if (git_repository_head_tree(&sm_head, sm_repo) < 0)
		giterr_clear();
	else {
		/* perform head to index diff on submodule */
2223
		if (git_diff_tree_to_index(&diff, sm_repo, sm_head, index, &opt) < 0)
2224 2225
			giterr_clear();
		else {
2226
			if (git_diff_num_deltas(diff) > 0)
2227
				*status |= GIT_SUBMODULE_STATUS_WD_INDEX_MODIFIED;
2228
			git_diff_free(diff);
2229 2230
			diff = NULL;
		}
Russell Belfer committed
2231

2232
		git_tree_free(sm_head);
2233
	}
2234

2235
	/* perform index-to-workdir diff on submodule */
2236
	if (git_diff_index_to_workdir(&diff, sm_repo, index, &opt) < 0)
2237 2238 2239 2240
		giterr_clear();
	else {
		size_t untracked =
			git_diff_num_deltas_of_type(diff, GIT_DELTA_UNTRACKED);
2241

2242 2243
		if (untracked > 0)
			*status |= GIT_SUBMODULE_STATUS_WD_UNTRACKED;
2244

2245 2246
		if (git_diff_num_deltas(diff) != untracked)
			*status |= GIT_SUBMODULE_STATUS_WD_WD_MODIFIED;
Russell Belfer committed
2247

2248
		git_diff_free(diff);
2249
		diff = NULL;
2250
	}
2251
}