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

8 9
#include "submodule.h"

10
#include "git2/config.h"
11
#include "git2/sys/config.h"
12 13 14
#include "git2/types.h"
#include "git2/index.h"
#include "buffer.h"
15
#include "buf_text.h"
16 17
#include "vector.h"
#include "posix.h"
18
#include "config_backend.h"
19 20
#include "config.h"
#include "repository.h"
Russell Belfer committed
21 22
#include "tree.h"
#include "iterator.h"
23 24
#include "path.h"
#include "index.h"
25
#include "worktree.h"
Russell Belfer committed
26 27

#define GIT_MODULES_FILE ".gitmodules"
28

29 30 31
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
32 33
	{GIT_CVAR_STRING, "merge", GIT_SUBMODULE_UPDATE_MERGE},
	{GIT_CVAR_STRING, "none", GIT_SUBMODULE_UPDATE_NONE},
34 35
	{GIT_CVAR_FALSE, NULL, GIT_SUBMODULE_UPDATE_NONE},
	{GIT_CVAR_TRUE, NULL, GIT_SUBMODULE_UPDATE_CHECKOUT},
36 37
};

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

47 48 49 50 51 52
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},
};

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

63 64
static int submodule_alloc(git_submodule **out, git_repository *repo, const char *name);
static git_config_backend *open_gitmodules(git_repository *repo, int gitmod);
65
static int gitmodules_snapshot(git_config **snap, git_repository *repo);
66 67
static int get_url_base(git_buf *url, git_repository *repo);
static int lookup_head_remote_key(git_buf *remote_key, git_repository *repo);
68
static int lookup_default_remote(git_remote **remote, git_repository *repo);
69 70
static int submodule_load_each(const git_config_entry *entry, void *payload);
static int submodule_read_config(git_submodule *sm, git_config *cfg);
71
static int submodule_load_from_wd_lite(git_submodule *);
72 73
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);
74 75
static void submodule_update_from_index_entry(git_submodule *sm, const git_index_entry *ie);
static void submodule_update_from_head_data(git_submodule *sm, mode_t mode, const git_oid *id);
Russell Belfer committed
76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92

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);
}

/*
 * PUBLIC APIS
 */

93 94 95 96 97 98
static void submodule_set_lookup_error(int error, const char *name)
{
	if (!error)
		return;

	giterr_set(GITERR_SUBMODULE, (error == GIT_ENOTFOUND) ?
99 100
		"no submodule named '%s'" :
		"submodule '%s' has not been added yet", name);
101 102
}

103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122
typedef struct {
	const char *path;
	char *name;
} fbp_data;

static int find_by_path(const git_config_entry *entry, void *payload)
{
	fbp_data *data = payload;

	if (!strcmp(entry->value, data->path)) {
		const char *fdot, *ldot;
		fdot = strchr(entry->name, '.');
		ldot = strrchr(entry->name, '.');
		data->name = git__strndup(fdot + 1, ldot - fdot - 1);
		GITERR_CHECK_ALLOC(data->name);
	}

	return 0;
}

123 124 125 126
/*
 * Checks to see if the submodule shares its name with a file or directory that
 * already exists on the index. If so, the submodule cannot be added.
 */
127
static int is_path_occupied(bool *occupied, git_repository *repo, const char *path)
128 129
{
	int error = 0;
130 131
	git_index *index;
	git_buf dir = GIT_BUF_INIT;
132
	*occupied = false;
133 134

	if ((error = git_repository_index__weakptr(&index, repo)) < 0)
135
		goto out;
136

137 138 139 140 141 142
	if ((error = git_index_find(NULL, index, path)) != GIT_ENOTFOUND) {
		if (!error) {
			giterr_set(GITERR_SUBMODULE,
				"File '%s' already exists in the index", path);
			*occupied = true;
		}
143
		goto out;
144 145
	}

146 147 148 149 150
	if ((error = git_buf_sets(&dir, path)) < 0)
		goto out;

	if ((error = git_path_to_dir(&dir)) < 0)
		goto out;
151

152 153 154 155 156 157 158
	if ((error = git_index_find_prefix(NULL, index, dir.ptr)) != GIT_ENOTFOUND) {
		if (!error) {
			giterr_set(GITERR_SUBMODULE,
				"Directory '%s' already exists in the index", path);
			*occupied = true;
		}
		goto out;
159
	}
160

161
	error = 0;
162

163
out:
164
	git_buf_dispose(&dir);
165
	return error;
166 167
}

168
/**
169
 * Release the name map returned by 'load_submodule_names'.
170
 */
171 172
static void free_submodule_names(git_strmap *names)
{
173 174
	const char *key;
	char *value;
175

176 177
	if (names == NULL)
		return;
178

179 180 181
	git_strmap_foreach(names, key, value, {
		git__free((char *) key);
		git__free(value);
182 183
	});
	git_strmap_free(names);
184

185 186 187 188 189 190 191 192
	return;
}

/**
 * Map submodule paths to names.
 * TODO: for some use-cases, this might need case-folding on a
 * case-insensitive filesystem
 */
193
static int load_submodule_names(git_strmap **out, git_repository *repo, git_config *cfg)
194 195
{
	const char *key = "submodule\\..*\\.path";
196
	git_config_iterator *iter = NULL;
197
	git_config_entry *entry;
198
	git_buf buf = GIT_BUF_INIT;
199
	git_strmap *names;
200
	int rval, isvalid;
201
	int error = 0;
202

203 204 205 206 207
	*out = NULL;

	if ((error = git_strmap_alloc(&names)) < 0)
		goto out;

208
	if ((error = git_config_iterator_glob_new(&iter, cfg, key)) < 0)
209
		goto out;
210

211
	while (git_config_next(&entry, iter) == 0) {
212 213 214 215
		const char *fdot, *ldot;
		fdot = strchr(entry->name, '.');
		ldot = strrchr(entry->name, '.');

216
		if (git_strmap_exists(names, entry->value)) {
217 218 219 220 221 222
			giterr_set(GITERR_SUBMODULE,
				   "duplicated submodule path '%s'", entry->value);
			error = -1;
			goto out;
		}

223
		git_buf_clear(&buf);
224
		git_buf_put(&buf, fdot + 1, ldot - fdot - 1);
225
		isvalid = git_submodule_name_is_valid(repo, buf.ptr, 0);
226 227 228 229
		if (isvalid < 0) {
			error = isvalid;
			goto out;
		}
230
		if (!isvalid)
231 232
			continue;

233
		git_strmap_insert(names, git__strdup(entry->value), git_buf_detach(&buf), &rval);
234
		if (rval < 0) {
235
			giterr_set(GITERR_NOMEMORY, "error inserting submodule into hash table");
236 237
			error = -1;
			goto out;
238
		}
239
	}
240 241
	if (error == GIT_ITEROVER)
		error = 0;
242

243 244 245
	*out = names;
	names = NULL;

246
out:
247
	free_submodule_names(names);
248
	git_buf_dispose(&buf);
249
	git_config_iterator_free(iter);
250
	return error;
251 252
}

253
int git_submodule_lookup(
254 255 256 257 258
	git_submodule **out, /* NULL if user only wants to test existence */
	git_repository *repo,
	const char *name)    /* trailing slash is allowed */
{
	int error;
259
	unsigned int location;
260
	git_submodule *sm;
261 262 263

	assert(repo && name);

264 265 266 267 268
	if (repo->is_bare) {
		giterr_set(GITERR_SUBMODULE, "cannot get submodules without a working tree");
		return -1;
	}

269
	if (repo->submodule_cache != NULL) {
270
		size_t pos = git_strmap_lookup_index(repo->submodule_cache, name);
271 272 273 274 275 276 277 278 279
		if (git_strmap_valid_index(repo->submodule_cache, pos)) {
			if (out) {
				*out = git_strmap_value_at(repo->submodule_cache, pos);
				GIT_REFCOUNT_INC(*out);
			}
			return 0;
		}
	}

280 281
	if ((error = submodule_alloc(&sm, repo, name)) < 0)
		return error;
Russell Belfer committed
282

283 284
	if ((error = git_submodule_reload(sm, false)) < 0) {
		git_submodule_free(sm);
Russell Belfer committed
285
		return error;
286
	}
Russell Belfer committed
287

288 289 290 291 292
	if ((error = git_submodule_location(&location, sm)) < 0) {
		git_submodule_free(sm);
		return error;
	}

293
	/* If it's not configured or we're looking by path  */
294 295
	if (location == 0 || location == GIT_SUBMODULE_STATUS_IN_WD) {
		git_config_backend *mods;
296
		const char *pattern = "submodule\\..*\\.path";
297 298 299 300 301 302 303 304
		git_buf path = GIT_BUF_INIT;
		fbp_data data = { NULL, NULL };

		git_buf_puts(&path, name);
		while (path.ptr[path.size-1] == '/') {
			path.ptr[--path.size] = '\0';
		}
		data.path = path.ptr;
305

306 307 308
		mods = open_gitmodules(repo, GITMODULES_EXISTING);

		if (mods)
309
			error = git_config_backend_foreach_match(mods, pattern, find_by_path, &data);
310

311
		git_config_backend_free(mods);
312 313 314

		if (error < 0) {
			git_submodule_free(sm);
315
			git_buf_dispose(&path);
316
			return error;
317
		}
318 319 320 321

		if (data.name) {
			git__free(sm->name);
			sm->name = data.name;
322
			sm->path = git_buf_detach(&path);
323 324 325 326 327 328 329

			/* Try to load again with the right name */
			if ((error = git_submodule_reload(sm, false)) < 0) {
				git_submodule_free(sm);
				return error;
			}
		}
330

331
		git_buf_dispose(&path);
332 333
	}

334 335 336 337 338 339 340
	if ((error = git_submodule_location(&location, sm)) < 0) {
		git_submodule_free(sm);
		return error;
	}

	/* If we still haven't found it, do the WD check */
	if (location == 0 || location == GIT_SUBMODULE_STATUS_IN_WD) {
341 342
		git_submodule_free(sm);
		error = GIT_ENOTFOUND;
Russell Belfer committed
343

344
		/* If it's not configured, we still check if there's a repo at the path */
Russell Belfer committed
345 346
		if (git_repository_workdir(repo)) {
			git_buf path = GIT_BUF_INIT;
347
			if (git_buf_join3(&path,
348
					  '/', git_repository_workdir(repo), name, DOT_GIT) < 0)
Russell Belfer committed
349 350
				return -1;

351
			if (git_path_exists(path.ptr))
Russell Belfer committed
352 353
				error = GIT_EEXISTS;

354
			git_buf_dispose(&path);
Russell Belfer committed
355 356
		}

357
		submodule_set_lookup_error(error, name);
358
		return error;
Russell Belfer committed
359 360
	}

361 362 363 364 365 366
	if (out)
		*out = sm;
	else
		git_submodule_free(sm);

	return 0;
Russell Belfer committed
367
}
368

369
int git_submodule_name_is_valid(git_repository *repo, const char *name, int flags)
370
{
371 372 373
	git_buf buf = GIT_BUF_INIT;
	int error, isvalid;

374 375 376
	if (flags == 0)
		flags = GIT_PATH_REJECT_FILESYSTEM_DEFAULTS;

377
	/* Avoid allocating a new string if we can avoid it */
378
	if (strchr(name, '\\') != NULL) {
379 380 381 382 383 384
		if ((error = git_path_normalize_slashes(&buf, name)) < 0)
			return error;
	} else {
		git_buf_attach_notowned(&buf, name, strlen(name));
	}

385
	isvalid =  git_path_isvalid(repo, buf.ptr, 0, flags);
386
	git_buf_dispose(&buf);
387 388

	return isvalid;
389 390
}

391 392 393 394 395
static void submodule_free_dup(void *sm)
{
	git_submodule_free(sm);
}

396 397 398
static int submodule_get_or_create(git_submodule **out, git_repository *repo, git_strmap *map, const char *name)
{
	int error = 0;
399
	size_t pos;
400 401 402 403 404 405 406 407 408 409 410 411
	git_submodule *sm = NULL;

	pos = git_strmap_lookup_index(map, name);
	if (git_strmap_valid_index(map, pos)) {
		sm = git_strmap_value_at(map, pos);
		goto done;
	}

	/* if the submodule doesn't exist yet in the map, create it */
	if ((error = submodule_alloc(&sm, repo, name)) < 0)
		return error;

412
	pos = git_strmap_put(map, sm->name, &error);
413 414 415 416 417 418 419 420 421 422 423 424 425 426 427
	/* nobody can beat us to adding it */
	assert(error != 0);
	if (error < 0) {
		git_submodule_free(sm);
		return error;
	}

	git_strmap_set_value_at(map, pos, sm);

done:
	GIT_REFCOUNT_INC(sm);
	*out = sm;
	return 0;
}

428
static int submodules_from_index(git_strmap *map, git_index *idx, git_config *cfg)
429
{
David Turner committed
430
	int error;
431
	git_iterator *i = NULL;
David Turner committed
432
	const git_index_entry *entry;
433
	git_strmap *names;
434

435
	if ((error = load_submodule_names(&names, git_index_owner(idx), cfg)))
436
		goto done;
437

David Turner committed
438
	if ((error = git_iterator_for_index(&i, git_index_owner(idx), idx, NULL)) < 0)
439
		goto done;
440

David Turner committed
441
	while (!(error = git_iterator_advance(&entry, i))) {
442
		size_t pos = git_strmap_lookup_index(map, entry->path);
David Turner committed
443 444 445 446 447 448 449 450 451 452
		git_submodule *sm;

		if (git_strmap_valid_index(map, pos)) {
			sm = git_strmap_value_at(map, pos);

			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)) {
453
			size_t name_pos;
454 455 456 457 458 459 460 461
			const char *name;

			name_pos = git_strmap_lookup_index(names, entry->path);
			if (git_strmap_valid_index(names, name_pos)) {
				name = git_strmap_value_at(names, name_pos);
			} else {
				name = entry->path;
			}
462

463
			if (!submodule_get_or_create(&sm, git_index_owner(idx), map, name)) {
David Turner committed
464 465 466 467 468
				submodule_update_from_index_entry(sm, entry);
				git_submodule_free(sm);
			}
		}
	}
469

David Turner committed
470 471
	if (error == GIT_ITEROVER)
		error = 0;
472

473
done:
David Turner committed
474
	git_iterator_free(i);
475
	free_submodule_names(names);
476

David Turner committed
477
	return error;
478 479
}

480
static int submodules_from_head(git_strmap *map, git_tree *head, git_config *cfg)
481
{
David Turner committed
482
	int error;
483
	git_iterator *i = NULL;
David Turner committed
484
	const git_index_entry *entry;
485 486 487
	git_strmap *names;

	if ((error = load_submodule_names(&names, git_tree_owner(head), cfg)))
488
		goto done;
489

David Turner committed
490
	if ((error = git_iterator_for_tree(&i, head, NULL)) < 0)
491
		goto done;
492

David Turner committed
493
	while (!(error = git_iterator_advance(&entry, i))) {
494
		size_t pos = git_strmap_lookup_index(map, entry->path);
David Turner committed
495 496 497 498 499 500 501 502 503 504
		git_submodule *sm;

		if (git_strmap_valid_index(map, pos)) {
			sm = git_strmap_value_at(map, pos);

			if (S_ISGITLINK(entry->mode))
				submodule_update_from_head_data(sm, entry->mode, &entry->id);
			else
				sm->flags |= GIT_SUBMODULE_STATUS__HEAD_NOT_SUBMODULE;
		} else if (S_ISGITLINK(entry->mode)) {
505
			size_t name_pos;
506 507 508 509 510 511 512 513
			const char *name;

			name_pos = git_strmap_lookup_index(names, entry->path);
			if (git_strmap_valid_index(names, name_pos)) {
				name = git_strmap_value_at(names, name_pos);
			} else {
				name = entry->path;
			}
514

515
			if (!submodule_get_or_create(&sm, git_tree_owner(head), map, name)) {
David Turner committed
516 517 518 519 520 521
				submodule_update_from_head_data(
					sm, entry->mode, &entry->id);
				git_submodule_free(sm);
			}
		}
	}
522

David Turner committed
523 524
	if (error == GIT_ITEROVER)
		error = 0;
525

526
done:
David Turner committed
527
	git_iterator_free(i);
528
	free_submodule_names(names);
529

David Turner committed
530
	return error;
531 532 533 534
}

/* If have_sm is true, sm is populated, otherwise map an repo are. */
typedef struct {
535
	git_config *mods;
536 537 538 539
	git_strmap *map;
	git_repository *repo;
} lfc_data;

540
int git_submodule__map(git_repository *repo, git_strmap *map)
541 542 543 544 545 546 547
{
	int error = 0;
	git_index *idx = NULL;
	git_tree *head = NULL;
	const char *wd = NULL;
	git_buf path = GIT_BUF_INIT;
	git_submodule *sm;
548
	git_config *mods = NULL;
549 550 551 552 553 554 555 556 557 558 559 560 561

	assert(repo && map);

	/* get sources that we will need to check */
	if (git_repository_index(&idx, repo) < 0)
		giterr_clear();
	if (git_repository_head_tree(&head, repo) < 0)
		giterr_clear();

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

562 563 564 565 566 567
	/* add submodule information from .gitmodules */
	if (wd) {
		lfc_data data = { 0 };
		data.map = map;
		data.repo = repo;

568 569 570
		if ((error = gitmodules_snapshot(&mods, repo)) < 0) {
			if (error == GIT_ENOTFOUND)
				error = 0;
571
			goto cleanup;
572
		}
573 574 575 576 577 578

		data.mods = mods;
		if ((error = git_config_foreach(
			    mods, submodule_load_each, &data)) < 0)
			goto cleanup;
	}
579
	/* add back submodule information from index */
580
	if (mods && idx) {
581
		if ((error = submodules_from_index(map, idx, mods)) < 0)
582 583 584
			goto cleanup;
	}
	/* add submodule information from HEAD */
585
	if (mods && head) {
586
		if ((error = submodules_from_head(map, head, mods)) < 0)
587 588 589
			goto cleanup;
	}
	/* shallow scan submodules in work tree as needed */
590
	if (wd) {
591 592 593 594 595 596
		git_strmap_foreach_value(map, sm, {
				submodule_load_from_wd_lite(sm);
			});
	}

cleanup:
597
	git_config_free(mods);
598 599 600
	/* TODO: if we got an error, mark submodule config as invalid? */
	git_index_free(idx);
	git_tree_free(head);
601
	git_buf_dispose(&path);
602 603 604
	return error;
}

Russell Belfer committed
605 606
int git_submodule_foreach(
	git_repository *repo,
607
	git_submodule_cb callback,
Russell Belfer committed
608 609
	void *payload)
{
610 611 612
	git_vector snapshot = GIT_VECTOR_INIT;
	git_strmap *submodules;
	git_submodule *sm;
Russell Belfer committed
613
	int error;
614
	size_t i;
Russell Belfer committed
615

616 617 618 619 620
	if (repo->is_bare) {
		giterr_set(GITERR_SUBMODULE, "cannot get submodules without a working tree");
		return -1;
	}

621
	if ((error = git_strmap_alloc(&submodules)) < 0)
Russell Belfer committed
622 623
		return error;

624
	if ((error = git_submodule__map(repo, submodules)) < 0)
625
		goto done;
626 627

	if (!(error = git_vector_init(
628
			&snapshot, git_strmap_num_entries(submodules), submodule_cmp))) {
629

630
		git_strmap_foreach_value(submodules, sm, {
631
			if ((error = git_vector_insert(&snapshot, sm)) < 0)
Russell Belfer committed
632
				break;
633 634 635 636 637 638 639 640 641 642
			GIT_REFCOUNT_INC(sm);
		});
	}

	if (error < 0)
		goto done;

	git_vector_uniq(&snapshot, submodule_free_dup);

	git_vector_foreach(&snapshot, i, sm) {
643
		if ((error = callback(sm, sm->name, payload)) != 0) {
644
			giterr_set_after_callback(error);
Russell Belfer committed
645
			break;
646
		}
647
	}
Russell Belfer committed
648

649 650 651 652
done:
	git_vector_foreach(&snapshot, i, sm)
		git_submodule_free(sm);
	git_vector_free(&snapshot);
Russell Belfer committed
653

654 655 656 657
	git_strmap_foreach_value(submodules, sm, {
		git_submodule_free(sm);
	});
	git_strmap_free(submodules);
Russell Belfer committed
658

659
	return error;
Russell Belfer committed
660 661
}

662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688
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) {
689 690 691 692
		error = git_repository_item_path(&repodir, parent_repo, GIT_REPOSITORY_ITEM_MODULES);
		if (error < 0)
			goto cleanup;
		error = git_buf_joinpath(&repodir, repodir.ptr, path);
693 694 695 696 697 698 699 700 701 702 703 704 705
		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:
706 707
	git_buf_dispose(&workdir);
	git_buf_dispose(&repodir);
708 709 710 711 712 713

	*out = subrepo;

	return error;
}

Russell Belfer committed
714
int git_submodule_add_setup(
715
	git_submodule **out,
Russell Belfer committed
716 717 718 719 720 721
	git_repository *repo,
	const char *url,
	const char *path,
	int use_gitlink)
{
	int error = 0;
Ben Straub committed
722
	git_config_backend *mods = NULL;
723
	git_submodule *sm = NULL;
Russell Belfer committed
724 725
	git_buf name = GIT_BUF_INIT, real_url = GIT_BUF_INIT;
	git_repository *subrepo = NULL;
726
	bool path_occupied;
Russell Belfer committed
727 728 729 730 731

	assert(repo && url && path);

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

732
	if (git_submodule_lookup(NULL, repo, path) < 0)
Russell Belfer committed
733 734 735
		giterr_clear();
	else {
		giterr_set(GITERR_SUBMODULE,
736
			"attempt to add submodule '%s' that already exists", path);
Russell Belfer committed
737 738 739 740 741 742 743 744 745
		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) {
746
		giterr_set(GITERR_SUBMODULE, "submodule path must be a relative path");
Russell Belfer committed
747 748 749 750
		error = -1;
		goto cleanup;
	}

751
	if ((error = is_path_occupied(&path_occupied, repo, path)) < 0)
752 753
		goto cleanup;

754 755 756 757 758
	if (path_occupied) {
		error = GIT_EEXISTS;
		goto cleanup;
	}

Russell Belfer committed
759 760
	/* update .gitmodules */

761
	if (!(mods = open_gitmodules(repo, GITMODULES_CREATE))) {
Russell Belfer committed
762
		giterr_set(GITERR_SUBMODULE,
763
			"adding submodules to a bare repository is not supported");
Russell Belfer committed
764 765 766 767
		return -1;
	}

	if ((error = git_buf_printf(&name, "submodule.%s.path", path)) < 0 ||
768
		(error = git_config_backend_set_string(mods, name.ptr, path)) < 0)
Russell Belfer committed
769 770 771
		goto cleanup;

	if ((error = submodule_config_key_trunc_puts(&name, "url")) < 0 ||
772
		(error = git_config_backend_set_string(mods, name.ptr, url)) < 0)
Russell Belfer committed
773 774 775 776 777 778 779 780 781 782
		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;

783 784
	/* if the repo does not already exist, then init a new repo and add it.
	 * Otherwise, just add the existing repo.
Russell Belfer committed
785
	 */
786 787
	if (!(git_path_exists(name.ptr) &&
		git_path_contains(&name, DOT_GIT))) {
788 789 790 791 792 793

		/* 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
794 795 796
			goto cleanup;
	}

797
	if ((error = git_submodule_lookup(&sm, repo, path)) < 0)
798
		goto cleanup;
Russell Belfer committed
799

800
	error = git_submodule_init(sm, false);
801

Russell Belfer committed
802
cleanup:
803 804 805 806 807 808
	if (error && sm) {
		git_submodule_free(sm);
		sm = NULL;
	}
	if (out != NULL)
		*out = sm;
Russell Belfer committed
809

810
	git_config_backend_free(mods);
Russell Belfer committed
811
	git_repository_free(subrepo);
812 813
	git_buf_dispose(&real_url);
	git_buf_dispose(&name);
Russell Belfer committed
814 815 816 817

	return error;
}

818 819 820 821 822 823 824
int git_submodule_repo_init(
	git_repository **out,
	const git_submodule *sm,
	int use_gitlink)
{
	int error;
	git_repository *sub_repo = NULL;
825 826 827
	const char *configured_url;
	git_config *cfg = NULL;
	git_buf buf = GIT_BUF_INIT;
828 829 830

	assert(out && sm);

831 832
	/* get the configured remote url of the submodule */
	if ((error = git_buf_printf(&buf, "submodule.%s.url", sm->name)) < 0 ||
833
		(error = git_repository_config_snapshot(&cfg, sm->repo)) < 0 ||
834 835 836
		(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;
837 838 839

	*out = sub_repo;

840 841
done:
	git_config_free(cfg);
842
	git_buf_dispose(&buf);
843 844 845
	return error;
}

Russell Belfer committed
846 847 848 849 850 851 852
int git_submodule_add_finalize(git_submodule *sm)
{
	int error;
	git_index *index;

	assert(sm);

853
	if ((error = git_repository_index__weakptr(&index, sm->repo)) < 0 ||
854
		(error = git_index_add_bypath(index, GIT_MODULES_FILE)) < 0)
Russell Belfer committed
855 856
		return error;

857
	return git_submodule_add_to_index(sm, true);
Russell Belfer committed
858 859
}

860
int git_submodule_add_to_index(git_submodule *sm, int write_index)
Russell Belfer committed
861 862
{
	int error;
863
	git_repository *sm_repo = NULL;
Russell Belfer committed
864 865 866 867 868 869 870 871
	git_index *index;
	git_buf path = GIT_BUF_INIT;
	git_commit *head;
	git_index_entry entry;
	struct stat st;

	assert(sm);

872 873 874
	/* force reload of wd OID by git_submodule_open */
	sm->flags = sm->flags & ~GIT_SUBMODULE_STATUS__WD_OID_VALID;

875
	if ((error = git_repository_index__weakptr(&index, sm->repo)) < 0 ||
Russell Belfer committed
876
		(error = git_buf_joinpath(
877
			&path, git_repository_workdir(sm->repo), sm->path)) < 0 ||
Russell Belfer committed
878 879 880 881 882 883
		(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,
884
			"cannot add submodule without working directory");
Russell Belfer committed
885 886 887
		error = -1;
		goto cleanup;
	}
888 889

	memset(&entry, 0, sizeof(entry));
890
	entry.path = sm->path;
891 892
	git_index_entry__init_from_stat(
		&entry, &st, !(git_index_caps(index) & GIT_INDEXCAP_NO_FILEMODE));
Russell Belfer committed
893 894 895 896

	/* 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,
897
			"cannot add submodule without HEAD to index");
Russell Belfer committed
898 899 900
		error = -1;
		goto cleanup;
	}
901
	git_oid_cpy(&entry.id, &sm->wd_oid);
Russell Belfer committed
902 903 904 905

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

906
	entry.ctime.seconds = (int32_t)git_commit_time(head);
Russell Belfer committed
907
	entry.ctime.nanoseconds = 0;
908
	entry.mtime.seconds = (int32_t)git_commit_time(head);
Russell Belfer committed
909 910 911 912
	entry.mtime.nanoseconds = 0;

	git_commit_free(head);

913
	/* add it */
Edward Thomson committed
914
	error = git_index_add(index, &entry);
Russell Belfer committed
915

916 917 918 919 920 921 922 923
	/* 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
924 925
cleanup:
	git_repository_free(sm_repo);
926
	git_buf_dispose(&path);
Russell Belfer committed
927 928 929
	return error;
}

930 931 932 933
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)
934
		if (_sm_update_map[i].map_value == (int)update)
935 936 937 938
			return _sm_update_map[i].str_match;
	return NULL;
}

Russell Belfer committed
939 940 941
git_repository *git_submodule_owner(git_submodule *submodule)
{
	assert(submodule);
942
	return submodule->repo;
Russell Belfer committed
943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962
}

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;
}

963 964 965
int git_submodule_resolve_url(git_buf *out, git_repository *repo, const char *url)
{
	int error = 0;
966
	git_buf normalized = GIT_BUF_INIT;
967

968 969 970
	assert(out && repo && url);

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

972
	/* We do this in all platforms in case someone on Windows created the .gitmodules */
973
	if (strchr(url, '\\')) {
974
		if ((error = git_path_normalize_slashes(&normalized, url)) < 0)
975 976 977 978 979
			return error;

		url = normalized.ptr;
	}

980

981
	if (git_path_is_relative(url)) {
982
		if (!(error = get_url_base(out, repo)))
983 984 985 986
			error = git_path_apply_relative(out, url);
	} else if (strchr(url, ':') != NULL || url[0] == '/') {
		error = git_buf_sets(out, url);
	} else {
987
		giterr_set(GITERR_SUBMODULE, "invalid format for submodule URL");
988 989 990
		error = -1;
	}

991
	git_buf_dispose(&normalized);
992 993 994
	return error;
}

995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008
static int write_var(git_repository *repo, const char *name, const char *var, const char *val)
{
	git_buf key = GIT_BUF_INIT;
	git_config_backend *mods;
	int error;

	mods = open_gitmodules(repo, GITMODULES_CREATE);
	if (!mods)
		return -1;

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

	if (val)
1009
		error = git_config_backend_set_string(mods, key.ptr, val);
1010
	else
1011
		error = git_config_backend_delete(mods, key.ptr);
1012

1013
	git_buf_dispose(&key);
1014 1015

cleanup:
1016
	git_config_backend_free(mods);
1017 1018 1019
	return error;
}

1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035
static int write_mapped_var(git_repository *repo, const char *name, git_cvar_map *maps, size_t nmaps, const char *var, int ival)
{
	git_cvar_t type;
	const char *val;

	if (git_config_lookup_map_enum(&type, &val, maps, nmaps, ival) < 0) {
		giterr_set(GITERR_SUBMODULE, "invalid value for %s", var);
		return -1;
	}

	if (type == GIT_CVAR_TRUE)
		val = "true";

	return write_var(repo, name, var, val);
}

1036 1037 1038 1039 1040 1041
const char *git_submodule_branch(git_submodule *submodule)
{
	assert(submodule);
	return submodule->branch;
}

1042
int git_submodule_set_branch(git_repository *repo, const char *name, const char *branch)
1043 1044
{

1045
	assert(repo && name);
1046

1047
	return write_var(repo, name, "branch", branch);
1048 1049
}

1050
int git_submodule_set_url(git_repository *repo, const char *name, const char *url)
Russell Belfer committed
1051
{
1052
	assert(repo && name && url);
Russell Belfer committed
1053

1054
	return write_var(repo, name, "url", url);
Russell Belfer committed
1055 1056
}

1057
const git_oid *git_submodule_index_id(git_submodule *submodule)
Russell Belfer committed
1058 1059 1060 1061 1062 1063 1064 1065 1066
{
	assert(submodule);

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

1067
const git_oid *git_submodule_head_id(git_submodule *submodule)
Russell Belfer committed
1068 1069 1070 1071 1072 1073 1074 1075 1076
{
	assert(submodule);

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

1077
const git_oid *git_submodule_wd_id(git_submodule *submodule)
Russell Belfer committed
1078 1079 1080
{
	assert(submodule);

1081
	/* load unless we think we have a valid oid */
Russell Belfer committed
1082 1083 1084 1085
	if (!(submodule->flags & GIT_SUBMODULE_STATUS__WD_OID_VALID)) {
		git_repository *subrepo;

		/* calling submodule open grabs the HEAD OID if possible */
1086
		if (!git_submodule_open_bare(&subrepo, submodule))
Russell Belfer committed
1087
			git_repository_free(subrepo);
1088 1089
		else
			giterr_clear();
Russell Belfer committed
1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100
	}

	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);
1101 1102
	return (submodule->ignore < GIT_SUBMODULE_IGNORE_NONE) ?
		GIT_SUBMODULE_IGNORE_NONE : submodule->ignore;
Russell Belfer committed
1103 1104
}

1105 1106
int git_submodule_set_ignore(git_repository *repo, const char *name, git_submodule_ignore_t ignore)
{
1107
	assert(repo && name);
1108

1109
	return write_mapped_var(repo, name, _sm_ignore_map, ARRAY_SIZE(_sm_ignore_map), "ignore", ignore);
1110 1111
}

1112
git_submodule_update_t git_submodule_update_strategy(git_submodule *submodule)
Russell Belfer committed
1113 1114
{
	assert(submodule);
1115 1116
	return (submodule->update < GIT_SUBMODULE_UPDATE_CHECKOUT) ?
		GIT_SUBMODULE_UPDATE_CHECKOUT : submodule->update;
Russell Belfer committed
1117 1118
}

1119
int git_submodule_set_update(git_repository *repo, const char *name, git_submodule_update_t update)
Russell Belfer committed
1120
{
1121
	assert(repo && name);
Russell Belfer committed
1122

1123
	return write_mapped_var(repo, name, _sm_update_map, ARRAY_SIZE(_sm_update_map), "update", update);
Russell Belfer committed
1124 1125
}

1126
git_submodule_recurse_t git_submodule_fetch_recurse_submodules(
1127 1128 1129 1130 1131 1132
	git_submodule *submodule)
{
	assert(submodule);
	return submodule->fetch_recurse;
}

1133
int git_submodule_set_fetch_recurse_submodules(git_repository *repo, const char *name, git_submodule_recurse_t recurse)
1134
{
1135 1136
	assert(repo && name);

1137
	return write_mapped_var(repo, name, _sm_recurse_map, ARRAY_SIZE(_sm_recurse_map), "fetchRecurseSubmodules", recurse);
1138 1139
}

1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164
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:
1165
	 * <repo-dir>/modules/<name>/ with a gitlink in the
1166 1167
	 * sub-repo workdir directory to that repository.
	 */
1168 1169 1170 1171
	error = git_repository_item_path(&repodir, parent_repo, GIT_REPOSITORY_ITEM_MODULES);
	if (error < 0)
		goto cleanup;
	error = git_buf_joinpath(&repodir, repodir.ptr, path);
1172 1173 1174 1175 1176 1177
	if (error < 0)
		goto cleanup;

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

cleanup:
1178 1179
	git_buf_dispose(&workdir);
	git_buf_dispose(&repodir);
1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195

	*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)
{
1196 1197
	git_submodule *sm;

1198
	GIT_UNUSED(bare);
1199 1200

	sm = payload;
1201 1202 1203 1204

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

1205 1206 1207 1208 1209 1210 1211
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;
}

1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232
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 */
1233
	memcpy(&clone_options.fetch_opts, &update_options.fetch_opts, sizeof(git_fetch_options));
1234 1235

	/* Get the status of the submodule to determine if it is already initialized  */
1236
	if ((error = git_submodule_status(&submodule_status, sm->repo, sm->name, GIT_SUBMODULE_IGNORE_UNSPECIFIED)) < 0)
1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259
		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;

1260
			if (!init) {
1261
				giterr_set(GITERR_SUBMODULE, "submodule is not initialized");
1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283
				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;

		/*
1284
		 * Do not perform checkout as part of clone, instead we
1285 1286 1287 1288 1289
		 * will checkout the specific commit manually.
		 */
		clone_options.checkout_opts.checkout_strategy = GIT_CHECKOUT_NONE;

		if ((error = git_clone(&sub_repo, submodule_url, sm->path, &clone_options)) < 0 ||
1290
			(error = git_repository_set_head_detached(sub_repo, git_submodule_index_id(sm))) < 0 ||
1291 1292 1293
			(error = git_checkout_head(sub_repo, &update_options.checkout_opts)) != 0)
			goto done;
	} else {
1294 1295
		const git_oid *oid;

1296 1297 1298 1299 1300
		/**
		 * 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.
		 */
1301 1302 1303
		if ((error = git_submodule_open(&sub_repo, sm)) < 0)
			goto done;

1304 1305 1306 1307 1308 1309
		if ((oid = git_submodule_index_id(sm)) == NULL) {
			giterr_set(GITERR_SUBMODULE, "could not get ID of submodule in index");
			error = -1;
			goto done;
		}

1310
		/* Look up the target commit in the submodule. */
1311
		if ((error = git_object_lookup(&target_commit, sub_repo, oid, GIT_OBJ_COMMIT)) < 0) {
1312 1313 1314 1315 1316 1317 1318 1319 1320
			/* If it isn't found then fetch and try again. */
			if (error != GIT_ENOTFOUND || !update_options.allow_fetch ||
				(error = lookup_default_remote(&remote, sub_repo)) < 0 ||
				(error = git_remote_fetch(remote, NULL, &update_options.fetch_opts, NULL)) < 0 ||
				(error = git_object_lookup(&target_commit, sub_repo, git_submodule_index_id(sm), GIT_OBJ_COMMIT)) < 0)
				goto done;
		}

		if ((error = git_checkout_tree(sub_repo, target_commit, &update_options.checkout_opts)) != 0 ||
1321
			(error = git_repository_set_head_detached(sub_repo, git_submodule_index_id(sm))) < 0)
1322 1323 1324 1325 1326 1327 1328 1329 1330 1331
			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:
1332
	git_buf_dispose(&buf);
1333 1334 1335 1336 1337 1338 1339 1340
	git_config_free(config);
	git_object_free(target_commit);
	git_remote_free(remote);
	git_repository_free(sub_repo);

	return error;
}

1341
int git_submodule_init(git_submodule *sm, int overwrite)
Russell Belfer committed
1342 1343
{
	int error;
1344
	const char *val;
1345
	git_buf key = GIT_BUF_INIT, effective_submodule_url = GIT_BUF_INIT;
1346
	git_config *cfg = NULL;
Russell Belfer committed
1347

1348
	if (!sm->url) {
Russell Belfer committed
1349
		giterr_set(GITERR_SUBMODULE,
1350
			"no URL configured for submodule '%s'", sm->name);
Russell Belfer committed
1351 1352 1353
		return -1;
	}

1354
	if ((error = git_repository_config(&cfg, sm->repo)) < 0)
Russell Belfer committed
1355 1356
		return error;

1357 1358
	/* write "submodule.NAME.url" */

1359
	if ((error = git_submodule_resolve_url(&effective_submodule_url, sm->repo, sm->url)) < 0 ||
1360
		(error = git_buf_printf(&key, "submodule.%s.url", sm->name)) < 0 ||
1361
		(error = git_config__update_entry(
1362
			cfg, key.ptr, effective_submodule_url.ptr, overwrite != 0, false)) < 0)
1363 1364
		goto cleanup;

Russell Belfer committed
1365 1366
	/* write "submodule.NAME.update" if not default */

1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378
	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);
1379 1380
	git_buf_dispose(&key);
	git_buf_dispose(&effective_submodule_url);
Russell Belfer committed
1381 1382 1383 1384

	return error;
}

1385
int git_submodule_sync(git_submodule *sm)
Russell Belfer committed
1386
{
1387 1388 1389
	int error = 0;
	git_config *cfg = NULL;
	git_buf key = GIT_BUF_INIT;
1390
	git_repository *smrepo = NULL;
1391 1392

	if (!sm->url) {
Russell Belfer committed
1393
		giterr_set(GITERR_SUBMODULE,
1394
			"no URL configured for submodule '%s'", sm->name);
Russell Belfer committed
1395 1396 1397 1398 1399
		return -1;
	}

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

1400 1401 1402 1403 1404 1405
	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 */

1406 1407 1408 1409
	if (!error &&
		(sm->flags & GIT_SUBMODULE_STATUS_IN_WD) != 0 &&
		!(error = git_submodule_open(&smrepo, sm)))
	{
1410 1411 1412 1413 1414
		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) {
1415
			giterr_clear();
1416
			error = git_buf_sets(&key, "remote.origin.url");
1417 1418
		} else {
			error = git_buf_join3(
1419
				&key, '.', "remote", remote_name.ptr, "url");
1420
			git_buf_dispose(&remote_name);
1421 1422
		}

1423 1424
		if (!error)
			error = git_config__update_entry(cfg, key.ptr, sm->url, true, false);
1425 1426 1427 1428

		git_repository_free(smrepo);
	}

1429
	git_buf_dispose(&key);
1430 1431

	return error;
Russell Belfer committed
1432 1433
}

1434 1435
static int git_submodule__open(
	git_repository **subrepo, git_submodule *sm, bool bare)
Russell Belfer committed
1436 1437 1438
{
	int error;
	git_buf path = GIT_BUF_INIT;
1439 1440
	unsigned int flags = GIT_REPOSITORY_OPEN_NO_SEARCH;
	const char *wd;
Russell Belfer committed
1441

1442
	assert(sm && subrepo);
Russell Belfer committed
1443

1444 1445 1446
	if (git_repository__ensure_not_bare(
			sm->repo, "open submodule repository") < 0)
		return GIT_EBAREREPO;
Russell Belfer committed
1447

1448
	wd = git_repository_workdir(sm->repo);
Russell Belfer committed
1449

1450 1451
	if (git_buf_joinpath(&path, wd, sm->path) < 0 ||
		git_buf_joinpath(&path, path.ptr, DOT_GIT) < 0)
Russell Belfer committed
1452 1453
		return -1;

1454 1455 1456 1457
	sm->flags = sm->flags &
		~(GIT_SUBMODULE_STATUS_IN_WD |
		  GIT_SUBMODULE_STATUS__WD_OID_VALID |
		  GIT_SUBMODULE_STATUS__WD_SCANNED);
Russell Belfer committed
1458

1459 1460
	if (bare)
		flags |= GIT_REPOSITORY_OPEN_BARE;
Russell Belfer committed
1461

1462
	error = git_repository_open_ext(subrepo, path.ptr, flags, wd);
1463

1464 1465 1466 1467
	/* if we opened the submodule successfully, grab HEAD OID, etc. */
	if (!error) {
		sm->flags |= GIT_SUBMODULE_STATUS_IN_WD |
			GIT_SUBMODULE_STATUS__WD_SCANNED;
1468

1469 1470 1471 1472 1473 1474 1475 1476 1477
		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" */
1478

1479 1480 1481
		if (git_path_isdir(path.ptr))
			sm->flags |= GIT_SUBMODULE_STATUS__WD_SCANNED;
	}
1482

1483
	git_buf_dispose(&path);
1484

1485 1486
	return error;
}
1487

1488 1489 1490 1491
int git_submodule_open_bare(git_repository **subrepo, git_submodule *sm)
{
	return git_submodule__open(subrepo, sm, true);
}
Russell Belfer committed
1492

1493 1494 1495
int git_submodule_open(git_repository **subrepo, git_submodule *sm)
{
	return git_submodule__open(subrepo, sm, false);
Russell Belfer committed
1496 1497
}

1498 1499
static void submodule_update_from_index_entry(
	git_submodule *sm, const git_index_entry *ie)
Russell Belfer committed
1500
{
1501
	bool already_found = (sm->flags & GIT_SUBMODULE_STATUS_IN_INDEX) != 0;
Russell Belfer committed
1502

1503 1504 1505 1506 1507 1508 1509
	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
1510
			git_oid_cpy(&sm->index_oid, &ie->id);
Russell Belfer committed
1511

1512 1513 1514 1515 1516 1517 1518 1519 1520
		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
1521

1522
	if (git_repository_index__weakptr(&index, sm->repo) < 0)
Russell Belfer committed
1523 1524
		return -1;

1525
	sm->flags = sm->flags &
1526 1527 1528
		~(GIT_SUBMODULE_STATUS_IN_INDEX |
		  GIT_SUBMODULE_STATUS__INDEX_OID_VALID);

1529 1530
	if (!(ie = git_index_get_bypath(index, sm->path, 0)))
		return 0;
Russell Belfer committed
1531

1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546
	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
1547
	}
1548
}
Russell Belfer committed
1549

1550 1551 1552
static int submodule_update_head(git_submodule *submodule)
{
	git_tree *head = NULL;
nulltoken committed
1553
	git_tree_entry *te = NULL;
Russell Belfer committed
1554

1555 1556 1557
	submodule->flags = submodule->flags &
		~(GIT_SUBMODULE_STATUS_IN_HEAD |
		  GIT_SUBMODULE_STATUS__HEAD_OID_VALID);
Russell Belfer committed
1558

1559 1560 1561 1562 1563
	/* 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
1564
		submodule_update_from_head_data(submodule, te->attr, git_tree_entry_id(te));
Russell Belfer committed
1565

nulltoken committed
1566
	git_tree_entry_free(te);
1567 1568 1569
	git_tree_free(head);
	return 0;
}
1570

1571
int git_submodule_reload(git_submodule *sm, int force)
1572
{
1573
	int error = 0, isvalid;
1574
	git_config *mods;
Russell Belfer committed
1575

1576 1577
	GIT_UNUSED(force);

1578 1579
	assert(sm);

1580 1581
	isvalid = git_submodule_name_is_valid(sm->repo, sm->name, 0);
	if (isvalid <= 0) {
1582
		/* This should come with a warning, but we've no API for that */
1583
		return isvalid;
1584 1585
	}

1586 1587
	if (!git_repository_is_bare(sm->repo)) {
		/* refresh config data */
1588 1589
		if ((error = gitmodules_snapshot(&mods, sm->repo)) < 0 && error != GIT_ENOTFOUND)
			return error;
1590 1591 1592
		if (mods != NULL) {
			error = submodule_read_config(sm, mods);
			git_config_free(mods);
Russell Belfer committed
1593

1594 1595 1596
			if (error < 0)
				return error;
		}
1597

1598 1599 1600 1601 1602
		/* refresh wd data */
		sm->flags &=
			~(GIT_SUBMODULE_STATUS_IN_WD |
			  GIT_SUBMODULE_STATUS__WD_OID_VALID |
			  GIT_SUBMODULE_STATUS__WD_FLAGS);
Russell Belfer committed
1603

1604
		error = submodule_load_from_wd_lite(sm);
1605
	}
1606

1607 1608
	if (error == 0 && (error = submodule_update_index(sm)) == 0)
		error = submodule_update_head(sm);
1609

1610
	return error;
Russell Belfer committed
1611 1612
}

1613 1614
static void submodule_copy_oid_maybe(
	git_oid *tgt, const git_oid *src, bool valid)
Russell Belfer committed
1615
{
1616 1617 1618 1619 1620 1621 1622
	if (tgt) {
		if (valid)
			memcpy(tgt, src, sizeof(*tgt));
		else
			memset(tgt, 0, sizeof(*tgt));
	}
}
1623

1624 1625 1626 1627 1628 1629 1630 1631 1632 1633
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
1634

1635
	if (ign == GIT_SUBMODULE_IGNORE_UNSPECIFIED)
1636
		ign = sm->ignore;
1637

1638 1639 1640 1641
	/* only return location info if ignore == all */
	if (ign == GIT_SUBMODULE_IGNORE_ALL) {
		*out_status = (sm->flags & GIT_SUBMODULE_STATUS__IN_FLAGS);
		return 0;
1642
	}
Russell Belfer committed
1643

1644 1645 1646 1647 1648 1649
	/* If the user has requested caching submodule state, performing these
	 * expensive operations (especially `submodule_update_head`, which is
	 * bottlenecked on `git_repository_head_tree`) eliminates much of the
	 * advantage.  We will, therefore, interpret the request for caching to
	 * apply here to and skip them.
	 */
1650

1651 1652 1653 1654 1655 1656 1657 1658 1659
	if (sm->repo->submodule_cache == NULL) {
		/* 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
1660

1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690
	/* 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
1691 1692
}

1693
int git_submodule_status(unsigned int *status, git_repository *repo, const char *name, git_submodule_ignore_t ignore)
1694
{
1695 1696 1697 1698 1699 1700 1701 1702
	git_submodule *sm;
	int error;

	assert(status && repo && name);

	if ((error = git_submodule_lookup(&sm, repo, name)) < 0)
		return error;

1703
	error = git_submodule__status(status, NULL, NULL, NULL, sm, ignore);
1704
	git_submodule_free(sm);
1705

1706
	return error;
1707
}
1708

1709 1710 1711 1712 1713 1714
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);
1715 1716
}

Russell Belfer committed
1717 1718 1719 1720
/*
 * INTERNAL FUNCTIONS
 */

1721
static int submodule_alloc(
1722
	git_submodule **out, git_repository *repo, const char *name)
1723
{
1724
	size_t namelen;
1725
	git_submodule *sm;
1726

1727
	if (!name || !(namelen = strlen(name))) {
1728
		giterr_set(GITERR_SUBMODULE, "invalid submodule name");
1729
		return -1;
1730 1731
	}

1732
	sm = git__calloc(1, sizeof(git_submodule));
1733
	GITERR_CHECK_ALLOC(sm);
1734

1735 1736 1737
	sm->name = sm->path = git__strdup(name);
	if (!sm->name) {
		git__free(sm);
1738
		return -1;
1739
	}
Russell Belfer committed
1740

1741
	GIT_REFCOUNT_INC(sm);
1742 1743
	sm->ignore = sm->ignore_default = GIT_SUBMODULE_IGNORE_NONE;
	sm->update = sm->update_default = GIT_SUBMODULE_UPDATE_CHECKOUT;
1744
	sm->fetch_recurse = sm->fetch_recurse_default = GIT_SUBMODULE_RECURSE_NO;
1745
	sm->repo   = repo;
1746
	sm->branch = NULL;
1747

1748 1749
	*out = sm;
	return 0;
Russell Belfer committed
1750 1751
}

1752
static void submodule_release(git_submodule *sm)
Russell Belfer committed
1753 1754 1755 1756
{
	if (!sm)
		return;

1757
	if (sm->repo) {
1758
		sm->repo = NULL;
1759 1760
	}

1761 1762 1763 1764
	if (sm->path != sm->name)
		git__free(sm->path);
	git__free(sm->name);
	git__free(sm->url);
1765
	git__free(sm->branch);
1766 1767 1768
	git__memzero(sm, sizeof(*sm));
	git__free(sm);
}
Russell Belfer committed
1769

1770 1771 1772 1773 1774
void git_submodule_free(git_submodule *sm)
{
	if (!sm)
		return;
	GIT_REFCOUNT_DEC(sm, submodule_release);
Russell Belfer committed
1775 1776
}

1777 1778 1779
static int submodule_config_error(const char *property, const char *value)
{
	giterr_set(GITERR_INVALID,
1780
		"invalid value for submodule '%s' property: '%s'", property, value);
1781
	return -1;
1782 1783
}

1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811
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;
}

1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825
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;
}

1826
static int get_value(const char **out, git_config *cfg, git_buf *buf, const char *name, const char *field)
1827
{
1828
	int error;
1829

1830
	git_buf_clear(buf);
1831

1832 1833 1834
	if ((error = git_buf_printf(buf, "submodule.%s.%s", name, field)) < 0 ||
	    (error = git_config_get_string(out, cfg, buf->ptr)) < 0)
		return error;
1835

1836 1837
	return error;
}
1838

1839 1840 1841 1842 1843 1844 1845 1846
static bool looks_like_command_line_option(const char *s)
{
	if (s && s[0] == '-')
		return true;

	return false;
}

1847 1848 1849 1850 1851
static int submodule_read_config(git_submodule *sm, git_config *cfg)
{
	git_buf key = GIT_BUF_INIT;
	const char *value;
	int error, in_config = 0;
Russell Belfer committed
1852

1853 1854 1855
	/*
	 * 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)
1856
	 */
1857

1858 1859
	if ((error = get_value(&value, cfg, &key, sm->name, "path")) == 0) {
		in_config = 1;
1860 1861
		/* We would warn here if we had that API */
		if (!looks_like_command_line_option(value)) {
1862 1863
	/*
	 * TODO: if case insensitive filesystem, then the following strcmp
1864 1865
	 * should be strcasecmp
	 */
1866 1867 1868 1869 1870 1871 1872
			if (strcmp(sm->name, value) != 0) {
				if (sm->path != sm->name)
					git__free(sm->path);
				sm->path = git__strdup(value);
				GITERR_CHECK_ALLOC(sm->path);
			}

1873
		}
1874
	} else if (error != GIT_ENOTFOUND) {
1875
		goto cleanup;
1876
	}
1877

1878
	if ((error = get_value(&value, cfg, &key, sm->name, "url")) == 0) {
1879 1880 1881 1882 1883 1884
		/* We would warn here if we had that API */
		if (!looks_like_command_line_option(value)) {
			in_config = 1;
			sm->url = git__strdup(value);
			GITERR_CHECK_ALLOC(sm->url);
		}
1885
	} else if (error != GIT_ENOTFOUND) {
1886
		goto cleanup;
1887 1888
	}

1889 1890 1891 1892 1893
	if ((error = get_value(&value, cfg, &key, sm->name, "branch")) == 0) {
		in_config = 1;
		sm->branch = git__strdup(value);
		GITERR_CHECK_ALLOC(sm->branch);
	} else if (error != GIT_ENOTFOUND) {
1894
		goto cleanup;
1895
	}
1896

1897 1898
	if ((error = get_value(&value, cfg, &key, sm->name, "update")) == 0) {
		in_config = 1;
1899
		if ((error = git_submodule_parse_update(&sm->update, value)) < 0)
1900
			goto cleanup;
1901
		sm->update_default = sm->update;
1902
	} else if (error != GIT_ENOTFOUND) {
1903
		goto cleanup;
1904
	}
1905 1906 1907

	if ((error = get_value(&value, cfg, &key, sm->name, "fetchRecurseSubmodules")) == 0) {
		in_config = 1;
1908
		if ((error = git_submodule_parse_recurse(&sm->fetch_recurse, value)) < 0)
1909
			goto cleanup;
1910
		sm->fetch_recurse_default = sm->fetch_recurse;
1911
	} else if (error != GIT_ENOTFOUND) {
1912
		goto cleanup;
1913
	}
1914 1915 1916

	if ((error = get_value(&value, cfg, &key, sm->name, "ignore")) == 0) {
		in_config = 1;
1917
		if ((error = git_submodule_parse_ignore(&sm->ignore, value)) < 0)
1918
			goto cleanup;
1919
		sm->ignore_default = sm->ignore;
1920
	} else if (error != GIT_ENOTFOUND) {
1921
		goto cleanup;
1922
	}
1923 1924 1925 1926

	if (in_config)
		sm->flags |= GIT_SUBMODULE_STATUS_IN_CONFIG;

1927 1928 1929
	error = 0;

cleanup:
1930
	git_buf_dispose(&key);
1931
	return error;
1932 1933 1934 1935 1936 1937
}

static int submodule_load_each(const git_config_entry *entry, void *payload)
{
	lfc_data *data = payload;
	const char *namestart, *property;
1938
	size_t pos;
1939 1940 1941
	git_strmap *map = data->map;
	git_buf name = GIT_BUF_INIT;
	git_submodule *sm;
1942
	int error, isvalid;
1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957

	if (git__prefixcmp(entry->name, "submodule.") != 0)
		return 0;

	namestart = entry->name + strlen("submodule.");
	property  = strrchr(namestart, '.');

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

	property++;

	if ((error = git_buf_set(&name, namestart, property - namestart -1)) < 0)
		return error;

1958 1959 1960
	isvalid = git_submodule_name_is_valid(data->repo, name.ptr, 0);
	if (isvalid <= 0) {
		error = isvalid;
1961 1962 1963
		goto done;
	}

1964 1965 1966 1967 1968 1969 1970
	/*
	 * Now that we have the submodule's name, we can use that to
	 * figure out whether it's in the map. If it's not, we create
	 * a new submodule, load the config and insert it. If it's
	 * already inserted, we've already loaded it, so we skip.
	 */
	pos = git_strmap_lookup_index(map, name.ptr);
1971 1972 1973 1974
	if (git_strmap_valid_index(map, pos)) {
		error = 0;
		goto done;
	}
1975 1976 1977 1978 1979 1980 1981 1982 1983

	if ((error = submodule_alloc(&sm, data->repo, name.ptr)) < 0)
		goto done;

	if ((error = submodule_read_config(sm, data->mods)) < 0) {
		git_submodule_free(sm);
		goto done;
	}

1984
	git_strmap_insert(map, sm->name, sm, &error);
1985 1986 1987 1988 1989
	assert(error != 0);
	if (error < 0)
		goto done;

	error = 0;
1990

1991
done:
1992
	git_buf_dispose(&name);
1993
	return error;
1994 1995
}

1996
static int submodule_load_from_wd_lite(git_submodule *sm)
Russell Belfer committed
1997 1998 1999
{
	git_buf path = GIT_BUF_INIT;

2000
	if (git_buf_joinpath(&path, git_repository_workdir(sm->repo), sm->path) < 0)
2001
		return -1;
Russell Belfer committed
2002 2003 2004 2005 2006 2007 2008

	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;

2009
	git_buf_dispose(&path);
Russell Belfer committed
2010 2011 2012
	return 0;
}

2013
/**
2014
 * Requests a snapshot of $WORK_TREE/.gitmodules.
2015
 *
2016
 * Returns GIT_ENOTFOUND in case no .gitmodules file exist
2017
 */
2018
static int gitmodules_snapshot(git_config **snap, git_repository *repo)
2019 2020
{
	const char *workdir = git_repository_workdir(repo);
2021
	git_config *mods = NULL;
2022
	git_buf path = GIT_BUF_INIT;
2023
	int error;
2024

2025 2026
	if (!workdir)
		return GIT_ENOTFOUND;
2027

2028 2029
	if ((error = git_buf_joinpath(&path, workdir, GIT_MODULES_FILE)) < 0)
		return error;
2030

2031 2032
	if ((error = git_config_open_ondisk(&mods, path.ptr)) < 0)
		goto cleanup;
2033
	git_buf_dispose(&path);
2034 2035 2036 2037 2038

	if ((error = git_config_snapshot(snap, mods)) < 0)
		goto cleanup;

	error = 0;
2039

2040 2041
cleanup:
	if (mods)
2042
		git_config_free(mods);
2043
	git_buf_dispose(&path);
2044

2045
	return error;
2046 2047
}

Ben Straub committed
2048
static git_config_backend *open_gitmodules(
2049
	git_repository *repo,
2050
	int okay_to_create)
Russell Belfer committed
2051
{
2052
	const char *workdir = git_repository_workdir(repo);
Russell Belfer committed
2053
	git_buf path = GIT_BUF_INIT;
Ben Straub committed
2054
	git_config_backend *mods = NULL;
Russell Belfer committed
2055 2056 2057 2058 2059 2060

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

		if (okay_to_create || git_path_isfile(path.ptr)) {
2061 2062
			/* git_config_backend_from_file should only fail if OOM */
			if (git_config_backend_from_file(&mods, path.ptr) < 0)
2063
				mods = NULL;
Russell Belfer committed
2064
			/* open should only fail here if the file is malformed */
2065 2066
			else if (git_config_backend_open(mods, GIT_CONFIG_LEVEL_LOCAL, repo) < 0) {
				git_config_backend_free(mods);
Russell Belfer committed
2067 2068
				mods = NULL;
			}
2069 2070 2071
		}
	}

2072
	git_buf_dispose(&path);
2073

Russell Belfer committed
2074 2075 2076
	return mods;
}

Russell Belfer committed
2077 2078
/* 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)
2079
{
Russell Belfer committed
2080
	int error;
Russell Belfer committed
2081 2082 2083 2084 2085 2086 2087
	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;

2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099
	/**
	 * 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
2100
	/* lookup remote tracking branch of HEAD */
2101 2102 2103 2104 2105
	if ((error = git_branch_upstream_name(
		&upstream_name,
		repo,
		git_reference_name(head))) < 0)
		goto done;
Russell Belfer committed
2106

2107 2108 2109
	/* lookup remote of remote tracking branch */
	if ((error = git_branch_remote_name(remote_name, repo, upstream_name.ptr)) < 0)
		goto done;
Russell Belfer committed
2110

2111
done:
2112
	git_buf_dispose(&upstream_name);
Russell Belfer committed
2113
	git_reference_free(head);
2114

2115 2116
	return error;
}
2117

Russell Belfer committed
2118 2119
/* Lookup the remote of the local tracking branch HEAD points to */
static int lookup_head_remote(git_remote **remote, git_repository *repo)
2120 2121
{
	int error;
Russell Belfer committed
2122
	git_buf remote_name = GIT_BUF_INIT;
2123

Russell Belfer committed
2124 2125
	/* lookup remote of remote tracking branch name */
	if (!(error = lookup_head_remote_key(&remote_name, repo)))
2126
		error = git_remote_lookup(remote, repo, remote_name.ptr);
2127

2128
	git_buf_dispose(&remote_name);
Russell Belfer committed
2129

2130 2131
	return error;
}
Russell Belfer committed
2132

Russell Belfer committed
2133 2134
/* Lookup remote, either from HEAD or fall back on origin */
static int lookup_default_remote(git_remote **remote, git_repository *repo)
2135
{
Russell Belfer committed
2136
	int error = lookup_head_remote(remote, repo);
Russell Belfer committed
2137

Russell Belfer committed
2138 2139
	/* if that failed, use 'origin' instead */
	if (error == GIT_ENOTFOUND)
2140
		error = git_remote_lookup(remote, repo, "origin");
Russell Belfer committed
2141

Russell Belfer committed
2142 2143 2144
	if (error == GIT_ENOTFOUND)
		giterr_set(
			GITERR_SUBMODULE,
2145
			"cannot get default remote for submodule - no local tracking "
Russell Belfer committed
2146
			"branch for HEAD and origin does not exist");
Russell Belfer committed
2147 2148

	return error;
2149 2150
}

Russell Belfer committed
2151
static int get_url_base(git_buf *url, git_repository *repo)
2152 2153
{
	int error;
2154
	git_worktree *wt = NULL;
Russell Belfer committed
2155
	git_remote *remote = NULL;
2156

2157
	if ((error = lookup_default_remote(&remote, repo)) == 0) {
Russell Belfer committed
2158
		error = git_buf_sets(url, git_remote_url(remote));
2159 2160 2161 2162
		goto out;
	} else if (error != GIT_ENOTFOUND)
		goto out;
	else
Russell Belfer committed
2163
		giterr_clear();
2164 2165 2166 2167 2168 2169 2170

	/* if repository does not have a default remote, use workdir instead */
	if (git_repository_is_worktree(repo)) {
		if ((error = git_worktree_open_from_repository(&wt, repo)) < 0)
			goto out;
		error = git_buf_sets(url, wt->parent_path);
	} else
Russell Belfer committed
2171
		error = git_buf_sets(url, git_repository_workdir(repo));
2172 2173 2174 2175

out:
	git_remote_free(remote);
	git_worktree_free(wt);
2176 2177 2178 2179

	return error;
}

2180
static void submodule_get_index_status(unsigned int *status, git_submodule *sm)
Russell Belfer committed
2181
{
2182 2183
	const git_oid *head_oid  = git_submodule_head_id(sm);
	const git_oid *index_oid = git_submodule_index_id(sm);
Russell Belfer committed
2184

2185 2186
	*status = *status & ~GIT_SUBMODULE_STATUS__INDEX_FLAGS;

2187 2188 2189 2190 2191 2192 2193 2194
	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
2195 2196
}

2197

2198 2199 2200 2201 2202
static void submodule_get_wd_status(
	unsigned int *status,
	git_submodule *sm,
	git_repository *sm_repo,
	git_submodule_ignore_t ign)
2203
{
2204 2205 2206 2207
	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;
2208
	git_index *index = NULL;
2209
	git_diff_options opt = GIT_DIFF_OPTIONS_INIT;
2210
	git_diff *diff;
2211

2212
	*status = *status & ~GIT_SUBMODULE_STATUS__WD_FLAGS;
Russell Belfer committed
2213

2214 2215 2216
	if (!index_oid) {
		if (wd_oid)
			*status |= GIT_SUBMODULE_STATUS_WD_ADDED;
Russell Belfer committed
2217
	}
2218 2219 2220 2221 2222 2223
	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
2224
	}
2225 2226
	else if (!git_oid_equal(index_oid, wd_oid))
		*status |= GIT_SUBMODULE_STATUS_WD_MODIFIED;
Russell Belfer committed
2227

2228 2229 2230
	/* if we have no repo, then we're done */
	if (!sm_repo)
		return;
2231

2232 2233 2234 2235
	/* 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).
	 */
2236

2237 2238
	if (ign == GIT_SUBMODULE_IGNORE_NONE)
		opt.flags |= GIT_DIFF_INCLUDE_UNTRACKED;
Russell Belfer committed
2239

2240 2241
	(void)git_repository_index__weakptr(&index, sm_repo);

2242
	/* if we don't have an unborn head, check diff with index */
2243 2244 2245 2246
	if (git_repository_head_tree(&sm_head, sm_repo) < 0)
		giterr_clear();
	else {
		/* perform head to index diff on submodule */
2247
		if (git_diff_tree_to_index(&diff, sm_repo, sm_head, index, &opt) < 0)
2248 2249
			giterr_clear();
		else {
2250
			if (git_diff_num_deltas(diff) > 0)
2251
				*status |= GIT_SUBMODULE_STATUS_WD_INDEX_MODIFIED;
2252
			git_diff_free(diff);
2253 2254
			diff = NULL;
		}
Russell Belfer committed
2255

2256
		git_tree_free(sm_head);
2257
	}
2258

2259
	/* perform index-to-workdir diff on submodule */
2260
	if (git_diff_index_to_workdir(&diff, sm_repo, index, &opt) < 0)
2261 2262 2263 2264
		giterr_clear();
	else {
		size_t untracked =
			git_diff_num_deltas_of_type(diff, GIT_DELTA_UNTRACKED);
2265

2266 2267
		if (untracked > 0)
			*status |= GIT_SUBMODULE_STATUS_WD_UNTRACKED;
2268

2269 2270
		if (git_diff_num_deltas(diff) != untracked)
			*status |= GIT_SUBMODULE_STATUS_WD_WD_MODIFIED;
Russell Belfer committed
2271

2272
		git_diff_free(diff);
2273
		diff = NULL;
2274
	}
2275
}