submodule.c 53.0 KB
Newer Older
1
#include "cache.h"
2
#include "repository.h"
3
#include "config.h"
4
#include "submodule-config.h"
5 6 7 8 9
#include "submodule.h"
#include "dir.h"
#include "diff.h"
#include "commit.h"
#include "revision.h"
10
#include "run-command.h"
11
#include "diffcore.h"
12
#include "refs.h"
13
#include "string-list.h"
14
#include "sha1-array.h"
15
#include "argv-array.h"
16
#include "blob.h"
17
#include "thread-utils.h"
18
#include "quote.h"
19
#include "remote.h"
20
#include "worktree.h"
21
#include "parse-options.h"
22

23
static int config_update_recurse_submodules = RECURSE_SUBMODULES_OFF;
24
static struct string_list changed_submodule_paths = STRING_LIST_INIT_DUP;
25
static int initialized_fetch_ref_tips;
26 27
static struct oid_array ref_tips_before_fetch;
static struct oid_array ref_tips_after_fetch;
28

29
/*
30 31 32
 * Check if the .gitmodules file is unmerged. Parsing of the .gitmodules file
 * will be disabled because we can't guess what might be configured in
 * .gitmodules unless the user resolves the conflict.
33
 */
34 35 36 37 38 39 40 41 42 43 44 45 46 47 48
int is_gitmodules_unmerged(const struct index_state *istate)
{
	int pos = index_name_pos(istate, GITMODULES_FILE, strlen(GITMODULES_FILE));
	if (pos < 0) { /* .gitmodules not found or isn't merged */
		pos = -1 - pos;
		if (istate->cache_nr > pos) {  /* there is a .gitmodules */
			const struct cache_entry *ce = istate->cache[pos];
			if (ce_namelen(ce) == strlen(GITMODULES_FILE) &&
			    !strcmp(ce->name, GITMODULES_FILE))
				return 1;
		}
	}

	return 0;
}
49

50
/*
51 52 53 54 55 56
 * Check if the .gitmodules file has unstaged modifications.  This must be
 * checked before allowing modifications to the .gitmodules file with the
 * intention to stage them later, because when continuing we would stage the
 * modifications the user didn't stage herself too. That might change in a
 * future version when we learn to stage the changes we do ourselves without
 * staging any previous modifications.
57
 */
58
int is_staging_gitmodules_ok(const struct index_state *istate)
59
{
60 61 62 63 64 65 66 67 68 69
	int pos = index_name_pos(istate, GITMODULES_FILE, strlen(GITMODULES_FILE));

	if ((pos >= 0) && (pos < istate->cache_nr)) {
		struct stat st;
		if (lstat(GITMODULES_FILE, &st) == 0 &&
		    ce_match_stat(istate->cache[pos], &st, 0) & DATA_CHANGED)
			return 0;
	}

	return 1;
70 71
}

72 73 74 75 76 77 78 79
/*
 * Try to update the "path" entry in the "submodule.<name>" section of the
 * .gitmodules file. Return 0 only if a .gitmodules file was found, a section
 * with the correct path=<oldpath> setting was found and we could update it.
 */
int update_path_in_gitmodules(const char *oldpath, const char *newpath)
{
	struct strbuf entry = STRBUF_INIT;
80
	const struct submodule *submodule;
81

82
	if (!file_exists(GITMODULES_FILE)) /* Do nothing without .gitmodules */
83 84
		return -1;

85
	if (is_gitmodules_unmerged(&the_index))
86 87
		die(_("Cannot change unmerged .gitmodules, resolve merge conflicts first"));

88
	submodule = submodule_from_path(&null_oid, oldpath);
89
	if (!submodule || !submodule->name) {
90 91 92 93
		warning(_("Could not find section in .gitmodules where path=%s"), oldpath);
		return -1;
	}
	strbuf_addstr(&entry, "submodule.");
94
	strbuf_addstr(&entry, submodule->name);
95
	strbuf_addstr(&entry, ".path");
96
	if (git_config_set_in_file_gently(GITMODULES_FILE, entry.buf, newpath) < 0) {
97 98 99 100 101 102 103 104 105
		/* Maybe the user already did that, don't error out here */
		warning(_("Could not update .gitmodules entry %s"), entry.buf);
		strbuf_release(&entry);
		return -1;
	}
	strbuf_release(&entry);
	return 0;
}

106 107 108 109 110 111 112 113
/*
 * Try to remove the "submodule.<name>" section from .gitmodules where the given
 * path is configured. Return 0 only if a .gitmodules file was found, a section
 * with the correct path=<path> setting was found and we could remove it.
 */
int remove_path_from_gitmodules(const char *path)
{
	struct strbuf sect = STRBUF_INIT;
114
	const struct submodule *submodule;
115

116
	if (!file_exists(GITMODULES_FILE)) /* Do nothing without .gitmodules */
117 118
		return -1;

119
	if (is_gitmodules_unmerged(&the_index))
120 121
		die(_("Cannot change unmerged .gitmodules, resolve merge conflicts first"));

122
	submodule = submodule_from_path(&null_oid, path);
123
	if (!submodule || !submodule->name) {
124 125 126 127
		warning(_("Could not find section in .gitmodules where path=%s"), path);
		return -1;
	}
	strbuf_addstr(&sect, "submodule.");
128
	strbuf_addstr(&sect, submodule->name);
129
	if (git_config_rename_section_in_file(GITMODULES_FILE, sect.buf, NULL) < 0) {
130 131 132 133 134 135 136 137 138
		/* Maybe the user already did that, don't error out here */
		warning(_("Could not remove .gitmodules entry for %s"), path);
		strbuf_release(&sect);
		return -1;
	}
	strbuf_release(&sect);
	return 0;
}

139 140
void stage_updated_gitmodules(void)
{
141
	if (add_file_to_cache(GITMODULES_FILE, 0))
142 143 144
		die(_("staging updated .gitmodules failed"));
}

145
static int add_submodule_odb(const char *path)
146 147
{
	struct strbuf objects_directory = STRBUF_INIT;
J
Jens Lehmann 已提交
148
	int ret = 0;
149

150 151 152
	ret = strbuf_git_path_submodule(&objects_directory, path, "objects/");
	if (ret)
		goto done;
J
Jens Lehmann 已提交
153 154 155 156
	if (!is_directory(objects_directory.buf)) {
		ret = -1;
		goto done;
	}
157
	add_to_alternates_memory(objects_directory.buf);
J
Jens Lehmann 已提交
158 159 160
done:
	strbuf_release(&objects_directory);
	return ret;
161 162
}

163 164 165
void set_diffopt_flags_from_submodule_config(struct diff_options *diffopt,
					     const char *path)
{
166
	const struct submodule *submodule = submodule_from_path(&null_oid, path);
167
	if (submodule) {
168 169
		const char *ignore;
		char *key;
170

171 172 173 174
		key = xstrfmt("submodule.%s.ignore", submodule->name);
		if (repo_config_get_string_const(the_repository, key, &ignore))
			ignore = submodule->ignore;
		free(key);
175

176 177
		if (ignore)
			handle_ignore_submodules_arg(diffopt, ignore);
178
		else if (is_gitmodules_unmerged(&the_index))
179
			DIFF_OPT_SET(diffopt, IGNORE_SUBMODULES);
180 181 182 183 184 185 186 187 188 189 190 191
	}
}

/* Cheap function that only determines if we're interested in submodules at all */
int git_default_submodule_config(const char *var, const char *value, void *cb)
{
	if (!strcmp(var, "submodule.recurse")) {
		int v = git_config_bool(var, value) ?
			RECURSE_SUBMODULES_ON : RECURSE_SUBMODULES_OFF;
		config_update_recurse_submodules = v;
	}
	return 0;
192 193
}

194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210
int option_parse_recurse_submodules_worktree_updater(const struct option *opt,
						     const char *arg, int unset)
{
	if (unset) {
		config_update_recurse_submodules = RECURSE_SUBMODULES_OFF;
		return 0;
	}
	if (arg)
		config_update_recurse_submodules =
			parse_update_recurse_submodules_arg(opt->long_name,
							    arg);
	else
		config_update_recurse_submodules = RECURSE_SUBMODULES_ON;

	return 0;
}

211 212 213
/*
 * Determine if a submodule has been initialized at a given 'path'
 */
214
int is_submodule_active(struct repository *repo, const char *path)
215 216
{
	int ret = 0;
217 218 219
	char *key = NULL;
	char *value = NULL;
	const struct string_list *sl;
220 221
	const struct submodule *module;

222
	module = submodule_from_cache(repo, &null_oid, path);
223

224 225 226
	/* early return if there isn't a path->module mapping */
	if (!module)
		return 0;
227

228 229
	/* submodule.<name>.active is set */
	key = xstrfmt("submodule.%s.active", module->name);
230
	if (!repo_config_get_bool(repo, key, &ret)) {
231 232 233 234
		free(key);
		return ret;
	}
	free(key);
235

236
	/* submodule.active is set */
237
	sl = repo_config_get_value_multi(repo, "submodule.active");
238 239 240 241
	if (sl) {
		struct pathspec ps;
		struct argv_array args = ARGV_ARRAY_INIT;
		const struct string_list_item *item;
242

243 244 245 246 247 248 249 250 251 252
		for_each_string_list_item(item, sl) {
			argv_array_push(&args, item->string);
		}

		parse_pathspec(&ps, 0, 0, NULL, args.argv);
		ret = match_pathspec(&ps, path, strlen(path), 0, NULL, 1);

		argv_array_clear(&args);
		clear_pathspec(&ps);
		return ret;
253 254
	}

255 256
	/* fallback to checking if the URL is set */
	key = xstrfmt("submodule.%s.url", module->name);
257
	ret = !repo_config_get_string(repo, key, &value);
258 259 260

	free(value);
	free(key);
261 262 263
	return ret;
}

264
int is_submodule_populated_gently(const char *path, int *return_error_code)
265 266 267 268
{
	int ret = 0;
	char *gitdir = xstrfmt("%s/.git", path);

269
	if (resolve_gitdir_gently(gitdir, return_error_code))
270 271 272 273 274 275
		ret = 1;

	free(gitdir);
	return ret;
}

276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305
/*
 * Dies if the provided 'prefix' corresponds to an unpopulated submodule
 */
void die_in_unpopulated_submodule(const struct index_state *istate,
				  const char *prefix)
{
	int i, prefixlen;

	if (!prefix)
		return;

	prefixlen = strlen(prefix);

	for (i = 0; i < istate->cache_nr; i++) {
		struct cache_entry *ce = istate->cache[i];
		int ce_len = ce_namelen(ce);

		if (!S_ISGITLINK(ce->ce_mode))
			continue;
		if (prefixlen <= ce_len)
			continue;
		if (strncmp(ce->name, prefix, ce_len))
			continue;
		if (prefix[ce_len] != '/')
			continue;

		die(_("in unpopulated submodule '%s'"), ce->name);
	}
}

306 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
/*
 * Dies if any paths in the provided pathspec descends into a submodule
 */
void die_path_inside_submodule(const struct index_state *istate,
			       const struct pathspec *ps)
{
	int i, j;

	for (i = 0; i < istate->cache_nr; i++) {
		struct cache_entry *ce = istate->cache[i];
		int ce_len = ce_namelen(ce);

		if (!S_ISGITLINK(ce->ce_mode))
			continue;

		for (j = 0; j < ps->nr ; j++) {
			const struct pathspec_item *item = &ps->items[j];

			if (item->len <= ce_len)
				continue;
			if (item->match[ce_len] != '/')
				continue;
			if (strncmp(ce->name, item->match, ce_len))
				continue;
			if (item->len == ce_len + 1)
				continue;

			die(_("Pathspec '%s' is in submodule '%.*s'"),
			    item->original, ce_len, ce->name);
		}
	}
}

339
enum submodule_update_type parse_submodule_update_type(const char *value)
340 341
{
	if (!strcmp(value, "none"))
342
		return SM_UPDATE_NONE;
343
	else if (!strcmp(value, "checkout"))
344
		return SM_UPDATE_CHECKOUT;
345
	else if (!strcmp(value, "rebase"))
346
		return SM_UPDATE_REBASE;
347
	else if (!strcmp(value, "merge"))
348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364
		return SM_UPDATE_MERGE;
	else if (*value == '!')
		return SM_UPDATE_COMMAND;
	else
		return SM_UPDATE_UNSPECIFIED;
}

int parse_submodule_update_strategy(const char *value,
		struct submodule_update_strategy *dst)
{
	enum submodule_update_type type;

	free((void*)dst->command);
	dst->command = NULL;

	type = parse_submodule_update_type(value);
	if (type == SM_UPDATE_UNSPECIFIED)
365
		return -1;
366 367 368 369 370

	dst->type = type;
	if (type == SM_UPDATE_COMMAND)
		dst->command = xstrdup(value + 1);

371 372 373
	return 0;
}

374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394
const char *submodule_strategy_to_string(const struct submodule_update_strategy *s)
{
	struct strbuf sb = STRBUF_INIT;
	switch (s->type) {
	case SM_UPDATE_CHECKOUT:
		return "checkout";
	case SM_UPDATE_MERGE:
		return "merge";
	case SM_UPDATE_REBASE:
		return "rebase";
	case SM_UPDATE_NONE:
		return "none";
	case SM_UPDATE_UNSPECIFIED:
		return NULL;
	case SM_UPDATE_COMMAND:
		strbuf_addf(&sb, "!%s", s->command);
		return strbuf_detach(&sb, NULL);
	}
	return NULL;
}

395 396 397
void handle_ignore_submodules_arg(struct diff_options *diffopt,
				  const char *arg)
{
398 399 400 401
	DIFF_OPT_CLR(diffopt, IGNORE_SUBMODULES);
	DIFF_OPT_CLR(diffopt, IGNORE_UNTRACKED_IN_SUBMODULES);
	DIFF_OPT_CLR(diffopt, IGNORE_DIRTY_SUBMODULES);

402 403 404 405 406 407
	if (!strcmp(arg, "all"))
		DIFF_OPT_SET(diffopt, IGNORE_SUBMODULES);
	else if (!strcmp(arg, "untracked"))
		DIFF_OPT_SET(diffopt, IGNORE_UNTRACKED_IN_SUBMODULES);
	else if (!strcmp(arg, "dirty"))
		DIFF_OPT_SET(diffopt, IGNORE_DIRTY_SUBMODULES);
408
	else if (strcmp(arg, "none"))
409 410 411
		die("bad --ignore-submodules argument: %s", arg);
}

412 413
static int prepare_submodule_summary(struct rev_info *rev, const char *path,
		struct commit *left, struct commit *right,
414
		struct commit_list *merge_bases)
415
{
416
	struct commit_list *list;
417 418 419 420 421 422 423 424 425 426 427

	init_revisions(rev, NULL);
	setup_revisions(0, NULL, rev, NULL);
	rev->left_right = 1;
	rev->first_parent_only = 1;
	left->object.flags |= SYMMETRIC_LEFT;
	add_pending_object(rev, &left->object, path);
	add_pending_object(rev, &right->object, path);
	for (list = merge_bases; list; list = list->next) {
		list->item->object.flags |= UNINTERESTING;
		add_pending_object(rev, &list->item->object,
428
			oid_to_hex(&list->item->object.oid));
429 430 431 432
	}
	return prepare_revision_walk(rev);
}

433
static void print_submodule_summary(struct rev_info *rev, struct diff_options *o)
434 435 436 437 438 439 440 441
{
	static const char format[] = "  %m %s";
	struct strbuf sb = STRBUF_INIT;
	struct commit *commit;

	while ((commit = get_revision(rev))) {
		struct pretty_print_context ctx = {0};
		ctx.date_mode = rev->date_mode;
442
		ctx.output_encoding = get_log_output_encoding();
443 444 445
		strbuf_setlen(&sb, 0);
		format_commit_message(commit, format, &sb, &ctx);
		strbuf_addch(&sb, '\n');
446 447 448 449
		if (commit->object.flags & SYMMETRIC_LEFT)
			diff_emit_submodule_del(o, sb.buf);
		else
			diff_emit_submodule_add(o, sb.buf);
450 451 452 453
	}
	strbuf_release(&sb);
}

454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470
static void prepare_submodule_repo_env_no_git_dir(struct argv_array *out)
{
	const char * const *var;

	for (var = local_repo_env; *var; var++) {
		if (strcmp(*var, CONFIG_DATA_ENVIRONMENT))
			argv_array_push(out, *var);
	}
}

void prepare_submodule_repo_env(struct argv_array *out)
{
	prepare_submodule_repo_env_no_git_dir(out);
	argv_array_pushf(out, "%s=%s", GIT_DIR_ENVIRONMENT,
			 DEFAULT_GIT_DIR_ENVIRONMENT);
}

471 472 473 474 475
/* Helper function to display the submodule header line prior to the full
 * summary output. If it can locate the submodule objects directory it will
 * attempt to lookup both the left and right commits and put them into the
 * left and right pointers.
 */
476
static void show_submodule_header(struct diff_options *o, const char *path,
477
		struct object_id *one, struct object_id *two,
478
		unsigned dirty_submodule,
479 480
		struct commit **left, struct commit **right,
		struct commit_list **merge_bases)
481 482 483 484 485
{
	const char *message = NULL;
	struct strbuf sb = STRBUF_INIT;
	int fast_forward = 0, fast_backward = 0;

486
	if (dirty_submodule & DIRTY_SUBMODULE_UNTRACKED)
487 488
		diff_emit_submodule_untracked(o, path);

489
	if (dirty_submodule & DIRTY_SUBMODULE_MODIFIED)
490
		diff_emit_submodule_modified(o, path);
491

492 493 494 495 496 497 498 499 500 501 502 503 504 505 506
	if (is_null_oid(one))
		message = "(new submodule)";
	else if (is_null_oid(two))
		message = "(submodule deleted)";

	if (add_submodule_odb(path)) {
		if (!message)
			message = "(not initialized)";
		goto output_header;
	}

	/*
	 * Attempt to lookup the commit references, and determine if this is
	 * a fast forward or fast backwards update.
	 */
507 508
	*left = lookup_commit_reference(one);
	*right = lookup_commit_reference(two);
509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525

	/*
	 * Warn about missing commits in the submodule project, but only if
	 * they aren't null.
	 */
	if ((!is_null_oid(one) && !*left) ||
	     (!is_null_oid(two) && !*right))
		message = "(commits not present)";

	*merge_bases = get_merge_bases(*left, *right);
	if (*merge_bases) {
		if ((*merge_bases)->item == *left)
			fast_forward = 1;
		else if ((*merge_bases)->item == *right)
			fast_backward = 1;
	}

526
	if (!oidcmp(one, two)) {
527 528 529 530
		strbuf_release(&sb);
		return;
	}

531
output_header:
532
	strbuf_addf(&sb, "Submodule %s ", path);
J
Junio C Hamano 已提交
533
	strbuf_add_unique_abbrev(&sb, one->hash, DEFAULT_ABBREV);
534
	strbuf_addstr(&sb, (fast_backward || fast_forward) ? ".." : "...");
J
Junio C Hamano 已提交
535
	strbuf_add_unique_abbrev(&sb, two->hash, DEFAULT_ABBREV);
536
	if (message)
537
		strbuf_addf(&sb, " %s\n", message);
538
	else
539 540
		strbuf_addf(&sb, "%s:\n", fast_backward ? " (rewind)" : "");
	diff_emit_submodule_header(o, sb.buf);
541 542 543

	strbuf_release(&sb);
}
544

545
void show_submodule_summary(struct diff_options *o, const char *path,
546
		struct object_id *one, struct object_id *two,
547
		unsigned dirty_submodule)
548 549 550 551 552
{
	struct rev_info rev;
	struct commit *left = NULL, *right = NULL;
	struct commit_list *merge_bases = NULL;

553 554
	show_submodule_header(o, path, one, two, dirty_submodule,
			      &left, &right, &merge_bases);
555 556 557 558 559 560 561 562 563 564 565

	/*
	 * If we don't have both a left and a right pointer, there is no
	 * reason to try and display a summary. The header line should contain
	 * all the information the user needs.
	 */
	if (!left || !right)
		goto out;

	/* Treat revision walker failure the same as missing commits */
	if (prepare_submodule_summary(&rev, path, left, right, merge_bases)) {
566
		diff_emit_submodule_error(o, "(revision walker failed)\n");
567 568 569
		goto out;
	}

570
	print_submodule_summary(&rev, o);
571 572 573 574 575 576 577 578

out:
	if (merge_bases)
		free_commit_list(merge_bases);
	clear_commit_marks(left, ~0);
	clear_commit_marks(right, ~0);
}

579
void show_submodule_inline_diff(struct diff_options *o, const char *path,
580
		struct object_id *one, struct object_id *two,
581
		unsigned dirty_submodule)
582 583 584 585 586
{
	const struct object_id *old = &empty_tree_oid, *new = &empty_tree_oid;
	struct commit *left = NULL, *right = NULL;
	struct commit_list *merge_bases = NULL;
	struct child_process cp = CHILD_PROCESS_INIT;
587
	struct strbuf sb = STRBUF_INIT;
588

589 590
	show_submodule_header(o, path, one, two, dirty_submodule,
			      &left, &right, &merge_bases);
591 592 593 594 595 596 597 598 599 600 601 602 603

	/* We need a valid left and right commit to display a difference */
	if (!(left || is_null_oid(one)) ||
	    !(right || is_null_oid(two)))
		goto done;

	if (left)
		old = one;
	if (right)
		new = two;

	cp.git_cmd = 1;
	cp.dir = path;
604
	cp.out = -1;
605 606 607
	cp.no_stdin = 1;

	/* TODO: other options may need to be passed here. */
608
	argv_array_pushl(&cp.args, "diff", "--submodule=diff", NULL);
609 610
	argv_array_pushf(&cp.args, "--color=%s", want_color(o->use_color) ?
			 "always" : "never");
611

612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632
	if (DIFF_OPT_TST(o, REVERSE_DIFF)) {
		argv_array_pushf(&cp.args, "--src-prefix=%s%s/",
				 o->b_prefix, path);
		argv_array_pushf(&cp.args, "--dst-prefix=%s%s/",
				 o->a_prefix, path);
	} else {
		argv_array_pushf(&cp.args, "--src-prefix=%s%s/",
				 o->a_prefix, path);
		argv_array_pushf(&cp.args, "--dst-prefix=%s%s/",
				 o->b_prefix, path);
	}
	argv_array_push(&cp.args, oid_to_hex(old));
	/*
	 * If the submodule has modified content, we will diff against the
	 * work tree, under the assumption that the user has asked for the
	 * diff format and wishes to actually see all differences even if they
	 * haven't yet been committed to the submodule yet.
	 */
	if (!(dirty_submodule & DIRTY_SUBMODULE_MODIFIED))
		argv_array_push(&cp.args, oid_to_hex(new));

633
	prepare_submodule_repo_env(&cp.env_array);
634 635 636 637 638 639 640 641
	if (start_command(&cp))
		diff_emit_submodule_error(o, "(diff failed)\n");

	while (strbuf_getwholeline_fd(&sb, cp.out, '\n') != EOF)
		diff_emit_submodule_pipethrough(o, sb.buf, sb.len);

	if (finish_command(&cp))
		diff_emit_submodule_error(o, "(diff failed)\n");
642 643

done:
644
	strbuf_release(&sb);
645 646 647 648 649 650 651 652
	if (merge_bases)
		free_commit_list(merge_bases);
	if (left)
		clear_commit_marks(left, ~0);
	if (right)
		clear_commit_marks(right, ~0);
}

653 654 655 656 657 658 659 660 661 662 663 664 665
int should_update_submodules(void)
{
	return config_update_recurse_submodules == RECURSE_SUBMODULES_ON;
}

const struct submodule *submodule_from_ce(const struct cache_entry *ce)
{
	if (!S_ISGITLINK(ce->ce_mode))
		return NULL;

	if (!should_update_submodules())
		return NULL;

666
	return submodule_from_path(&null_oid, ce->name);
667 668
}

669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756
static struct oid_array *submodule_commits(struct string_list *submodules,
					   const char *path)
{
	struct string_list_item *item;

	item = string_list_insert(submodules, path);
	if (item->util)
		return (struct oid_array *) item->util;

	/* NEEDSWORK: should we have oid_array_init()? */
	item->util = xcalloc(1, sizeof(struct oid_array));
	return (struct oid_array *) item->util;
}

static void collect_changed_submodules_cb(struct diff_queue_struct *q,
					  struct diff_options *options,
					  void *data)
{
	int i;
	struct string_list *changed = data;

	for (i = 0; i < q->nr; i++) {
		struct diff_filepair *p = q->queue[i];
		struct oid_array *commits;
		if (!S_ISGITLINK(p->two->mode))
			continue;

		if (S_ISGITLINK(p->one->mode)) {
			/*
			 * NEEDSWORK: We should honor the name configured in
			 * the .gitmodules file of the commit we are examining
			 * here to be able to correctly follow submodules
			 * being moved around.
			 */
			commits = submodule_commits(changed, p->two->path);
			oid_array_append(commits, &p->two->oid);
		} else {
			/* Submodule is new or was moved here */
			/*
			 * NEEDSWORK: When the .git directories of submodules
			 * live inside the superprojects .git directory some
			 * day we should fetch new submodules directly into
			 * that location too when config or options request
			 * that so they can be checked out from there.
			 */
			continue;
		}
	}
}

/*
 * Collect the paths of submodules in 'changed' which have changed based on
 * the revisions as specified in 'argv'.  Each entry in 'changed' will also
 * have a corresponding 'struct oid_array' (in the 'util' field) which lists
 * what the submodule pointers were updated to during the change.
 */
static void collect_changed_submodules(struct string_list *changed,
				       struct argv_array *argv)
{
	struct rev_info rev;
	const struct commit *commit;

	init_revisions(&rev, NULL);
	setup_revisions(argv->argc, argv->argv, &rev, NULL);
	if (prepare_revision_walk(&rev))
		die("revision walk setup failed");

	while ((commit = get_revision(&rev))) {
		struct rev_info diff_rev;

		init_revisions(&diff_rev, NULL);
		diff_rev.diffopt.output_format |= DIFF_FORMAT_CALLBACK;
		diff_rev.diffopt.format_callback = collect_changed_submodules_cb;
		diff_rev.diffopt.format_callback_data = changed;
		diff_tree_combined_merge(commit, 1, &diff_rev);
	}

	reset_revision_walk();
}

static void free_submodules_oids(struct string_list *submodules)
{
	struct string_list_item *item;
	for_each_string_list_item(item, submodules)
		oid_array_clear((struct oid_array *) item->util);
	string_list_clear(submodules, 1);
}

757 758
static int has_remote(const char *refname, const struct object_id *oid,
		      int flags, void *cb_data)
759 760 761 762
{
	return 1;
}

763
static int append_oid_to_argv(const struct object_id *oid, void *data)
764
{
765
	struct argv_array *argv = data;
766
	argv_array_push(argv, oid_to_hex(oid));
767 768 769
	return 0;
}

770
static int check_has_commit(const struct object_id *oid, void *data)
771
{
772 773
	int *has_commit = data;

774
	if (!lookup_commit_reference(oid))
775 776 777 778 779
		*has_commit = 0;

	return 0;
}

780
static int submodule_has_commits(const char *path, struct oid_array *commits)
781 782 783
{
	int has_commit = 1;

784
	/*
V
Ville Skyttä 已提交
785
	 * Perform a cheap, but incorrect check for the existence of 'commits'.
786
	 * This is done by adding the submodule's object store to the in-core
V
Ville Skyttä 已提交
787
	 * object store, and then querying for each commit's existence.  If we
788 789 790 791 792
	 * do not have the commit object anywhere, there is no chance we have
	 * it in the object store of the correct submodule and have it
	 * reachable from a ref, so we can fail early without spawning rev-list
	 * which is expensive.
	 */
793 794 795
	if (add_submodule_odb(path))
		return 0;

796
	oid_array_for_each_unique(commits, check_has_commit, &has_commit);
797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821

	if (has_commit) {
		/*
		 * Even if the submodule is checked out and the commit is
		 * present, make sure it exists in the submodule's object store
		 * and that it is reachable from a ref.
		 */
		struct child_process cp = CHILD_PROCESS_INIT;
		struct strbuf out = STRBUF_INIT;

		argv_array_pushl(&cp.args, "rev-list", "-n", "1", NULL);
		oid_array_for_each_unique(commits, append_oid_to_argv, &cp.args);
		argv_array_pushl(&cp.args, "--not", "--all", NULL);

		prepare_submodule_repo_env(&cp.env_array);
		cp.git_cmd = 1;
		cp.no_stdin = 1;
		cp.dir = path;

		if (capture_command(&cp, &out, GIT_MAX_HEXSZ + 1) || out.len)
			has_commit = 0;

		strbuf_release(&out);
	}

822 823 824
	return has_commit;
}

825
static int submodule_needs_pushing(const char *path, struct oid_array *commits)
826 827
{
	if (!submodule_has_commits(path, commits))
828 829 830 831 832 833 834 835 836 837 838
		/*
		 * NOTE: We do consider it safe to return "no" here. The
		 * correct answer would be "We do not know" instead of
		 * "No push needed", but it is quite hard to change
		 * the submodule pointer without having the submodule
		 * around. If a user did however change the submodules
		 * without having the submodule around, this indicates
		 * an expert who knows what they are doing or a
		 * maintainer integrating work from other people. In
		 * both cases it should be safe to skip this check.
		 */
839 840 841
		return 0;

	if (for_each_remote_ref_submodule(path, has_remote, NULL) > 0) {
842
		struct child_process cp = CHILD_PROCESS_INIT;
843 844 845
		struct strbuf buf = STRBUF_INIT;
		int needs_pushing = 0;

846
		argv_array_push(&cp.args, "rev-list");
847
		oid_array_for_each_unique(commits, append_oid_to_argv, &cp.args);
848 849
		argv_array_pushl(&cp.args, "--not", "--remotes", "-n", "1" , NULL);

850
		prepare_submodule_repo_env(&cp.env_array);
851 852 853 854 855
		cp.git_cmd = 1;
		cp.no_stdin = 1;
		cp.out = -1;
		cp.dir = path;
		if (start_command(&cp))
856 857
			die("Could not run 'git rev-list <commits> --not --remotes -n 1' command in submodule %s",
					path);
858 859 860 861 862 863 864 865 866 867 868
		if (strbuf_read(&buf, cp.out, 41))
			needs_pushing = 1;
		finish_command(&cp);
		close(cp.out);
		strbuf_release(&buf);
		return needs_pushing;
	}

	return 0;
}

869
int find_unpushed_submodules(struct oid_array *commits,
870
		const char *remotes_name, struct string_list *needs_pushing)
871
{
872 873
	struct string_list submodules = STRING_LIST_INIT_DUP;
	struct string_list_item *submodule;
874
	struct argv_array argv = ARGV_ARRAY_INIT;
875

876 877
	/* argv.argv[0] will be ignored by setup_revisions */
	argv_array_push(&argv, "find_unpushed_submodules");
878
	oid_array_for_each_unique(commits, append_oid_to_argv, &argv);
879 880 881
	argv_array_push(&argv, "--not");
	argv_array_pushf(&argv, "--remotes=%s", remotes_name);

882
	collect_changed_submodules(&submodules, &argv);
883

884
	for_each_string_list_item(submodule, &submodules) {
885 886
		struct oid_array *commits = submodule->util;
		const char *path = submodule->string;
887

888 889
		if (submodule_needs_pushing(path, commits))
			string_list_insert(needs_pushing, path);
890
	}
891 892

	free_submodules_oids(&submodules);
893
	argv_array_clear(&argv);
894

895
	return needs_pushing->nr;
896 897
}

898
static int push_submodule(const char *path,
899 900
			  const struct remote *remote,
			  const char **refspec, int refspec_nr,
901 902
			  const struct string_list *push_options,
			  int dry_run)
903 904 905 906 907
{
	if (add_submodule_odb(path))
		return 1;

	if (for_each_remote_ref_submodule(path, has_remote, NULL) > 0) {
908
		struct child_process cp = CHILD_PROCESS_INIT;
909 910 911
		argv_array_push(&cp.args, "push");
		if (dry_run)
			argv_array_push(&cp.args, "--dry-run");
912

913 914 915 916 917 918
		if (push_options && push_options->nr) {
			const struct string_list_item *item;
			for_each_string_list_item(item, push_options)
				argv_array_pushf(&cp.args, "--push-option=%s",
						 item->string);
		}
919 920 921 922 923 924 925 926

		if (remote->origin != REMOTE_UNCONFIGURED) {
			int i;
			argv_array_push(&cp.args, remote->name);
			for (i = 0; i < refspec_nr; i++)
				argv_array_push(&cp.args, refspec[i]);
		}

927
		prepare_submodule_repo_env(&cp.env_array);
928 929 930 931 932 933 934 935 936 937 938
		cp.git_cmd = 1;
		cp.no_stdin = 1;
		cp.dir = path;
		if (run_command(&cp))
			return 0;
		close(cp.out);
	}

	return 1;
}

939 940 941 942
/*
 * Perform a check in the submodule to see if the remote and refspec work.
 * Die if the submodule can't be pushed.
 */
943 944
static void submodule_push_check(const char *path, const char *head,
				 const struct remote *remote,
945 946 947 948 949 950 951
				 const char **refspec, int refspec_nr)
{
	struct child_process cp = CHILD_PROCESS_INIT;
	int i;

	argv_array_push(&cp.args, "submodule--helper");
	argv_array_push(&cp.args, "push-check");
952
	argv_array_push(&cp.args, head);
953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972
	argv_array_push(&cp.args, remote->name);

	for (i = 0; i < refspec_nr; i++)
		argv_array_push(&cp.args, refspec[i]);

	prepare_submodule_repo_env(&cp.env_array);
	cp.git_cmd = 1;
	cp.no_stdin = 1;
	cp.no_stdout = 1;
	cp.dir = path;

	/*
	 * Simply indicate if 'submodule--helper push-check' failed.
	 * More detailed error information will be provided by the
	 * child process.
	 */
	if (run_command(&cp))
		die("process for submodule '%s' failed", path);
}

973
int push_unpushed_submodules(struct oid_array *commits,
974 975
			     const struct remote *remote,
			     const char **refspec, int refspec_nr,
976
			     const struct string_list *push_options,
977
			     int dry_run)
978 979
{
	int i, ret = 1;
980
	struct string_list needs_pushing = STRING_LIST_INIT_DUP;
981

982
	if (!find_unpushed_submodules(commits, remote->name, &needs_pushing))
983 984
		return 1;

985 986 987 988 989 990
	/*
	 * Verify that the remote and refspec can be propagated to all
	 * submodules.  This check can be skipped if the remote and refspec
	 * won't be propagated due to the remote being unconfigured (e.g. a URL
	 * instead of a remote name).
	 */
991 992 993 994 995 996 997 998
	if (remote->origin != REMOTE_UNCONFIGURED) {
		char *head;
		struct object_id head_oid;

		head = resolve_refdup("HEAD", 0, head_oid.hash, NULL);
		if (!head)
			die(_("Failed to resolve HEAD as a valid ref."));

999 1000
		for (i = 0; i < needs_pushing.nr; i++)
			submodule_push_check(needs_pushing.items[i].string,
1001 1002 1003 1004
					     head, remote,
					     refspec, refspec_nr);
		free(head);
	}
1005 1006

	/* Actually push the submodules */
1007 1008 1009
	for (i = 0; i < needs_pushing.nr; i++) {
		const char *path = needs_pushing.items[i].string;
		fprintf(stderr, "Pushing submodule '%s'\n", path);
1010 1011
		if (!push_submodule(path, remote, refspec, refspec_nr,
				    push_options, dry_run)) {
1012 1013 1014 1015 1016 1017 1018 1019 1020 1021
			fprintf(stderr, "Unable to push submodule '%s'\n", path);
			ret = 0;
		}
	}

	string_list_clear(&needs_pushing, 0);

	return ret;
}

1022 1023
static int append_oid_to_array(const char *ref, const struct object_id *oid,
			       int flags, void *data)
1024
{
1025 1026
	struct oid_array *array = data;
	oid_array_append(array, oid);
1027 1028 1029
	return 0;
}

1030
void check_for_new_submodule_commits(struct object_id *oid)
1031 1032
{
	if (!initialized_fetch_ref_tips) {
1033
		for_each_ref(append_oid_to_array, &ref_tips_before_fetch);
1034 1035 1036
		initialized_fetch_ref_tips = 1;
	}

1037
	oid_array_append(&ref_tips_after_fetch, oid);
1038 1039 1040
}

static void calculate_changed_submodule_paths(void)
1041
{
1042
	struct argv_array argv = ARGV_ARRAY_INIT;
1043 1044
	struct string_list changed_submodules = STRING_LIST_INIT_DUP;
	const struct string_list_item *item;
1045

1046
	/* No need to check if there are no submodules configured */
1047
	if (!submodule_from_path(NULL, NULL))
1048 1049
		return;

1050
	argv_array_push(&argv, "--"); /* argv[0] program name */
1051
	oid_array_for_each_unique(&ref_tips_after_fetch,
1052
				   append_oid_to_argv, &argv);
1053
	argv_array_push(&argv, "--not");
1054
	oid_array_for_each_unique(&ref_tips_before_fetch,
1055
				   append_oid_to_argv, &argv);
1056 1057 1058 1059 1060

	/*
	 * Collect all submodules (whether checked out or not) for which new
	 * commits have been recorded upstream in "changed_submodule_paths".
	 */
1061 1062 1063 1064 1065 1066 1067 1068
	collect_changed_submodules(&changed_submodules, &argv);

	for_each_string_list_item(item, &changed_submodules) {
		struct oid_array *commits = item->util;
		const char *path = item->string;

		if (!submodule_has_commits(path, commits))
			string_list_append(&changed_submodule_paths, path);
1069
	}
1070

1071
	free_submodules_oids(&changed_submodules);
1072
	argv_array_clear(&argv);
1073 1074
	oid_array_clear(&ref_tips_before_fetch);
	oid_array_clear(&ref_tips_after_fetch);
1075
	initialized_fetch_ref_tips = 0;
1076 1077
}

1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102
int submodule_touches_in_range(struct object_id *excl_oid,
			       struct object_id *incl_oid)
{
	struct string_list subs = STRING_LIST_INIT_DUP;
	struct argv_array args = ARGV_ARRAY_INIT;
	int ret;

	/* No need to check if there are no submodules configured */
	if (!submodule_from_path(NULL, NULL))
		return 0;

	argv_array_push(&args, "--"); /* args[0] program name */
	argv_array_push(&args, oid_to_hex(incl_oid));
	argv_array_push(&args, "--not");
	argv_array_push(&args, oid_to_hex(excl_oid));

	collect_changed_submodules(&subs, &args);
	ret = subs.nr;

	argv_array_clear(&args);

	free_submodules_oids(&subs);
	return ret;
}

1103 1104 1105 1106 1107 1108
struct submodule_parallel_fetch {
	int count;
	struct argv_array args;
	const char *work_tree;
	const char *prefix;
	int command_line_option;
1109
	int default_option;
1110 1111 1112
	int quiet;
	int result;
};
1113
#define SPF_INIT {0, ARGV_ARRAY_INIT, NULL, NULL, 0, 0, 0, 0}
1114 1115 1116

static int get_next_submodule(struct child_process *cp,
			      struct strbuf *err, void *data, void **task_cb)
1117
{
1118 1119
	int ret = 0;
	struct submodule_parallel_fetch *spf = data;
1120

1121
	for (; spf->count < active_nr; spf->count++) {
1122 1123 1124
		struct strbuf submodule_path = STRBUF_INIT;
		struct strbuf submodule_git_dir = STRBUF_INIT;
		struct strbuf submodule_prefix = STRBUF_INIT;
1125
		const struct cache_entry *ce = active_cache[spf->count];
1126 1127
		const char *git_dir, *default_argv;
		const struct submodule *submodule;
1128 1129 1130 1131

		if (!S_ISGITLINK(ce->ce_mode))
			continue;

1132
		submodule = submodule_from_path(&null_oid, ce->name);
1133

1134
		default_argv = "yes";
1135
		if (spf->command_line_option == RECURSE_SUBMODULES_DEFAULT) {
1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151
			int fetch_recurse = RECURSE_SUBMODULES_NONE;

			if (submodule) {
				char *key;
				const char *value;

				fetch_recurse = submodule->fetch_recurse;
				key = xstrfmt("submodule.%s.fetchRecurseSubmodules", submodule->name);
				if (!repo_config_get_string_const(the_repository, key, &value)) {
					fetch_recurse = parse_fetch_recurse_submodules_arg(key, value);
				}
				free(key);
			}

			if (fetch_recurse != RECURSE_SUBMODULES_NONE) {
				if (fetch_recurse == RECURSE_SUBMODULES_OFF)
1152
					continue;
1153
				if (fetch_recurse == RECURSE_SUBMODULES_ON_DEMAND) {
1154 1155 1156 1157
					if (!unsorted_string_list_lookup(&changed_submodule_paths, ce->name))
						continue;
					default_argv = "on-demand";
				}
1158
			} else {
1159
				if (spf->default_option == RECURSE_SUBMODULES_OFF)
1160
					continue;
1161
				if (spf->default_option == RECURSE_SUBMODULES_ON_DEMAND) {
1162 1163 1164 1165
					if (!unsorted_string_list_lookup(&changed_submodule_paths, ce->name))
						continue;
					default_argv = "on-demand";
				}
1166
			}
1167
		} else if (spf->command_line_option == RECURSE_SUBMODULES_ON_DEMAND) {
1168 1169 1170
			if (!unsorted_string_list_lookup(&changed_submodule_paths, ce->name))
				continue;
			default_argv = "on-demand";
1171 1172
		}

1173
		strbuf_addf(&submodule_path, "%s/%s", spf->work_tree, ce->name);
1174
		strbuf_addf(&submodule_git_dir, "%s/.git", submodule_path.buf);
1175
		strbuf_addf(&submodule_prefix, "%s%s/", spf->prefix, ce->name);
1176
		git_dir = read_gitfile(submodule_git_dir.buf);
1177 1178 1179
		if (!git_dir)
			git_dir = submodule_git_dir.buf;
		if (is_directory(git_dir)) {
1180 1181
			child_process_init(cp);
			cp->dir = strbuf_detach(&submodule_path, NULL);
1182
			prepare_submodule_repo_env(&cp->env_array);
1183 1184 1185 1186 1187 1188 1189 1190 1191 1192
			cp->git_cmd = 1;
			if (!spf->quiet)
				strbuf_addf(err, "Fetching submodule %s%s\n",
					    spf->prefix, ce->name);
			argv_array_init(&cp->args);
			argv_array_pushv(&cp->args, spf->args.argv);
			argv_array_push(&cp->args, default_argv);
			argv_array_push(&cp->args, "--submodule-prefix");
			argv_array_push(&cp->args, submodule_prefix.buf);
			ret = 1;
1193 1194 1195 1196
		}
		strbuf_release(&submodule_path);
		strbuf_release(&submodule_git_dir);
		strbuf_release(&submodule_prefix);
1197 1198 1199 1200
		if (ret) {
			spf->count++;
			return 1;
		}
1201
	}
1202 1203 1204
	return 0;
}

1205
static int fetch_start_failure(struct strbuf *err,
1206 1207 1208 1209 1210 1211 1212 1213 1214
			       void *cb, void *task_cb)
{
	struct submodule_parallel_fetch *spf = cb;

	spf->result = 1;

	return 0;
}

1215 1216
static int fetch_finish(int retvalue, struct strbuf *err,
			void *cb, void *task_cb)
1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227
{
	struct submodule_parallel_fetch *spf = cb;

	if (retvalue)
		spf->result = 1;

	return 0;
}

int fetch_populated_submodules(const struct argv_array *options,
			       const char *prefix, int command_line_option,
1228
			       int default_option,
1229
			       int quiet, int max_parallel_jobs)
1230 1231 1232 1233 1234 1235
{
	int i;
	struct submodule_parallel_fetch spf = SPF_INIT;

	spf.work_tree = get_git_work_tree();
	spf.command_line_option = command_line_option;
1236
	spf.default_option = default_option;
1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259
	spf.quiet = quiet;
	spf.prefix = prefix;

	if (!spf.work_tree)
		goto out;

	if (read_cache() < 0)
		die("index file corrupt");

	argv_array_push(&spf.args, "fetch");
	for (i = 0; i < options->argc; i++)
		argv_array_push(&spf.args, options->argv[i]);
	argv_array_push(&spf.args, "--recurse-submodules-default");
	/* default value, "--submodule-prefix" and its value are added later */

	calculate_changed_submodule_paths();
	run_processes_parallel(max_parallel_jobs,
			       get_next_submodule,
			       fetch_start_failure,
			       fetch_finish,
			       &spf);

	argv_array_clear(&spf.args);
1260 1261
out:
	string_list_clear(&changed_submodule_paths, 1);
1262
	return spf.result;
1263 1264
}

1265
unsigned is_submodule_modified(const char *path, int ignore_untracked)
1266
{
1267
	struct child_process cp = CHILD_PROCESS_INIT;
1268
	struct strbuf buf = STRBUF_INIT;
1269
	FILE *fp;
1270
	unsigned dirty_submodule = 0;
1271
	const char *git_dir;
1272
	int ignore_cp_exit_code = 0;
1273

1274
	strbuf_addf(&buf, "%s/.git", path);
1275
	git_dir = read_gitfile(buf.buf);
1276 1277
	if (!git_dir)
		git_dir = buf.buf;
1278 1279 1280
	if (!is_git_directory(git_dir)) {
		if (is_directory(git_dir))
			die(_("'%s' not recognized as a git repository"), git_dir);
1281 1282 1283 1284 1285 1286
		strbuf_release(&buf);
		/* The submodule is not checked out, so it is not modified */
		return 0;
	}
	strbuf_reset(&buf);

1287
	argv_array_pushl(&cp.args, "status", "--porcelain=2", NULL);
1288
	if (ignore_untracked)
1289
		argv_array_push(&cp.args, "-uno");
1290

1291
	prepare_submodule_repo_env(&cp.env_array);
1292 1293 1294
	cp.git_cmd = 1;
	cp.no_stdin = 1;
	cp.out = -1;
1295
	cp.dir = path;
1296
	if (start_command(&cp))
1297
		die("Could not run 'git status --porcelain=2' in submodule %s", path);
1298

1299 1300
	fp = xfdopen(cp.out, "r");
	while (strbuf_getwholeline(&buf, fp, '\n') != EOF) {
1301 1302
		/* regular untracked files */
		if (buf.buf[0] == '?')
1303
			dirty_submodule |= DIRTY_SUBMODULE_UNTRACKED;
1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321

		if (buf.buf[0] == 'u' ||
		    buf.buf[0] == '1' ||
		    buf.buf[0] == '2') {
			/* T = line type, XY = status, SSSS = submodule state */
			if (buf.len < strlen("T XY SSSS"))
				die("BUG: invalid status --porcelain=2 line %s",
				    buf.buf);

			if (buf.buf[5] == 'S' && buf.buf[8] == 'U')
				/* nested untracked file */
				dirty_submodule |= DIRTY_SUBMODULE_UNTRACKED;

			if (buf.buf[0] == 'u' ||
			    buf.buf[0] == '2' ||
			    memcmp(buf.buf + 5, "S..U", 4))
				/* other change */
				dirty_submodule |= DIRTY_SUBMODULE_MODIFIED;
1322
		}
1323 1324 1325

		if ((dirty_submodule & DIRTY_SUBMODULE_MODIFIED) &&
		    ((dirty_submodule & DIRTY_SUBMODULE_UNTRACKED) ||
1326 1327 1328 1329 1330 1331
		     ignore_untracked)) {
			/*
			 * We're not interested in any further information from
			 * the child any more, neither output nor its exit code.
			 */
			ignore_cp_exit_code = 1;
1332
			break;
1333
		}
1334
	}
1335
	fclose(fp);
1336

1337
	if (finish_command(&cp) && !ignore_cp_exit_code)
1338
		die("'git status --porcelain=2' failed in submodule %s", path);
1339 1340

	strbuf_release(&buf);
1341
	return dirty_submodule;
1342
}
1343

1344 1345
int submodule_uses_gitfile(const char *path)
{
1346
	struct child_process cp = CHILD_PROCESS_INIT;
1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367
	const char *argv[] = {
		"submodule",
		"foreach",
		"--quiet",
		"--recursive",
		"test -f .git",
		NULL,
	};
	struct strbuf buf = STRBUF_INIT;
	const char *git_dir;

	strbuf_addf(&buf, "%s/.git", path);
	git_dir = read_gitfile(buf.buf);
	if (!git_dir) {
		strbuf_release(&buf);
		return 0;
	}
	strbuf_release(&buf);

	/* Now test that all nested submodules use a gitfile too */
	cp.argv = argv;
1368
	prepare_submodule_repo_env(&cp.env_array);
1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379
	cp.git_cmd = 1;
	cp.no_stdin = 1;
	cp.no_stderr = 1;
	cp.no_stdout = 1;
	cp.dir = path;
	if (run_command(&cp))
		return 0;

	return 1;
}

1380 1381 1382 1383 1384 1385 1386 1387
/*
 * Check if it is a bad idea to remove a submodule, i.e. if we'd lose data
 * when doing so.
 *
 * Return 1 if we'd lose data, return 0 if the removal is fine,
 * and negative values for errors.
 */
int bad_to_remove_submodule(const char *path, unsigned flags)
1388 1389
{
	ssize_t len;
1390
	struct child_process cp = CHILD_PROCESS_INIT;
1391
	struct strbuf buf = STRBUF_INIT;
1392
	int ret = 0;
1393

1394
	if (!file_exists(path) || is_empty_dir(path))
1395
		return 0;
1396 1397

	if (!submodule_uses_gitfile(path))
1398
		return 1;
1399

1400
	argv_array_pushl(&cp.args, "status", "--porcelain",
1401
				   "--ignore-submodules=none", NULL);
1402 1403 1404 1405 1406 1407 1408 1409

	if (flags & SUBMODULE_REMOVAL_IGNORE_UNTRACKED)
		argv_array_push(&cp.args, "-uno");
	else
		argv_array_push(&cp.args, "-uall");

	if (!(flags & SUBMODULE_REMOVAL_IGNORE_IGNORED_UNTRACKED))
		argv_array_push(&cp.args, "--ignored");
1410

1411
	prepare_submodule_repo_env(&cp.env_array);
1412 1413 1414 1415
	cp.git_cmd = 1;
	cp.no_stdin = 1;
	cp.out = -1;
	cp.dir = path;
1416 1417
	if (start_command(&cp)) {
		if (flags & SUBMODULE_REMOVAL_DIE_ON_ERROR)
1418
			die(_("could not start 'git status' in submodule '%s'"),
1419 1420 1421 1422
				path);
		ret = -1;
		goto out;
	}
1423 1424 1425

	len = strbuf_read(&buf, cp.out, 1024);
	if (len > 2)
1426
		ret = 1;
1427 1428
	close(cp.out);

1429 1430
	if (finish_command(&cp)) {
		if (flags & SUBMODULE_REMOVAL_DIE_ON_ERROR)
1431
			die(_("could not run 'git status' in submodule '%s'"),
1432 1433 1434 1435
				path);
		ret = -1;
	}
out:
1436
	strbuf_release(&buf);
1437
	return ret;
1438 1439
}

1440 1441 1442 1443 1444 1445 1446 1447
static const char *get_super_prefix_or_empty(void)
{
	const char *s = get_super_prefix();
	if (!s)
		s = "";
	return s;
}

1448 1449 1450 1451
static int submodule_has_dirty_index(const struct submodule *sub)
{
	struct child_process cp = CHILD_PROCESS_INIT;

1452
	prepare_submodule_repo_env(&cp.env_array);
1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468

	cp.git_cmd = 1;
	argv_array_pushl(&cp.args, "diff-index", "--quiet",
				   "--cached", "HEAD", NULL);
	cp.no_stdin = 1;
	cp.no_stdout = 1;
	cp.dir = sub->path;
	if (start_command(&cp))
		die("could not recurse into submodule '%s'", sub->path);

	return finish_command(&cp);
}

static void submodule_reset_index(const char *path)
{
	struct child_process cp = CHILD_PROCESS_INIT;
1469
	prepare_submodule_repo_env(&cp.env_array);
1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497

	cp.git_cmd = 1;
	cp.no_stdin = 1;
	cp.dir = path;

	argv_array_pushf(&cp.args, "--super-prefix=%s%s/",
				   get_super_prefix_or_empty(), path);
	argv_array_pushl(&cp.args, "read-tree", "-u", "--reset", NULL);

	argv_array_push(&cp.args, EMPTY_TREE_SHA1_HEX);

	if (run_command(&cp))
		die("could not reset submodule index");
}

/**
 * Moves a submodule at a given path from a given head to another new head.
 * For edge cases (a submodule coming into existence or removing a submodule)
 * pass NULL for old or new respectively.
 */
int submodule_move_head(const char *path,
			 const char *old,
			 const char *new,
			 unsigned flags)
{
	int ret = 0;
	struct child_process cp = CHILD_PROCESS_INIT;
	const struct submodule *sub;
1498
	int *error_code_ptr, error_code;
1499

1500
	if (!is_submodule_active(the_repository, path))
1501 1502
		return 0;

1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514
	if (flags & SUBMODULE_MOVE_HEAD_FORCE)
		/*
		 * Pass non NULL pointer to is_submodule_populated_gently
		 * to prevent die()-ing. We'll use connect_work_tree_and_git_dir
		 * to fixup the submodule in the force case later.
		 */
		error_code_ptr = &error_code;
	else
		error_code_ptr = NULL;

	if (old && !is_submodule_populated_gently(path, error_code_ptr))
		return 0;
1515

1516
	sub = submodule_from_path(&null_oid, path);
1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532

	if (!sub)
		die("BUG: could not get submodule information for '%s'", path);

	if (old && !(flags & SUBMODULE_MOVE_HEAD_FORCE)) {
		/* Check if the submodule has a dirty index. */
		if (submodule_has_dirty_index(sub))
			return error(_("submodule '%s' has dirty index"), path);
	}

	if (!(flags & SUBMODULE_MOVE_HEAD_DRY_RUN)) {
		if (old) {
			if (!submodule_uses_gitfile(path))
				absorb_git_dir_into_superproject("", path,
					ABSORB_GITDIR_RECURSE_SUBMODULES);
		} else {
1533
			char *gitdir = xstrfmt("%s/modules/%s",
1534
				    get_git_common_dir(), sub->name);
1535 1536
			connect_work_tree_and_git_dir(path, gitdir);
			free(gitdir);
1537 1538 1539 1540

			/* make sure the index is clean as well */
			submodule_reset_index(path);
		}
1541 1542 1543 1544 1545 1546 1547

		if (old && (flags & SUBMODULE_MOVE_HEAD_FORCE)) {
			char *gitdir = xstrfmt("%s/modules/%s",
				    get_git_common_dir(), sub->name);
			connect_work_tree_and_git_dir(path, gitdir);
			free(gitdir);
		}
1548 1549
	}

1550
	prepare_submodule_repo_env(&cp.env_array);
1551 1552 1553 1554 1555 1556 1557

	cp.git_cmd = 1;
	cp.no_stdin = 1;
	cp.dir = path;

	argv_array_pushf(&cp.args, "--super-prefix=%s%s/",
			get_super_prefix_or_empty(), path);
1558
	argv_array_pushl(&cp.args, "read-tree", "--recurse-submodules", NULL);
1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579

	if (flags & SUBMODULE_MOVE_HEAD_DRY_RUN)
		argv_array_push(&cp.args, "-n");
	else
		argv_array_push(&cp.args, "-u");

	if (flags & SUBMODULE_MOVE_HEAD_FORCE)
		argv_array_push(&cp.args, "--reset");
	else
		argv_array_push(&cp.args, "-m");

	argv_array_push(&cp.args, old ? old : EMPTY_TREE_SHA1_HEX);
	argv_array_push(&cp.args, new ? new : EMPTY_TREE_SHA1_HEX);

	if (run_command(&cp)) {
		ret = -1;
		goto out;
	}

	if (!(flags & SUBMODULE_MOVE_HEAD_DRY_RUN)) {
		if (new) {
1580
			child_process_init(&cp);
1581
			/* also set the HEAD accordingly */
1582 1583 1584
			cp.git_cmd = 1;
			cp.no_stdin = 1;
			cp.dir = path;
1585

1586
			prepare_submodule_repo_env(&cp.env_array);
1587
			argv_array_pushl(&cp.args, "update-ref", "HEAD", new, NULL);
1588

1589
			if (run_command(&cp)) {
1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607
				ret = -1;
				goto out;
			}
		} else {
			struct strbuf sb = STRBUF_INIT;

			strbuf_addf(&sb, "%s/.git", path);
			unlink_or_warn(sb.buf);
			strbuf_release(&sb);

			if (is_empty_dir(path))
				rmdir_or_warn(path);
		}
	}
out:
	return ret;
}

1608 1609 1610 1611
static int find_first_merges(struct object_array *result, const char *path,
		struct commit *a, struct commit *b)
{
	int i, j;
1612
	struct object_array merges = OBJECT_ARRAY_INIT;
1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625
	struct commit *commit;
	int contains_another;

	char merged_revision[42];
	const char *rev_args[] = { "rev-list", "--merges", "--ancestry-path",
				   "--all", merged_revision, NULL };
	struct rev_info revs;
	struct setup_revision_opt rev_opts;

	memset(result, 0, sizeof(struct object_array));
	memset(&rev_opts, 0, sizeof(rev_opts));

	/* get all revisions that merge commit a */
1626
	xsnprintf(merged_revision, sizeof(merged_revision), "^%s",
1627
			oid_to_hex(&a->object.oid));
1628 1629
	init_revisions(&revs, NULL);
	rev_opts.submodule = path;
1630
	setup_revisions(ARRAY_SIZE(rev_args)-1, rev_args, &revs, &rev_opts);
1631 1632 1633 1634 1635 1636

	/* save all revisions from the above list that contain b */
	if (prepare_revision_walk(&revs))
		die("revision walk setup failed");
	while ((commit = get_revision(&revs)) != NULL) {
		struct object *o = &(commit->object);
1637
		if (in_merge_bases(b, commit))
1638 1639
			add_object_array(o, NULL, &merges);
	}
1640
	reset_revision_walk();
1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651

	/* Now we've got all merges that contain a and b. Prune all
	 * merges that contain another found merge and save them in
	 * result.
	 */
	for (i = 0; i < merges.nr; i++) {
		struct commit *m1 = (struct commit *) merges.objects[i].item;

		contains_another = 0;
		for (j = 0; j < merges.nr; j++) {
			struct commit *m2 = (struct commit *) merges.objects[j].item;
1652
			if (i != j && in_merge_bases(m2, m1)) {
1653 1654 1655 1656 1657 1658
				contains_another = 1;
				break;
			}
		}

		if (!contains_another)
1659
			add_object_array(merges.objects[i].item, NULL, result);
1660 1661 1662 1663 1664 1665 1666 1667 1668 1669
	}

	free(merges.objects);
	return result->nr;
}

static void print_commit(struct commit *commit)
{
	struct strbuf sb = STRBUF_INIT;
	struct pretty_print_context ctx = {0};
1670
	ctx.date_mode.type = DATE_NORMAL;
1671 1672 1673 1674 1675 1676 1677 1678
	format_commit_message(commit, " %h: %m %s", &sb, &ctx);
	fprintf(stderr, "%s\n", sb.buf);
	strbuf_release(&sb);
}

#define MERGE_WARNING(path, msg) \
	warning("Failed to merge submodule %s (%s)", path, msg);

1679 1680 1681
int merge_submodule(struct object_id *result, const char *path,
		    const struct object_id *base, const struct object_id *a,
		    const struct object_id *b, int search)
1682 1683 1684 1685 1686 1687 1688 1689
{
	struct commit *commit_base, *commit_a, *commit_b;
	int parent_count;
	struct object_array merges;

	int i;

	/* store a in result in case we fail */
1690
	oidcpy(result, a);
1691 1692

	/* we can not handle deletion conflicts */
1693
	if (is_null_oid(base))
1694
		return 0;
1695
	if (is_null_oid(a))
1696
		return 0;
1697
	if (is_null_oid(b))
1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712
		return 0;

	if (add_submodule_odb(path)) {
		MERGE_WARNING(path, "not checked out");
		return 0;
	}

	if (!(commit_base = lookup_commit_reference(base)) ||
	    !(commit_a = lookup_commit_reference(a)) ||
	    !(commit_b = lookup_commit_reference(b))) {
		MERGE_WARNING(path, "commits not present");
		return 0;
	}

	/* check whether both changes are forward */
1713 1714
	if (!in_merge_bases(commit_base, commit_a) ||
	    !in_merge_bases(commit_base, commit_b)) {
1715 1716 1717 1718 1719
		MERGE_WARNING(path, "commits don't follow merge-base");
		return 0;
	}

	/* Case #1: a is contained in b or vice versa */
1720
	if (in_merge_bases(commit_a, commit_b)) {
1721
		oidcpy(result, b);
1722 1723
		return 1;
	}
1724
	if (in_merge_bases(commit_b, commit_a)) {
1725
		oidcpy(result, a);
1726 1727 1728 1729 1730 1731 1732 1733 1734 1735
		return 1;
	}

	/*
	 * Case #2: There are one or more merges that contain a and b in
	 * the submodule. If there is only one, then present it as a
	 * suggestion to the user, but leave it marked unmerged so the
	 * user needs to confirm the resolution.
	 */

1736 1737 1738 1739
	/* Skip the search if makes no sense to the calling context.  */
	if (!search)
		return 0;

1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757
	/* find commit which merges them */
	parent_count = find_first_merges(&merges, path, commit_a, commit_b);
	switch (parent_count) {
	case 0:
		MERGE_WARNING(path, "merge following commits not found");
		break;

	case 1:
		MERGE_WARNING(path, "not fast-forward");
		fprintf(stderr, "Found a possible merge resolution "
				"for the submodule:\n");
		print_commit((struct commit *) merges.objects[0].item);
		fprintf(stderr,
			"If this is correct simply add it to the index "
			"for example\n"
			"by using:\n\n"
			"  git update-index --cacheinfo 160000 %s \"%s\"\n\n"
			"which will accept this suggestion.\n",
1758
			oid_to_hex(&merges.objects[0].item->oid), path);
1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769
		break;

	default:
		MERGE_WARNING(path, "multiple merges found");
		for (i = 0; i < merges.nr; i++)
			print_commit((struct commit *) merges.objects[i].item);
	}

	free(merges.objects);
	return 0;
}
1770

1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790
/*
 * Embeds a single submodules git directory into the superprojects git dir,
 * non recursively.
 */
static void relocate_single_git_dir_into_superproject(const char *prefix,
						      const char *path)
{
	char *old_git_dir = NULL, *real_old_git_dir = NULL, *real_new_git_dir = NULL;
	const char *new_git_dir;
	const struct submodule *sub;

	if (submodule_uses_worktrees(path))
		die(_("relocate_gitdir for submodule '%s' with "
		      "more than one worktree not supported"), path);

	old_git_dir = xstrfmt("%s/.git", path);
	if (read_gitfile(old_git_dir))
		/* If it is an actual gitfile, it doesn't need migration. */
		return;

1791
	real_old_git_dir = real_pathdup(old_git_dir, 1);
1792

1793
	sub = submodule_from_path(&null_oid, path);
1794 1795 1796 1797 1798 1799
	if (!sub)
		die(_("could not lookup name for submodule '%s'"), path);

	new_git_dir = git_path("modules/%s", sub->name);
	if (safe_create_leading_directories_const(new_git_dir) < 0)
		die(_("could not create directory '%s'"), new_git_dir);
1800
	real_new_git_dir = real_pathdup(new_git_dir, 1);
1801 1802

	fprintf(stderr, _("Migrating git directory of '%s%s' from\n'%s' to\n'%s'\n"),
1803
		get_super_prefix_or_empty(), path,
1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821
		real_old_git_dir, real_new_git_dir);

	relocate_gitdir(path, real_old_git_dir, real_new_git_dir);

	free(old_git_dir);
	free(real_old_git_dir);
	free(real_new_git_dir);
}

/*
 * Migrate the git directory of the submodule given by path from
 * having its git directory within the working tree to the git dir nested
 * in its superprojects git dir under modules/.
 */
void absorb_git_dir_into_superproject(const char *prefix,
				      const char *path,
				      unsigned flags)
{
1822 1823
	int err_code;
	const char *sub_git_dir;
1824 1825
	struct strbuf gitdir = STRBUF_INIT;
	strbuf_addf(&gitdir, "%s/.git", path);
1826
	sub_git_dir = resolve_gitdir_gently(gitdir.buf, &err_code);
1827 1828

	/* Not populated? */
1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848
	if (!sub_git_dir) {
		const struct submodule *sub;

		if (err_code == READ_GITFILE_ERR_STAT_FAILED) {
			/* unpopulated as expected */
			strbuf_release(&gitdir);
			return;
		}

		if (err_code != READ_GITFILE_ERR_NOT_A_REPO)
			/* We don't know what broke here. */
			read_gitfile_error_die(err_code, path, NULL);

		/*
		* Maybe populated, but no git directory was found?
		* This can happen if the superproject is a submodule
		* itself and was just absorbed. The absorption of the
		* superproject did not rewrite the git file links yet,
		* fix it now.
		*/
1849
		sub = submodule_from_path(&null_oid, path);
1850 1851
		if (!sub)
			die(_("could not lookup name for submodule '%s'"), path);
1852 1853
		connect_work_tree_and_git_dir(path,
			git_path("modules/%s", sub->name));
1854 1855
	} else {
		/* Is it already absorbed into the superprojects git dir? */
1856 1857
		char *real_sub_git_dir = real_pathdup(sub_git_dir, 1);
		char *real_common_git_dir = real_pathdup(get_git_common_dir(), 1);
1858

1859 1860 1861 1862 1863 1864 1865
		if (!starts_with(real_sub_git_dir, real_common_git_dir))
			relocate_single_git_dir_into_superproject(prefix, path);

		free(real_sub_git_dir);
		free(real_common_git_dir);
	}
	strbuf_release(&gitdir);
1866 1867 1868 1869 1870 1871 1872 1873

	if (flags & ABSORB_GITDIR_RECURSE_SUBMODULES) {
		struct child_process cp = CHILD_PROCESS_INIT;
		struct strbuf sb = STRBUF_INIT;

		if (flags & ~ABSORB_GITDIR_RECURSE_SUBMODULES)
			die("BUG: we don't know how to pass the flags down?");

1874
		strbuf_addstr(&sb, get_super_prefix_or_empty());
1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890
		strbuf_addstr(&sb, path);
		strbuf_addch(&sb, '/');

		cp.dir = path;
		cp.git_cmd = 1;
		cp.no_stdin = 1;
		argv_array_pushl(&cp.args, "--super-prefix", sb.buf,
					   "submodule--helper",
					   "absorb-git-dirs", NULL);
		prepare_submodule_repo_env(&cp.env_array);
		if (run_command(&cp))
			die(_("could not recurse into submodule '%s'"), path);

		strbuf_release(&sb);
	}
}
1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972

const char *get_superproject_working_tree(void)
{
	struct child_process cp = CHILD_PROCESS_INIT;
	struct strbuf sb = STRBUF_INIT;
	const char *one_up = real_path_if_valid("../");
	const char *cwd = xgetcwd();
	const char *ret = NULL;
	const char *subpath;
	int code;
	ssize_t len;

	if (!is_inside_work_tree())
		/*
		 * FIXME:
		 * We might have a superproject, but it is harder
		 * to determine.
		 */
		return NULL;

	if (!one_up)
		return NULL;

	subpath = relative_path(cwd, one_up, &sb);

	prepare_submodule_repo_env(&cp.env_array);
	argv_array_pop(&cp.env_array);

	argv_array_pushl(&cp.args, "--literal-pathspecs", "-C", "..",
			"ls-files", "-z", "--stage", "--full-name", "--",
			subpath, NULL);
	strbuf_reset(&sb);

	cp.no_stdin = 1;
	cp.no_stderr = 1;
	cp.out = -1;
	cp.git_cmd = 1;

	if (start_command(&cp))
		die(_("could not start ls-files in .."));

	len = strbuf_read(&sb, cp.out, PATH_MAX);
	close(cp.out);

	if (starts_with(sb.buf, "160000")) {
		int super_sub_len;
		int cwd_len = strlen(cwd);
		char *super_sub, *super_wt;

		/*
		 * There is a superproject having this repo as a submodule.
		 * The format is <mode> SP <hash> SP <stage> TAB <full name> \0,
		 * We're only interested in the name after the tab.
		 */
		super_sub = strchr(sb.buf, '\t') + 1;
		super_sub_len = sb.buf + sb.len - super_sub - 1;

		if (super_sub_len > cwd_len ||
		    strcmp(&cwd[cwd_len - super_sub_len], super_sub))
			die (_("BUG: returned path string doesn't match cwd?"));

		super_wt = xstrdup(cwd);
		super_wt[cwd_len - super_sub_len] = '\0';

		ret = real_path(super_wt);
		free(super_wt);
	}
	strbuf_release(&sb);

	code = finish_command(&cp);

	if (code == 128)
		/* '../' is not a git repository */
		return NULL;
	if (code == 0 && len == 0)
		/* There is an unrelated git repository at '../' */
		return NULL;
	if (code)
		die(_("ls-tree returned unexpected return code %d"), code);

	return ret;
}
1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990

int submodule_to_gitdir(struct strbuf *buf, const char *submodule)
{
	const struct submodule *sub;
	const char *git_dir;
	int ret = 0;

	strbuf_reset(buf);
	strbuf_addstr(buf, submodule);
	strbuf_complete(buf, '/');
	strbuf_addstr(buf, ".git");

	git_dir = read_gitfile(buf->buf);
	if (git_dir) {
		strbuf_reset(buf);
		strbuf_addstr(buf, git_dir);
	}
	if (!is_git_directory(buf->buf)) {
1991
		sub = submodule_from_path(&null_oid, submodule);
1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002
		if (!sub) {
			ret = -1;
			goto cleanup;
		}
		strbuf_reset(buf);
		strbuf_git_path(buf, "%s/%s", "modules", sub->name);
	}

cleanup:
	return ret;
}