submodule: check for unmerged .gitmodules outside of config parsing
[git/git.git] / submodule.c
CommitLineData
752c0c24 1#include "cache.h"
69aba532 2#include "repository.h"
b2141fc1 3#include "config.h"
851e18c3 4#include "submodule-config.h"
752c0c24
JS
5#include "submodule.h"
6#include "dir.h"
7#include "diff.h"
8#include "commit.h"
9#include "revision.h"
ee6fc514 10#include "run-command.h"
c7e1a736 11#include "diffcore.h"
68d03e4a 12#include "refs.h"
aee9c7d6 13#include "string-list.h"
6859de45 14#include "sha1-array.h"
c1189cae 15#include "argv-array.h"
5fee9952 16#include "blob.h"
fe85ee6e 17#include "thread-utils.h"
4638728c 18#include "quote.h"
06bf4ad1 19#include "remote.h"
f6f85861 20#include "worktree.h"
046b4823 21#include "parse-options.h"
aee9c7d6 22
d7a3803f 23static int config_update_recurse_submodules = RECURSE_SUBMODULES_OFF;
a6bb78c3 24static struct string_list changed_submodule_paths = STRING_LIST_INIT_DUP;
6859de45 25static int initialized_fetch_ref_tips;
910650d2 26static struct oid_array ref_tips_before_fetch;
27static struct oid_array ref_tips_after_fetch;
6859de45 28
d4e98b58 29/*
34e2ba04
BW
30 * Check if the .gitmodules file is unmerged. Parsing of the .gitmodules file
31 * will be disabled because we can't guess what might be configured in
32 * .gitmodules unless the user resolves the conflict.
d4e98b58 33 */
34e2ba04
BW
34int is_gitmodules_unmerged(const struct index_state *istate)
35{
36 int pos = index_name_pos(istate, GITMODULES_FILE, strlen(GITMODULES_FILE));
37 if (pos < 0) { /* .gitmodules not found or isn't merged */
38 pos = -1 - pos;
39 if (istate->cache_nr > pos) { /* there is a .gitmodules */
40 const struct cache_entry *ce = istate->cache[pos];
41 if (ce_namelen(ce) == strlen(GITMODULES_FILE) &&
42 !strcmp(ce->name, GITMODULES_FILE))
43 return 1;
44 }
45 }
46
47 return 0;
48}
752c0c24 49
5fee9952 50/*
91b83480
BW
51 * Check if the .gitmodules file has unstaged modifications. This must be
52 * checked before allowing modifications to the .gitmodules file with the
53 * intention to stage them later, because when continuing we would stage the
54 * modifications the user didn't stage herself too. That might change in a
55 * future version when we learn to stage the changes we do ourselves without
56 * staging any previous modifications.
5fee9952 57 */
91b83480 58int is_staging_gitmodules_ok(const struct index_state *istate)
5fee9952 59{
91b83480
BW
60 int pos = index_name_pos(istate, GITMODULES_FILE, strlen(GITMODULES_FILE));
61
62 if ((pos >= 0) && (pos < istate->cache_nr)) {
63 struct stat st;
64 if (lstat(GITMODULES_FILE, &st) == 0 &&
65 ce_match_stat(istate->cache[pos], &st, 0) & DATA_CHANGED)
66 return 0;
67 }
68
69 return 1;
5fee9952
JL
70}
71
0656781f
JL
72/*
73 * Try to update the "path" entry in the "submodule.<name>" section of the
74 * .gitmodules file. Return 0 only if a .gitmodules file was found, a section
75 * with the correct path=<oldpath> setting was found and we could update it.
76 */
77int update_path_in_gitmodules(const char *oldpath, const char *newpath)
78{
79 struct strbuf entry = STRBUF_INIT;
851e18c3 80 const struct submodule *submodule;
0656781f 81
4c0eeafe 82 if (!file_exists(GITMODULES_FILE)) /* Do nothing without .gitmodules */
0656781f
JL
83 return -1;
84
34e2ba04 85 if (is_gitmodules_unmerged(&the_index))
0656781f
JL
86 die(_("Cannot change unmerged .gitmodules, resolve merge conflicts first"));
87
851e18c3
HV
88 submodule = submodule_from_path(null_sha1, oldpath);
89 if (!submodule || !submodule->name) {
0656781f
JL
90 warning(_("Could not find section in .gitmodules where path=%s"), oldpath);
91 return -1;
92 }
93 strbuf_addstr(&entry, "submodule.");
851e18c3 94 strbuf_addstr(&entry, submodule->name);
0656781f 95 strbuf_addstr(&entry, ".path");
4c0eeafe 96 if (git_config_set_in_file_gently(GITMODULES_FILE, entry.buf, newpath) < 0) {
0656781f
JL
97 /* Maybe the user already did that, don't error out here */
98 warning(_("Could not update .gitmodules entry %s"), entry.buf);
99 strbuf_release(&entry);
100 return -1;
101 }
102 strbuf_release(&entry);
103 return 0;
104}
105
95c16418
JL
106/*
107 * Try to remove the "submodule.<name>" section from .gitmodules where the given
108 * path is configured. Return 0 only if a .gitmodules file was found, a section
109 * with the correct path=<path> setting was found and we could remove it.
110 */
111int remove_path_from_gitmodules(const char *path)
112{
113 struct strbuf sect = STRBUF_INIT;
851e18c3 114 const struct submodule *submodule;
95c16418 115
4c0eeafe 116 if (!file_exists(GITMODULES_FILE)) /* Do nothing without .gitmodules */
95c16418
JL
117 return -1;
118
34e2ba04 119 if (is_gitmodules_unmerged(&the_index))
95c16418
JL
120 die(_("Cannot change unmerged .gitmodules, resolve merge conflicts first"));
121
851e18c3
HV
122 submodule = submodule_from_path(null_sha1, path);
123 if (!submodule || !submodule->name) {
95c16418
JL
124 warning(_("Could not find section in .gitmodules where path=%s"), path);
125 return -1;
126 }
127 strbuf_addstr(&sect, "submodule.");
851e18c3 128 strbuf_addstr(&sect, submodule->name);
4c0eeafe 129 if (git_config_rename_section_in_file(GITMODULES_FILE, sect.buf, NULL) < 0) {
95c16418
JL
130 /* Maybe the user already did that, don't error out here */
131 warning(_("Could not remove .gitmodules entry for %s"), path);
132 strbuf_release(&sect);
133 return -1;
134 }
135 strbuf_release(&sect);
136 return 0;
137}
138
5fee9952
JL
139void stage_updated_gitmodules(void)
140{
4c0eeafe 141 if (add_file_to_cache(GITMODULES_FILE, 0))
5fee9952
JL
142 die(_("staging updated .gitmodules failed"));
143}
144
cb58c932 145static int add_submodule_odb(const char *path)
752c0c24
JS
146{
147 struct strbuf objects_directory = STRBUF_INIT;
de7a7960 148 int ret = 0;
752c0c24 149
99b43a61
JK
150 ret = strbuf_git_path_submodule(&objects_directory, path, "objects/");
151 if (ret)
152 goto done;
de7a7960
JL
153 if (!is_directory(objects_directory.buf)) {
154 ret = -1;
155 goto done;
156 }
a5b34d21 157 add_to_alternates_memory(objects_directory.buf);
de7a7960
JL
158done:
159 strbuf_release(&objects_directory);
160 return ret;
752c0c24
JS
161}
162
aee9c7d6
JL
163void set_diffopt_flags_from_submodule_config(struct diff_options *diffopt,
164 const char *path)
165{
851e18c3
HV
166 const struct submodule *submodule = submodule_from_path(null_sha1, path);
167 if (submodule) {
168 if (submodule->ignore)
169 handle_ignore_submodules_arg(diffopt, submodule->ignore);
34e2ba04 170 else if (is_gitmodules_unmerged(&the_index))
d4e98b58 171 DIFF_OPT_SET(diffopt, IGNORE_SUBMODULES);
aee9c7d6
JL
172 }
173}
174
1d789d08
SB
175/* For loading from the .gitmodules file. */
176static int git_modules_config(const char *var, const char *value, void *cb)
302ad7a9 177{
f20e7c1e 178 if (starts_with(var, "submodule."))
302ad7a9
JL
179 return parse_submodule_config_option(var, value);
180 return 0;
181}
182
046b4823 183/* Loads all submodule settings from the config. */
1d789d08
SB
184int submodule_config(const char *var, const char *value, void *cb)
185{
046b4823
SB
186 if (!strcmp(var, "submodule.recurse")) {
187 int v = git_config_bool(var, value) ?
188 RECURSE_SUBMODULES_ON : RECURSE_SUBMODULES_OFF;
189 config_update_recurse_submodules = v;
190 return 0;
191 } else {
192 return git_modules_config(var, value, cb);
193 }
194}
195
196/* Cheap function that only determines if we're interested in submodules at all */
197int git_default_submodule_config(const char *var, const char *value, void *cb)
198{
199 if (!strcmp(var, "submodule.recurse")) {
200 int v = git_config_bool(var, value) ?
201 RECURSE_SUBMODULES_ON : RECURSE_SUBMODULES_OFF;
202 config_update_recurse_submodules = v;
203 }
204 return 0;
1d789d08
SB
205}
206
d7a3803f
SB
207int option_parse_recurse_submodules_worktree_updater(const struct option *opt,
208 const char *arg, int unset)
209{
210 if (unset) {
211 config_update_recurse_submodules = RECURSE_SUBMODULES_OFF;
212 return 0;
213 }
214 if (arg)
215 config_update_recurse_submodules =
216 parse_update_recurse_submodules_arg(opt->long_name,
217 arg);
218 else
219 config_update_recurse_submodules = RECURSE_SUBMODULES_ON;
220
221 return 0;
222}
223
224void load_submodule_cache(void)
225{
226 if (config_update_recurse_submodules == RECURSE_SUBMODULES_OFF)
227 return;
228
229 gitmodules_config();
230 git_config(submodule_config, NULL);
231}
232
302ad7a9
JL
233void gitmodules_config(void)
234{
235 const char *work_tree = get_git_work_tree();
236 if (work_tree) {
237 struct strbuf gitmodules_path = STRBUF_INIT;
238 strbuf_addstr(&gitmodules_path, work_tree);
4c0eeafe 239 strbuf_addstr(&gitmodules_path, "/" GITMODULES_FILE);
d4e98b58
JL
240 if (read_cache() < 0)
241 die("index file corrupt");
d4e98b58 242
34e2ba04 243 if (!is_gitmodules_unmerged(&the_index))
1d789d08
SB
244 git_config_from_file(git_modules_config,
245 gitmodules_path.buf, NULL);
302ad7a9
JL
246 strbuf_release(&gitmodules_path);
247 }
248}
249
69aba532
BW
250static int gitmodules_cb(const char *var, const char *value, void *data)
251{
252 struct repository *repo = data;
253 return submodule_config_option(repo, var, value);
254}
255
256void repo_read_gitmodules(struct repository *repo)
257{
4c0eeafe 258 char *gitmodules_path = repo_worktree_path(repo, GITMODULES_FILE);
69aba532
BW
259
260 git_config_from_file(gitmodules_cb, gitmodules_path, repo);
261 free(gitmodules_path);
262}
263
9ebf689a
BW
264void gitmodules_config_sha1(const unsigned char *commit_sha1)
265{
266 struct strbuf rev = STRBUF_INIT;
267 unsigned char sha1[20];
268
269 if (gitmodule_sha1_from_commit(commit_sha1, sha1, &rev)) {
1d789d08 270 git_config_from_blob_sha1(git_modules_config, rev.buf,
9ebf689a
BW
271 sha1, NULL);
272 }
273 strbuf_release(&rev);
274}
275
f9f42560
BW
276/*
277 * Determine if a submodule has been initialized at a given 'path'
278 */
627d9342 279int is_submodule_active(struct repository *repo, const char *path)
f9f42560
BW
280{
281 int ret = 0;
a086f921
BW
282 char *key = NULL;
283 char *value = NULL;
284 const struct string_list *sl;
627d9342
BW
285 const struct submodule *module;
286
287 module = submodule_from_cache(repo, null_sha1, path);
f9f42560 288
a086f921
BW
289 /* early return if there isn't a path->module mapping */
290 if (!module)
291 return 0;
f9f42560 292
a086f921
BW
293 /* submodule.<name>.active is set */
294 key = xstrfmt("submodule.%s.active", module->name);
627d9342 295 if (!repo_config_get_bool(repo, key, &ret)) {
a086f921
BW
296 free(key);
297 return ret;
298 }
299 free(key);
f9f42560 300
a086f921 301 /* submodule.active is set */
627d9342 302 sl = repo_config_get_value_multi(repo, "submodule.active");
a086f921
BW
303 if (sl) {
304 struct pathspec ps;
305 struct argv_array args = ARGV_ARRAY_INIT;
306 const struct string_list_item *item;
f9f42560 307
a086f921
BW
308 for_each_string_list_item(item, sl) {
309 argv_array_push(&args, item->string);
310 }
311
312 parse_pathspec(&ps, 0, 0, NULL, args.argv);
313 ret = match_pathspec(&ps, path, strlen(path), 0, NULL, 1);
314
315 argv_array_clear(&args);
316 clear_pathspec(&ps);
317 return ret;
f9f42560
BW
318 }
319
a086f921
BW
320 /* fallback to checking if the URL is set */
321 key = xstrfmt("submodule.%s.url", module->name);
627d9342 322 ret = !repo_config_get_string(repo, key, &value);
a086f921
BW
323
324 free(value);
325 free(key);
f9f42560
BW
326 return ret;
327}
328
15cdc647 329int is_submodule_populated_gently(const char *path, int *return_error_code)
5688c28d
BW
330{
331 int ret = 0;
332 char *gitdir = xstrfmt("%s/.git", path);
333
15cdc647 334 if (resolve_gitdir_gently(gitdir, return_error_code))
5688c28d
BW
335 ret = 1;
336
337 free(gitdir);
338 return ret;
339}
340
bdab9721
BW
341/*
342 * Dies if the provided 'prefix' corresponds to an unpopulated submodule
343 */
344void die_in_unpopulated_submodule(const struct index_state *istate,
345 const char *prefix)
346{
347 int i, prefixlen;
348
349 if (!prefix)
350 return;
351
352 prefixlen = strlen(prefix);
353
354 for (i = 0; i < istate->cache_nr; i++) {
355 struct cache_entry *ce = istate->cache[i];
356 int ce_len = ce_namelen(ce);
357
358 if (!S_ISGITLINK(ce->ce_mode))
359 continue;
360 if (prefixlen <= ce_len)
361 continue;
362 if (strncmp(ce->name, prefix, ce_len))
363 continue;
364 if (prefix[ce_len] != '/')
365 continue;
366
367 die(_("in unpopulated submodule '%s'"), ce->name);
368 }
369}
370
c08397e3
BW
371/*
372 * Dies if any paths in the provided pathspec descends into a submodule
373 */
374void die_path_inside_submodule(const struct index_state *istate,
375 const struct pathspec *ps)
376{
377 int i, j;
378
379 for (i = 0; i < istate->cache_nr; i++) {
380 struct cache_entry *ce = istate->cache[i];
381 int ce_len = ce_namelen(ce);
382
383 if (!S_ISGITLINK(ce->ce_mode))
384 continue;
385
386 for (j = 0; j < ps->nr ; j++) {
387 const struct pathspec_item *item = &ps->items[j];
388
389 if (item->len <= ce_len)
390 continue;
391 if (item->match[ce_len] != '/')
392 continue;
393 if (strncmp(ce->name, item->match, ce_len))
394 continue;
395 if (item->len == ce_len + 1)
396 continue;
397
398 die(_("Pathspec '%s' is in submodule '%.*s'"),
399 item->original, ce_len, ce->name);
400 }
401 }
402}
403
ea2fa5a3
SB
404int parse_submodule_update_strategy(const char *value,
405 struct submodule_update_strategy *dst)
406{
407 free((void*)dst->command);
408 dst->command = NULL;
409 if (!strcmp(value, "none"))
410 dst->type = SM_UPDATE_NONE;
411 else if (!strcmp(value, "checkout"))
412 dst->type = SM_UPDATE_CHECKOUT;
413 else if (!strcmp(value, "rebase"))
414 dst->type = SM_UPDATE_REBASE;
415 else if (!strcmp(value, "merge"))
416 dst->type = SM_UPDATE_MERGE;
417 else if (skip_prefix(value, "!", &value)) {
418 dst->type = SM_UPDATE_COMMAND;
419 dst->command = xstrdup(value);
420 } else
421 return -1;
422 return 0;
423}
424
3604242f
SB
425const char *submodule_strategy_to_string(const struct submodule_update_strategy *s)
426{
427 struct strbuf sb = STRBUF_INIT;
428 switch (s->type) {
429 case SM_UPDATE_CHECKOUT:
430 return "checkout";
431 case SM_UPDATE_MERGE:
432 return "merge";
433 case SM_UPDATE_REBASE:
434 return "rebase";
435 case SM_UPDATE_NONE:
436 return "none";
437 case SM_UPDATE_UNSPECIFIED:
438 return NULL;
439 case SM_UPDATE_COMMAND:
440 strbuf_addf(&sb, "!%s", s->command);
441 return strbuf_detach(&sb, NULL);
442 }
443 return NULL;
444}
445
46a958b3
JL
446void handle_ignore_submodules_arg(struct diff_options *diffopt,
447 const char *arg)
448{
be4f2b40
JS
449 DIFF_OPT_CLR(diffopt, IGNORE_SUBMODULES);
450 DIFF_OPT_CLR(diffopt, IGNORE_UNTRACKED_IN_SUBMODULES);
451 DIFF_OPT_CLR(diffopt, IGNORE_DIRTY_SUBMODULES);
452
46a958b3
JL
453 if (!strcmp(arg, "all"))
454 DIFF_OPT_SET(diffopt, IGNORE_SUBMODULES);
455 else if (!strcmp(arg, "untracked"))
456 DIFF_OPT_SET(diffopt, IGNORE_UNTRACKED_IN_SUBMODULES);
457 else if (!strcmp(arg, "dirty"))
458 DIFF_OPT_SET(diffopt, IGNORE_DIRTY_SUBMODULES);
aee9c7d6 459 else if (strcmp(arg, "none"))
46a958b3
JL
460 die("bad --ignore-submodules argument: %s", arg);
461}
462
808a95dc
JN
463static int prepare_submodule_summary(struct rev_info *rev, const char *path,
464 struct commit *left, struct commit *right,
8e6df650 465 struct commit_list *merge_bases)
808a95dc 466{
8e6df650 467 struct commit_list *list;
808a95dc
JN
468
469 init_revisions(rev, NULL);
470 setup_revisions(0, NULL, rev, NULL);
471 rev->left_right = 1;
472 rev->first_parent_only = 1;
473 left->object.flags |= SYMMETRIC_LEFT;
474 add_pending_object(rev, &left->object, path);
475 add_pending_object(rev, &right->object, path);
808a95dc
JN
476 for (list = merge_bases; list; list = list->next) {
477 list->item->object.flags |= UNINTERESTING;
478 add_pending_object(rev, &list->item->object,
f2fd0760 479 oid_to_hex(&list->item->object.oid));
808a95dc
JN
480 }
481 return prepare_revision_walk(rev);
482}
483
484static void print_submodule_summary(struct rev_info *rev, FILE *f,
0f33a067 485 const char *line_prefix,
808a95dc
JN
486 const char *del, const char *add, const char *reset)
487{
488 static const char format[] = " %m %s";
489 struct strbuf sb = STRBUF_INIT;
490 struct commit *commit;
491
492 while ((commit = get_revision(rev))) {
493 struct pretty_print_context ctx = {0};
494 ctx.date_mode = rev->date_mode;
ecaee805 495 ctx.output_encoding = get_log_output_encoding();
808a95dc 496 strbuf_setlen(&sb, 0);
0f33a067 497 strbuf_addstr(&sb, line_prefix);
808a95dc
JN
498 if (commit->object.flags & SYMMETRIC_LEFT) {
499 if (del)
500 strbuf_addstr(&sb, del);
501 }
502 else if (add)
503 strbuf_addstr(&sb, add);
504 format_commit_message(commit, format, &sb, &ctx);
505 if (reset)
506 strbuf_addstr(&sb, reset);
507 strbuf_addch(&sb, '\n');
508 fprintf(f, "%s", sb.buf);
509 }
510 strbuf_release(&sb);
511}
512
6cd5757c
SB
513static void prepare_submodule_repo_env_no_git_dir(struct argv_array *out)
514{
515 const char * const *var;
516
517 for (var = local_repo_env; *var; var++) {
518 if (strcmp(*var, CONFIG_DATA_ENVIRONMENT))
519 argv_array_push(out, *var);
520 }
521}
522
523void prepare_submodule_repo_env(struct argv_array *out)
524{
525 prepare_submodule_repo_env_no_git_dir(out);
526 argv_array_pushf(out, "%s=%s", GIT_DIR_ENVIRONMENT,
527 DEFAULT_GIT_DIR_ENVIRONMENT);
528}
529
8e6df650
JK
530/* Helper function to display the submodule header line prior to the full
531 * summary output. If it can locate the submodule objects directory it will
532 * attempt to lookup both the left and right commits and put them into the
533 * left and right pointers.
534 */
535static void show_submodule_header(FILE *f, const char *path,
0f33a067 536 const char *line_prefix,
602a283a 537 struct object_id *one, struct object_id *two,
4e215131 538 unsigned dirty_submodule, const char *meta,
8e6df650
JK
539 const char *reset,
540 struct commit **left, struct commit **right,
541 struct commit_list **merge_bases)
752c0c24 542{
752c0c24
JS
543 const char *message = NULL;
544 struct strbuf sb = STRBUF_INIT;
752c0c24
JS
545 int fast_forward = 0, fast_backward = 0;
546
c7e1a736 547 if (dirty_submodule & DIRTY_SUBMODULE_UNTRACKED)
0f33a067
JK
548 fprintf(f, "%sSubmodule %s contains untracked content\n",
549 line_prefix, path);
c7e1a736 550 if (dirty_submodule & DIRTY_SUBMODULE_MODIFIED)
0f33a067
JK
551 fprintf(f, "%sSubmodule %s contains modified content\n",
552 line_prefix, path);
c7e1a736 553
8e6df650
JK
554 if (is_null_oid(one))
555 message = "(new submodule)";
556 else if (is_null_oid(two))
557 message = "(submodule deleted)";
558
559 if (add_submodule_odb(path)) {
560 if (!message)
561 message = "(not initialized)";
562 goto output_header;
563 }
564
565 /*
566 * Attempt to lookup the commit references, and determine if this is
567 * a fast forward or fast backwards update.
568 */
bc83266a 569 *left = lookup_commit_reference(one);
570 *right = lookup_commit_reference(two);
8e6df650
JK
571
572 /*
573 * Warn about missing commits in the submodule project, but only if
574 * they aren't null.
575 */
576 if ((!is_null_oid(one) && !*left) ||
577 (!is_null_oid(two) && !*right))
578 message = "(commits not present)";
579
580 *merge_bases = get_merge_bases(*left, *right);
581 if (*merge_bases) {
582 if ((*merge_bases)->item == *left)
583 fast_forward = 1;
584 else if ((*merge_bases)->item == *right)
585 fast_backward = 1;
586 }
587
602a283a 588 if (!oidcmp(one, two)) {
c7e1a736
JL
589 strbuf_release(&sb);
590 return;
591 }
592
8e6df650 593output_header:
a94bb683 594 strbuf_addf(&sb, "%s%sSubmodule %s ", line_prefix, meta, path);
69e65449 595 strbuf_add_unique_abbrev(&sb, one->hash, DEFAULT_ABBREV);
a94bb683 596 strbuf_addstr(&sb, (fast_backward || fast_forward) ? ".." : "...");
f0798e6c 597 strbuf_add_unique_abbrev(&sb, two->hash, DEFAULT_ABBREV);
752c0c24 598 if (message)
4e215131 599 strbuf_addf(&sb, " %s%s\n", message, reset);
752c0c24 600 else
4e215131 601 strbuf_addf(&sb, "%s:%s\n", fast_backward ? " (rewind)" : "", reset);
752c0c24
JS
602 fwrite(sb.buf, sb.len, 1, f);
603
752c0c24
JS
604 strbuf_release(&sb);
605}
ee6fc514 606
8e6df650
JK
607void show_submodule_summary(FILE *f, const char *path,
608 const char *line_prefix,
609 struct object_id *one, struct object_id *two,
610 unsigned dirty_submodule, const char *meta,
611 const char *del, const char *add, const char *reset)
612{
613 struct rev_info rev;
614 struct commit *left = NULL, *right = NULL;
615 struct commit_list *merge_bases = NULL;
616
617 show_submodule_header(f, path, line_prefix, one, two, dirty_submodule,
618 meta, reset, &left, &right, &merge_bases);
619
620 /*
621 * If we don't have both a left and a right pointer, there is no
622 * reason to try and display a summary. The header line should contain
623 * all the information the user needs.
624 */
625 if (!left || !right)
626 goto out;
627
628 /* Treat revision walker failure the same as missing commits */
629 if (prepare_submodule_summary(&rev, path, left, right, merge_bases)) {
630 fprintf(f, "%s(revision walker failed)\n", line_prefix);
631 goto out;
632 }
633
634 print_submodule_summary(&rev, f, line_prefix, del, add, reset);
635
636out:
637 if (merge_bases)
638 free_commit_list(merge_bases);
639 clear_commit_marks(left, ~0);
640 clear_commit_marks(right, ~0);
641}
642
fd47ae6a
JK
643void show_submodule_inline_diff(FILE *f, const char *path,
644 const char *line_prefix,
645 struct object_id *one, struct object_id *two,
646 unsigned dirty_submodule, const char *meta,
647 const char *del, const char *add, const char *reset,
648 const struct diff_options *o)
649{
650 const struct object_id *old = &empty_tree_oid, *new = &empty_tree_oid;
651 struct commit *left = NULL, *right = NULL;
652 struct commit_list *merge_bases = NULL;
653 struct strbuf submodule_dir = STRBUF_INIT;
654 struct child_process cp = CHILD_PROCESS_INIT;
655
656 show_submodule_header(f, path, line_prefix, one, two, dirty_submodule,
657 meta, reset, &left, &right, &merge_bases);
658
659 /* We need a valid left and right commit to display a difference */
660 if (!(left || is_null_oid(one)) ||
661 !(right || is_null_oid(two)))
662 goto done;
663
664 if (left)
665 old = one;
666 if (right)
667 new = two;
668
669 fflush(f);
670 cp.git_cmd = 1;
671 cp.dir = path;
672 cp.out = dup(fileno(f));
673 cp.no_stdin = 1;
674
675 /* TODO: other options may need to be passed here. */
5a522142
SB
676 argv_array_pushl(&cp.args, "diff", "--submodule=diff", NULL);
677
fd47ae6a
JK
678 argv_array_pushf(&cp.args, "--line-prefix=%s", line_prefix);
679 if (DIFF_OPT_TST(o, REVERSE_DIFF)) {
680 argv_array_pushf(&cp.args, "--src-prefix=%s%s/",
681 o->b_prefix, path);
682 argv_array_pushf(&cp.args, "--dst-prefix=%s%s/",
683 o->a_prefix, path);
684 } else {
685 argv_array_pushf(&cp.args, "--src-prefix=%s%s/",
686 o->a_prefix, path);
687 argv_array_pushf(&cp.args, "--dst-prefix=%s%s/",
688 o->b_prefix, path);
689 }
690 argv_array_push(&cp.args, oid_to_hex(old));
691 /*
692 * If the submodule has modified content, we will diff against the
693 * work tree, under the assumption that the user has asked for the
694 * diff format and wishes to actually see all differences even if they
695 * haven't yet been committed to the submodule yet.
696 */
697 if (!(dirty_submodule & DIRTY_SUBMODULE_MODIFIED))
698 argv_array_push(&cp.args, oid_to_hex(new));
699
17b254cd 700 prepare_submodule_repo_env(&cp.env_array);
fd47ae6a
JK
701 if (run_command(&cp))
702 fprintf(f, "(diff failed)\n");
703
704done:
705 strbuf_release(&submodule_dir);
706 if (merge_bases)
707 free_commit_list(merge_bases);
708 if (left)
709 clear_commit_marks(left, ~0);
710 if (right)
711 clear_commit_marks(right, ~0);
712}
713
84f8925e
SB
714int should_update_submodules(void)
715{
716 return config_update_recurse_submodules == RECURSE_SUBMODULES_ON;
717}
718
719const struct submodule *submodule_from_ce(const struct cache_entry *ce)
720{
721 if (!S_ISGITLINK(ce->ce_mode))
722 return NULL;
723
724 if (!should_update_submodules())
725 return NULL;
726
727 return submodule_from_path(null_sha1, ce->name);
728}
729
aacc5c1a
BW
730static struct oid_array *submodule_commits(struct string_list *submodules,
731 const char *path)
732{
733 struct string_list_item *item;
734
735 item = string_list_insert(submodules, path);
736 if (item->util)
737 return (struct oid_array *) item->util;
738
739 /* NEEDSWORK: should we have oid_array_init()? */
740 item->util = xcalloc(1, sizeof(struct oid_array));
741 return (struct oid_array *) item->util;
742}
743
744static void collect_changed_submodules_cb(struct diff_queue_struct *q,
745 struct diff_options *options,
746 void *data)
747{
748 int i;
749 struct string_list *changed = data;
750
751 for (i = 0; i < q->nr; i++) {
752 struct diff_filepair *p = q->queue[i];
753 struct oid_array *commits;
754 if (!S_ISGITLINK(p->two->mode))
755 continue;
756
757 if (S_ISGITLINK(p->one->mode)) {
758 /*
759 * NEEDSWORK: We should honor the name configured in
760 * the .gitmodules file of the commit we are examining
761 * here to be able to correctly follow submodules
762 * being moved around.
763 */
764 commits = submodule_commits(changed, p->two->path);
765 oid_array_append(commits, &p->two->oid);
766 } else {
767 /* Submodule is new or was moved here */
768 /*
769 * NEEDSWORK: When the .git directories of submodules
770 * live inside the superprojects .git directory some
771 * day we should fetch new submodules directly into
772 * that location too when config or options request
773 * that so they can be checked out from there.
774 */
775 continue;
776 }
777 }
778}
779
780/*
781 * Collect the paths of submodules in 'changed' which have changed based on
782 * the revisions as specified in 'argv'. Each entry in 'changed' will also
783 * have a corresponding 'struct oid_array' (in the 'util' field) which lists
784 * what the submodule pointers were updated to during the change.
785 */
786static void collect_changed_submodules(struct string_list *changed,
787 struct argv_array *argv)
788{
789 struct rev_info rev;
790 const struct commit *commit;
791
792 init_revisions(&rev, NULL);
793 setup_revisions(argv->argc, argv->argv, &rev, NULL);
794 if (prepare_revision_walk(&rev))
795 die("revision walk setup failed");
796
797 while ((commit = get_revision(&rev))) {
798 struct rev_info diff_rev;
799
800 init_revisions(&diff_rev, NULL);
801 diff_rev.diffopt.output_format |= DIFF_FORMAT_CALLBACK;
802 diff_rev.diffopt.format_callback = collect_changed_submodules_cb;
803 diff_rev.diffopt.format_callback_data = changed;
804 diff_tree_combined_merge(commit, 1, &diff_rev);
805 }
806
807 reset_revision_walk();
808}
809
810static void free_submodules_oids(struct string_list *submodules)
811{
812 struct string_list_item *item;
813 for_each_string_list_item(item, submodules)
814 oid_array_clear((struct oid_array *) item->util);
815 string_list_clear(submodules, 1);
816}
817
7290ef58
MH
818static int has_remote(const char *refname, const struct object_id *oid,
819 int flags, void *cb_data)
d2b17b32
FG
820{
821 return 1;
822}
823
1b7ba794 824static int append_oid_to_argv(const struct object_id *oid, void *data)
d2b17b32 825{
9cfa1c26 826 struct argv_array *argv = data;
1b7ba794 827 argv_array_push(argv, oid_to_hex(oid));
9cfa1c26
HV
828 return 0;
829}
830
1b7ba794 831static int check_has_commit(const struct object_id *oid, void *data)
d2b17b32 832{
5b6607d2
HV
833 int *has_commit = data;
834
bc83266a 835 if (!lookup_commit_reference(oid))
5b6607d2
HV
836 *has_commit = 0;
837
838 return 0;
839}
840
910650d2 841static int submodule_has_commits(const char *path, struct oid_array *commits)
5b6607d2
HV
842{
843 int has_commit = 1;
844
7c8d2b00 845 /*
64127575 846 * Perform a cheap, but incorrect check for the existence of 'commits'.
7c8d2b00 847 * This is done by adding the submodule's object store to the in-core
64127575 848 * object store, and then querying for each commit's existence. If we
7c8d2b00
BW
849 * do not have the commit object anywhere, there is no chance we have
850 * it in the object store of the correct submodule and have it
851 * reachable from a ref, so we can fail early without spawning rev-list
852 * which is expensive.
853 */
5b6607d2
HV
854 if (add_submodule_odb(path))
855 return 0;
856
910650d2 857 oid_array_for_each_unique(commits, check_has_commit, &has_commit);
7c8d2b00
BW
858
859 if (has_commit) {
860 /*
861 * Even if the submodule is checked out and the commit is
862 * present, make sure it exists in the submodule's object store
863 * and that it is reachable from a ref.
864 */
865 struct child_process cp = CHILD_PROCESS_INIT;
866 struct strbuf out = STRBUF_INIT;
867
868 argv_array_pushl(&cp.args, "rev-list", "-n", "1", NULL);
869 oid_array_for_each_unique(commits, append_oid_to_argv, &cp.args);
870 argv_array_pushl(&cp.args, "--not", "--all", NULL);
871
872 prepare_submodule_repo_env(&cp.env_array);
873 cp.git_cmd = 1;
874 cp.no_stdin = 1;
875 cp.dir = path;
876
877 if (capture_command(&cp, &out, GIT_MAX_HEXSZ + 1) || out.len)
878 has_commit = 0;
879
880 strbuf_release(&out);
881 }
882
5b6607d2
HV
883 return has_commit;
884}
885
910650d2 886static int submodule_needs_pushing(const char *path, struct oid_array *commits)
5b6607d2
HV
887{
888 if (!submodule_has_commits(path, commits))
250ab24a
HV
889 /*
890 * NOTE: We do consider it safe to return "no" here. The
891 * correct answer would be "We do not know" instead of
892 * "No push needed", but it is quite hard to change
893 * the submodule pointer without having the submodule
894 * around. If a user did however change the submodules
895 * without having the submodule around, this indicates
896 * an expert who knows what they are doing or a
897 * maintainer integrating work from other people. In
898 * both cases it should be safe to skip this check.
899 */
d2b17b32
FG
900 return 0;
901
902 if (for_each_remote_ref_submodule(path, has_remote, NULL) > 0) {
d3180279 903 struct child_process cp = CHILD_PROCESS_INIT;
d2b17b32
FG
904 struct strbuf buf = STRBUF_INIT;
905 int needs_pushing = 0;
906
5b6607d2 907 argv_array_push(&cp.args, "rev-list");
910650d2 908 oid_array_for_each_unique(commits, append_oid_to_argv, &cp.args);
5b6607d2
HV
909 argv_array_pushl(&cp.args, "--not", "--remotes", "-n", "1" , NULL);
910
c12e8656 911 prepare_submodule_repo_env(&cp.env_array);
d2b17b32
FG
912 cp.git_cmd = 1;
913 cp.no_stdin = 1;
914 cp.out = -1;
915 cp.dir = path;
916 if (start_command(&cp))
5b6607d2
HV
917 die("Could not run 'git rev-list <commits> --not --remotes -n 1' command in submodule %s",
918 path);
d2b17b32
FG
919 if (strbuf_read(&buf, cp.out, 41))
920 needs_pushing = 1;
921 finish_command(&cp);
922 close(cp.out);
923 strbuf_release(&buf);
924 return needs_pushing;
925 }
926
927 return 0;
928}
929
910650d2 930int find_unpushed_submodules(struct oid_array *commits,
a762e51e 931 const char *remotes_name, struct string_list *needs_pushing)
d2b17b32 932{
14739447
HV
933 struct string_list submodules = STRING_LIST_INIT_DUP;
934 struct string_list_item *submodule;
9cfa1c26 935 struct argv_array argv = ARGV_ARRAY_INIT;
a762e51e 936
9cfa1c26
HV
937 /* argv.argv[0] will be ignored by setup_revisions */
938 argv_array_push(&argv, "find_unpushed_submodules");
910650d2 939 oid_array_for_each_unique(commits, append_oid_to_argv, &argv);
9cfa1c26
HV
940 argv_array_push(&argv, "--not");
941 argv_array_pushf(&argv, "--remotes=%s", remotes_name);
942
aacc5c1a 943 collect_changed_submodules(&submodules, &argv);
d2b17b32 944
14739447 945 for_each_string_list_item(submodule, &submodules) {
aacc5c1a
BW
946 struct oid_array *commits = submodule->util;
947 const char *path = submodule->string;
5b6607d2 948
aacc5c1a
BW
949 if (submodule_needs_pushing(path, commits))
950 string_list_insert(needs_pushing, path);
14739447 951 }
610b2337
BW
952
953 free_submodules_oids(&submodules);
aacc5c1a 954 argv_array_clear(&argv);
d2b17b32 955
a762e51e 956 return needs_pushing->nr;
d2b17b32
FG
957}
958
2a90556d 959static int push_submodule(const char *path,
06bf4ad1
BW
960 const struct remote *remote,
961 const char **refspec, int refspec_nr,
2a90556d
BW
962 const struct string_list *push_options,
963 int dry_run)
eb21c732
HV
964{
965 if (add_submodule_odb(path))
966 return 1;
967
968 if (for_each_remote_ref_submodule(path, has_remote, NULL) > 0) {
d3180279 969 struct child_process cp = CHILD_PROCESS_INIT;
0301c821
BW
970 argv_array_push(&cp.args, "push");
971 if (dry_run)
972 argv_array_push(&cp.args, "--dry-run");
eb21c732 973
2a90556d
BW
974 if (push_options && push_options->nr) {
975 const struct string_list_item *item;
976 for_each_string_list_item(item, push_options)
977 argv_array_pushf(&cp.args, "--push-option=%s",
978 item->string);
979 }
06bf4ad1
BW
980
981 if (remote->origin != REMOTE_UNCONFIGURED) {
982 int i;
983 argv_array_push(&cp.args, remote->name);
984 for (i = 0; i < refspec_nr; i++)
985 argv_array_push(&cp.args, refspec[i]);
986 }
987
c12e8656 988 prepare_submodule_repo_env(&cp.env_array);
eb21c732
HV
989 cp.git_cmd = 1;
990 cp.no_stdin = 1;
991 cp.dir = path;
992 if (run_command(&cp))
993 return 0;
994 close(cp.out);
995 }
996
997 return 1;
998}
999
06bf4ad1
BW
1000/*
1001 * Perform a check in the submodule to see if the remote and refspec work.
1002 * Die if the submodule can't be pushed.
1003 */
1004static void submodule_push_check(const char *path, const struct remote *remote,
1005 const char **refspec, int refspec_nr)
1006{
1007 struct child_process cp = CHILD_PROCESS_INIT;
1008 int i;
1009
1010 argv_array_push(&cp.args, "submodule--helper");
1011 argv_array_push(&cp.args, "push-check");
1012 argv_array_push(&cp.args, remote->name);
1013
1014 for (i = 0; i < refspec_nr; i++)
1015 argv_array_push(&cp.args, refspec[i]);
1016
1017 prepare_submodule_repo_env(&cp.env_array);
1018 cp.git_cmd = 1;
1019 cp.no_stdin = 1;
1020 cp.no_stdout = 1;
1021 cp.dir = path;
1022
1023 /*
1024 * Simply indicate if 'submodule--helper push-check' failed.
1025 * More detailed error information will be provided by the
1026 * child process.
1027 */
1028 if (run_command(&cp))
1029 die("process for submodule '%s' failed", path);
1030}
1031
910650d2 1032int push_unpushed_submodules(struct oid_array *commits,
06bf4ad1
BW
1033 const struct remote *remote,
1034 const char **refspec, int refspec_nr,
2a90556d 1035 const struct string_list *push_options,
0301c821 1036 int dry_run)
eb21c732
HV
1037{
1038 int i, ret = 1;
f93d7c6f 1039 struct string_list needs_pushing = STRING_LIST_INIT_DUP;
eb21c732 1040
06bf4ad1 1041 if (!find_unpushed_submodules(commits, remote->name, &needs_pushing))
eb21c732
HV
1042 return 1;
1043
06bf4ad1
BW
1044 /*
1045 * Verify that the remote and refspec can be propagated to all
1046 * submodules. This check can be skipped if the remote and refspec
1047 * won't be propagated due to the remote being unconfigured (e.g. a URL
1048 * instead of a remote name).
1049 */
1050 if (remote->origin != REMOTE_UNCONFIGURED)
1051 for (i = 0; i < needs_pushing.nr; i++)
1052 submodule_push_check(needs_pushing.items[i].string,
1053 remote, refspec, refspec_nr);
1054
1055 /* Actually push the submodules */
eb21c732
HV
1056 for (i = 0; i < needs_pushing.nr; i++) {
1057 const char *path = needs_pushing.items[i].string;
1058 fprintf(stderr, "Pushing submodule '%s'\n", path);
06bf4ad1
BW
1059 if (!push_submodule(path, remote, refspec, refspec_nr,
1060 push_options, dry_run)) {
eb21c732
HV
1061 fprintf(stderr, "Unable to push submodule '%s'\n", path);
1062 ret = 0;
1063 }
1064 }
1065
1066 string_list_clear(&needs_pushing, 0);
1067
1068 return ret;
1069}
1070
419fd786
BW
1071static int append_oid_to_array(const char *ref, const struct object_id *oid,
1072 int flags, void *data)
6859de45 1073{
419fd786
BW
1074 struct oid_array *array = data;
1075 oid_array_append(array, oid);
6859de45
JK
1076 return 0;
1077}
1078
2eb80bcd 1079void check_for_new_submodule_commits(struct object_id *oid)
6859de45
JK
1080{
1081 if (!initialized_fetch_ref_tips) {
419fd786 1082 for_each_ref(append_oid_to_array, &ref_tips_before_fetch);
6859de45
JK
1083 initialized_fetch_ref_tips = 1;
1084 }
1085
910650d2 1086 oid_array_append(&ref_tips_after_fetch, oid);
6859de45
JK
1087}
1088
6859de45 1089static void calculate_changed_submodule_paths(void)
88a21979 1090{
c1189cae 1091 struct argv_array argv = ARGV_ARRAY_INIT;
aacc5c1a
BW
1092 struct string_list changed_submodules = STRING_LIST_INIT_DUP;
1093 const struct string_list_item *item;
88a21979 1094
18322bad 1095 /* No need to check if there are no submodules configured */
851e18c3 1096 if (!submodule_from_path(NULL, NULL))
18322bad
JL
1097 return;
1098
c1189cae 1099 argv_array_push(&argv, "--"); /* argv[0] program name */
910650d2 1100 oid_array_for_each_unique(&ref_tips_after_fetch,
d1a8460c 1101 append_oid_to_argv, &argv);
c1189cae 1102 argv_array_push(&argv, "--not");
910650d2 1103 oid_array_for_each_unique(&ref_tips_before_fetch,
d1a8460c 1104 append_oid_to_argv, &argv);
88a21979
JL
1105
1106 /*
1107 * Collect all submodules (whether checked out or not) for which new
1108 * commits have been recorded upstream in "changed_submodule_paths".
1109 */
aacc5c1a
BW
1110 collect_changed_submodules(&changed_submodules, &argv);
1111
1112 for_each_string_list_item(item, &changed_submodules) {
1113 struct oid_array *commits = item->util;
1114 const char *path = item->string;
1115
1116 if (!submodule_has_commits(path, commits))
1117 string_list_append(&changed_submodule_paths, path);
88a21979 1118 }
6859de45 1119
aacc5c1a 1120 free_submodules_oids(&changed_submodules);
c1189cae 1121 argv_array_clear(&argv);
910650d2 1122 oid_array_clear(&ref_tips_before_fetch);
1123 oid_array_clear(&ref_tips_after_fetch);
6859de45 1124 initialized_fetch_ref_tips = 0;
88a21979
JL
1125}
1126
a6d7eb2c
SB
1127int submodule_touches_in_range(struct object_id *excl_oid,
1128 struct object_id *incl_oid)
1129{
1130 struct string_list subs = STRING_LIST_INIT_DUP;
1131 struct argv_array args = ARGV_ARRAY_INIT;
1132 int ret;
1133
1134 gitmodules_config();
1135 /* No need to check if there are no submodules configured */
1136 if (!submodule_from_path(NULL, NULL))
1137 return 0;
1138
1139 argv_array_push(&args, "--"); /* args[0] program name */
1140 argv_array_push(&args, oid_to_hex(incl_oid));
1141 argv_array_push(&args, "--not");
1142 argv_array_push(&args, oid_to_hex(excl_oid));
1143
1144 collect_changed_submodules(&subs, &args);
1145 ret = subs.nr;
1146
1147 argv_array_clear(&args);
1148
1149 free_submodules_oids(&subs);
1150 return ret;
1151}
1152
fe85ee6e
SB
1153struct submodule_parallel_fetch {
1154 int count;
1155 struct argv_array args;
1156 const char *work_tree;
1157 const char *prefix;
1158 int command_line_option;
8fa29159 1159 int default_option;
fe85ee6e
SB
1160 int quiet;
1161 int result;
1162};
8fa29159 1163#define SPF_INIT {0, ARGV_ARRAY_INIT, NULL, NULL, 0, 0, 0, 0}
fe85ee6e
SB
1164
1165static int get_next_submodule(struct child_process *cp,
1166 struct strbuf *err, void *data, void **task_cb)
7dce19d3 1167{
fe85ee6e
SB
1168 int ret = 0;
1169 struct submodule_parallel_fetch *spf = data;
6859de45 1170
fe85ee6e 1171 for (; spf->count < active_nr; spf->count++) {
7dce19d3
JL
1172 struct strbuf submodule_path = STRBUF_INIT;
1173 struct strbuf submodule_git_dir = STRBUF_INIT;
1174 struct strbuf submodule_prefix = STRBUF_INIT;
fe85ee6e 1175 const struct cache_entry *ce = active_cache[spf->count];
851e18c3
HV
1176 const char *git_dir, *default_argv;
1177 const struct submodule *submodule;
7dce19d3
JL
1178
1179 if (!S_ISGITLINK(ce->ce_mode))
1180 continue;
1181
851e18c3
HV
1182 submodule = submodule_from_path(null_sha1, ce->name);
1183 if (!submodule)
1184 submodule = submodule_from_name(null_sha1, ce->name);
7dce19d3 1185
88a21979 1186 default_argv = "yes";
fe85ee6e 1187 if (spf->command_line_option == RECURSE_SUBMODULES_DEFAULT) {
851e18c3
HV
1188 if (submodule &&
1189 submodule->fetch_recurse !=
1190 RECURSE_SUBMODULES_NONE) {
1191 if (submodule->fetch_recurse ==
1192 RECURSE_SUBMODULES_OFF)
c1a3c364 1193 continue;
851e18c3
HV
1194 if (submodule->fetch_recurse ==
1195 RECURSE_SUBMODULES_ON_DEMAND) {
bf42b384
JL
1196 if (!unsorted_string_list_lookup(&changed_submodule_paths, ce->name))
1197 continue;
1198 default_argv = "on-demand";
1199 }
c1a3c364 1200 } else {
34e2ba04 1201 if (spf->default_option == RECURSE_SUBMODULES_OFF)
c1a3c364 1202 continue;
8fa29159 1203 if (spf->default_option == RECURSE_SUBMODULES_ON_DEMAND) {
88a21979
JL
1204 if (!unsorted_string_list_lookup(&changed_submodule_paths, ce->name))
1205 continue;
1206 default_argv = "on-demand";
1207 }
c1a3c364 1208 }
fe85ee6e 1209 } else if (spf->command_line_option == RECURSE_SUBMODULES_ON_DEMAND) {
8f0700dd
JL
1210 if (!unsorted_string_list_lookup(&changed_submodule_paths, ce->name))
1211 continue;
1212 default_argv = "on-demand";
be254a0e
JL
1213 }
1214
fe85ee6e 1215 strbuf_addf(&submodule_path, "%s/%s", spf->work_tree, ce->name);
7dce19d3 1216 strbuf_addf(&submodule_git_dir, "%s/.git", submodule_path.buf);
fe85ee6e 1217 strbuf_addf(&submodule_prefix, "%s%s/", spf->prefix, ce->name);
13d6ec91 1218 git_dir = read_gitfile(submodule_git_dir.buf);
7dce19d3
JL
1219 if (!git_dir)
1220 git_dir = submodule_git_dir.buf;
1221 if (is_directory(git_dir)) {
fe85ee6e
SB
1222 child_process_init(cp);
1223 cp->dir = strbuf_detach(&submodule_path, NULL);
c12e8656 1224 prepare_submodule_repo_env(&cp->env_array);
fe85ee6e
SB
1225 cp->git_cmd = 1;
1226 if (!spf->quiet)
1227 strbuf_addf(err, "Fetching submodule %s%s\n",
1228 spf->prefix, ce->name);
1229 argv_array_init(&cp->args);
1230 argv_array_pushv(&cp->args, spf->args.argv);
1231 argv_array_push(&cp->args, default_argv);
1232 argv_array_push(&cp->args, "--submodule-prefix");
1233 argv_array_push(&cp->args, submodule_prefix.buf);
1234 ret = 1;
7dce19d3
JL
1235 }
1236 strbuf_release(&submodule_path);
1237 strbuf_release(&submodule_git_dir);
1238 strbuf_release(&submodule_prefix);
fe85ee6e
SB
1239 if (ret) {
1240 spf->count++;
1241 return 1;
1242 }
7dce19d3 1243 }
fe85ee6e
SB
1244 return 0;
1245}
1246
2a73b3da 1247static int fetch_start_failure(struct strbuf *err,
fe85ee6e
SB
1248 void *cb, void *task_cb)
1249{
1250 struct submodule_parallel_fetch *spf = cb;
1251
1252 spf->result = 1;
1253
1254 return 0;
1255}
1256
2a73b3da
SB
1257static int fetch_finish(int retvalue, struct strbuf *err,
1258 void *cb, void *task_cb)
fe85ee6e
SB
1259{
1260 struct submodule_parallel_fetch *spf = cb;
1261
1262 if (retvalue)
1263 spf->result = 1;
1264
1265 return 0;
1266}
1267
1268int fetch_populated_submodules(const struct argv_array *options,
1269 const char *prefix, int command_line_option,
8fa29159 1270 int default_option,
62104ba1 1271 int quiet, int max_parallel_jobs)
fe85ee6e
SB
1272{
1273 int i;
fe85ee6e
SB
1274 struct submodule_parallel_fetch spf = SPF_INIT;
1275
1276 spf.work_tree = get_git_work_tree();
1277 spf.command_line_option = command_line_option;
8fa29159 1278 spf.default_option = default_option;
fe85ee6e
SB
1279 spf.quiet = quiet;
1280 spf.prefix = prefix;
1281
1282 if (!spf.work_tree)
1283 goto out;
1284
1285 if (read_cache() < 0)
1286 die("index file corrupt");
1287
1288 argv_array_push(&spf.args, "fetch");
1289 for (i = 0; i < options->argc; i++)
1290 argv_array_push(&spf.args, options->argv[i]);
1291 argv_array_push(&spf.args, "--recurse-submodules-default");
1292 /* default value, "--submodule-prefix" and its value are added later */
1293
1294 calculate_changed_submodule_paths();
1295 run_processes_parallel(max_parallel_jobs,
1296 get_next_submodule,
1297 fetch_start_failure,
1298 fetch_finish,
1299 &spf);
1300
1301 argv_array_clear(&spf.args);
88a21979
JL
1302out:
1303 string_list_clear(&changed_submodule_paths, 1);
fe85ee6e 1304 return spf.result;
7dce19d3
JL
1305}
1306
3bfc4504 1307unsigned is_submodule_modified(const char *path, int ignore_untracked)
ee6fc514 1308{
d3180279 1309 struct child_process cp = CHILD_PROCESS_INIT;
ee6fc514 1310 struct strbuf buf = STRBUF_INIT;
af6865a7 1311 FILE *fp;
c7e1a736 1312 unsigned dirty_submodule = 0;
eee49b6c 1313 const char *git_dir;
af6865a7 1314 int ignore_cp_exit_code = 0;
ee6fc514 1315
eee49b6c 1316 strbuf_addf(&buf, "%s/.git", path);
13d6ec91 1317 git_dir = read_gitfile(buf.buf);
eee49b6c
JL
1318 if (!git_dir)
1319 git_dir = buf.buf;
5c896f7c
SB
1320 if (!is_git_directory(git_dir)) {
1321 if (is_directory(git_dir))
1322 die(_("'%s' not recognized as a git repository"), git_dir);
ee6fc514
JL
1323 strbuf_release(&buf);
1324 /* The submodule is not checked out, so it is not modified */
1325 return 0;
ee6fc514
JL
1326 }
1327 strbuf_reset(&buf);
1328
fcecf0b9 1329 argv_array_pushl(&cp.args, "status", "--porcelain=2", NULL);
3bfc4504 1330 if (ignore_untracked)
d0d7fed1 1331 argv_array_push(&cp.args, "-uno");
3bfc4504 1332
c12e8656 1333 prepare_submodule_repo_env(&cp.env_array);
ee6fc514
JL
1334 cp.git_cmd = 1;
1335 cp.no_stdin = 1;
1336 cp.out = -1;
eee49b6c 1337 cp.dir = path;
ee6fc514 1338 if (start_command(&cp))
fcecf0b9 1339 die("Could not run 'git status --porcelain=2' in submodule %s", path);
ee6fc514 1340
af6865a7
SB
1341 fp = xfdopen(cp.out, "r");
1342 while (strbuf_getwholeline(&buf, fp, '\n') != EOF) {
fcecf0b9
SB
1343 /* regular untracked files */
1344 if (buf.buf[0] == '?')
c7e1a736 1345 dirty_submodule |= DIRTY_SUBMODULE_UNTRACKED;
40069d6e
SB
1346
1347 if (buf.buf[0] == 'u' ||
1348 buf.buf[0] == '1' ||
1349 buf.buf[0] == '2') {
1350 /* T = line type, XY = status, SSSS = submodule state */
1351 if (buf.len < strlen("T XY SSSS"))
1352 die("BUG: invalid status --porcelain=2 line %s",
1353 buf.buf);
1354
1355 if (buf.buf[5] == 'S' && buf.buf[8] == 'U')
1356 /* nested untracked file */
1357 dirty_submodule |= DIRTY_SUBMODULE_UNTRACKED;
1358
1359 if (buf.buf[0] == 'u' ||
1360 buf.buf[0] == '2' ||
1361 memcmp(buf.buf + 5, "S..U", 4))
1362 /* other change */
1363 dirty_submodule |= DIRTY_SUBMODULE_MODIFIED;
c7e1a736 1364 }
64f9a946
SB
1365
1366 if ((dirty_submodule & DIRTY_SUBMODULE_MODIFIED) &&
1367 ((dirty_submodule & DIRTY_SUBMODULE_UNTRACKED) ||
af6865a7
SB
1368 ignore_untracked)) {
1369 /*
1370 * We're not interested in any further information from
1371 * the child any more, neither output nor its exit code.
1372 */
1373 ignore_cp_exit_code = 1;
c7e1a736 1374 break;
af6865a7 1375 }
c7e1a736 1376 }
af6865a7 1377 fclose(fp);
ee6fc514 1378
af6865a7 1379 if (finish_command(&cp) && !ignore_cp_exit_code)
fcecf0b9 1380 die("'git status --porcelain=2' failed in submodule %s", path);
ee6fc514 1381
ee6fc514 1382 strbuf_release(&buf);
c7e1a736 1383 return dirty_submodule;
ee6fc514 1384}
68d03e4a 1385
293ab15e
JL
1386int submodule_uses_gitfile(const char *path)
1387{
d3180279 1388 struct child_process cp = CHILD_PROCESS_INIT;
293ab15e
JL
1389 const char *argv[] = {
1390 "submodule",
1391 "foreach",
1392 "--quiet",
1393 "--recursive",
1394 "test -f .git",
1395 NULL,
1396 };
1397 struct strbuf buf = STRBUF_INIT;
1398 const char *git_dir;
1399
1400 strbuf_addf(&buf, "%s/.git", path);
1401 git_dir = read_gitfile(buf.buf);
1402 if (!git_dir) {
1403 strbuf_release(&buf);
1404 return 0;
1405 }
1406 strbuf_release(&buf);
1407
1408 /* Now test that all nested submodules use a gitfile too */
293ab15e 1409 cp.argv = argv;
c12e8656 1410 prepare_submodule_repo_env(&cp.env_array);
293ab15e
JL
1411 cp.git_cmd = 1;
1412 cp.no_stdin = 1;
1413 cp.no_stderr = 1;
1414 cp.no_stdout = 1;
1415 cp.dir = path;
1416 if (run_command(&cp))
1417 return 0;
1418
1419 return 1;
1420}
1421
83b76966
SB
1422/*
1423 * Check if it is a bad idea to remove a submodule, i.e. if we'd lose data
1424 * when doing so.
1425 *
1426 * Return 1 if we'd lose data, return 0 if the removal is fine,
1427 * and negative values for errors.
1428 */
1429int bad_to_remove_submodule(const char *path, unsigned flags)
293ab15e 1430{
293ab15e 1431 ssize_t len;
d3180279 1432 struct child_process cp = CHILD_PROCESS_INIT;
293ab15e 1433 struct strbuf buf = STRBUF_INIT;
83b76966 1434 int ret = 0;
293ab15e 1435
dbe44faa 1436 if (!file_exists(path) || is_empty_dir(path))
83b76966 1437 return 0;
293ab15e
JL
1438
1439 if (!submodule_uses_gitfile(path))
83b76966 1440 return 1;
293ab15e 1441
83b76966 1442 argv_array_pushl(&cp.args, "status", "--porcelain",
5a1c824f 1443 "--ignore-submodules=none", NULL);
83b76966
SB
1444
1445 if (flags & SUBMODULE_REMOVAL_IGNORE_UNTRACKED)
1446 argv_array_push(&cp.args, "-uno");
1447 else
1448 argv_array_push(&cp.args, "-uall");
1449
1450 if (!(flags & SUBMODULE_REMOVAL_IGNORE_IGNORED_UNTRACKED))
1451 argv_array_push(&cp.args, "--ignored");
293ab15e 1452
c12e8656 1453 prepare_submodule_repo_env(&cp.env_array);
293ab15e
JL
1454 cp.git_cmd = 1;
1455 cp.no_stdin = 1;
1456 cp.out = -1;
1457 cp.dir = path;
83b76966
SB
1458 if (start_command(&cp)) {
1459 if (flags & SUBMODULE_REMOVAL_DIE_ON_ERROR)
35ad44cb 1460 die(_("could not start 'git status' in submodule '%s'"),
83b76966
SB
1461 path);
1462 ret = -1;
1463 goto out;
1464 }
293ab15e
JL
1465
1466 len = strbuf_read(&buf, cp.out, 1024);
1467 if (len > 2)
83b76966 1468 ret = 1;
293ab15e
JL
1469 close(cp.out);
1470
83b76966
SB
1471 if (finish_command(&cp)) {
1472 if (flags & SUBMODULE_REMOVAL_DIE_ON_ERROR)
35ad44cb 1473 die(_("could not run 'git status' in submodule '%s'"),
83b76966
SB
1474 path);
1475 ret = -1;
1476 }
1477out:
293ab15e 1478 strbuf_release(&buf);
83b76966 1479 return ret;
293ab15e
JL
1480}
1481
202275b9
SB
1482static const char *get_super_prefix_or_empty(void)
1483{
1484 const char *s = get_super_prefix();
1485 if (!s)
1486 s = "";
1487 return s;
1488}
1489
6e3c1595
SB
1490static int submodule_has_dirty_index(const struct submodule *sub)
1491{
1492 struct child_process cp = CHILD_PROCESS_INIT;
1493
da27bc81 1494 prepare_submodule_repo_env(&cp.env_array);
6e3c1595
SB
1495
1496 cp.git_cmd = 1;
1497 argv_array_pushl(&cp.args, "diff-index", "--quiet",
1498 "--cached", "HEAD", NULL);
1499 cp.no_stdin = 1;
1500 cp.no_stdout = 1;
1501 cp.dir = sub->path;
1502 if (start_command(&cp))
1503 die("could not recurse into submodule '%s'", sub->path);
1504
1505 return finish_command(&cp);
1506}
1507
1508static void submodule_reset_index(const char *path)
1509{
1510 struct child_process cp = CHILD_PROCESS_INIT;
da27bc81 1511 prepare_submodule_repo_env(&cp.env_array);
6e3c1595
SB
1512
1513 cp.git_cmd = 1;
1514 cp.no_stdin = 1;
1515 cp.dir = path;
1516
1517 argv_array_pushf(&cp.args, "--super-prefix=%s%s/",
1518 get_super_prefix_or_empty(), path);
1519 argv_array_pushl(&cp.args, "read-tree", "-u", "--reset", NULL);
1520
1521 argv_array_push(&cp.args, EMPTY_TREE_SHA1_HEX);
1522
1523 if (run_command(&cp))
1524 die("could not reset submodule index");
1525}
1526
1527/**
1528 * Moves a submodule at a given path from a given head to another new head.
1529 * For edge cases (a submodule coming into existence or removing a submodule)
1530 * pass NULL for old or new respectively.
1531 */
1532int submodule_move_head(const char *path,
1533 const char *old,
1534 const char *new,
1535 unsigned flags)
1536{
1537 int ret = 0;
1538 struct child_process cp = CHILD_PROCESS_INIT;
1539 const struct submodule *sub;
f2d48994 1540 int *error_code_ptr, error_code;
6e3c1595 1541
627d9342 1542 if (!is_submodule_active(the_repository, path))
823bab09
SB
1543 return 0;
1544
f2d48994
SB
1545 if (flags & SUBMODULE_MOVE_HEAD_FORCE)
1546 /*
1547 * Pass non NULL pointer to is_submodule_populated_gently
1548 * to prevent die()-ing. We'll use connect_work_tree_and_git_dir
1549 * to fixup the submodule in the force case later.
1550 */
1551 error_code_ptr = &error_code;
1552 else
1553 error_code_ptr = NULL;
1554
1555 if (old && !is_submodule_populated_gently(path, error_code_ptr))
1556 return 0;
6e3c1595
SB
1557
1558 sub = submodule_from_path(null_sha1, path);
1559
1560 if (!sub)
1561 die("BUG: could not get submodule information for '%s'", path);
1562
1563 if (old && !(flags & SUBMODULE_MOVE_HEAD_FORCE)) {
1564 /* Check if the submodule has a dirty index. */
1565 if (submodule_has_dirty_index(sub))
1566 return error(_("submodule '%s' has dirty index"), path);
1567 }
1568
1569 if (!(flags & SUBMODULE_MOVE_HEAD_DRY_RUN)) {
1570 if (old) {
1571 if (!submodule_uses_gitfile(path))
1572 absorb_git_dir_into_superproject("", path,
1573 ABSORB_GITDIR_RECURSE_SUBMODULES);
1574 } else {
f2d48994 1575 char *gitdir = xstrfmt("%s/modules/%s",
6e3c1595 1576 get_git_common_dir(), sub->name);
f2d48994
SB
1577 connect_work_tree_and_git_dir(path, gitdir);
1578 free(gitdir);
6e3c1595
SB
1579
1580 /* make sure the index is clean as well */
1581 submodule_reset_index(path);
1582 }
f2d48994
SB
1583
1584 if (old && (flags & SUBMODULE_MOVE_HEAD_FORCE)) {
1585 char *gitdir = xstrfmt("%s/modules/%s",
1586 get_git_common_dir(), sub->name);
1587 connect_work_tree_and_git_dir(path, gitdir);
1588 free(gitdir);
1589 }
6e3c1595
SB
1590 }
1591
da27bc81 1592 prepare_submodule_repo_env(&cp.env_array);
6e3c1595
SB
1593
1594 cp.git_cmd = 1;
1595 cp.no_stdin = 1;
1596 cp.dir = path;
1597
1598 argv_array_pushf(&cp.args, "--super-prefix=%s%s/",
1599 get_super_prefix_or_empty(), path);
218c8837 1600 argv_array_pushl(&cp.args, "read-tree", "--recurse-submodules", NULL);
6e3c1595
SB
1601
1602 if (flags & SUBMODULE_MOVE_HEAD_DRY_RUN)
1603 argv_array_push(&cp.args, "-n");
1604 else
1605 argv_array_push(&cp.args, "-u");
1606
1607 if (flags & SUBMODULE_MOVE_HEAD_FORCE)
1608 argv_array_push(&cp.args, "--reset");
1609 else
1610 argv_array_push(&cp.args, "-m");
1611
1612 argv_array_push(&cp.args, old ? old : EMPTY_TREE_SHA1_HEX);
1613 argv_array_push(&cp.args, new ? new : EMPTY_TREE_SHA1_HEX);
1614
1615 if (run_command(&cp)) {
1616 ret = -1;
1617 goto out;
1618 }
1619
1620 if (!(flags & SUBMODULE_MOVE_HEAD_DRY_RUN)) {
1621 if (new) {
a17062cf 1622 child_process_init(&cp);
6e3c1595 1623 /* also set the HEAD accordingly */
a17062cf
SB
1624 cp.git_cmd = 1;
1625 cp.no_stdin = 1;
1626 cp.dir = path;
6e3c1595 1627
218c8837 1628 prepare_submodule_repo_env(&cp.env_array);
a17062cf 1629 argv_array_pushl(&cp.args, "update-ref", "HEAD", new, NULL);
6e3c1595 1630
a17062cf 1631 if (run_command(&cp)) {
6e3c1595
SB
1632 ret = -1;
1633 goto out;
1634 }
1635 } else {
1636 struct strbuf sb = STRBUF_INIT;
1637
1638 strbuf_addf(&sb, "%s/.git", path);
1639 unlink_or_warn(sb.buf);
1640 strbuf_release(&sb);
1641
1642 if (is_empty_dir(path))
1643 rmdir_or_warn(path);
1644 }
1645 }
1646out:
1647 return ret;
1648}
1649
68d03e4a
HV
1650static int find_first_merges(struct object_array *result, const char *path,
1651 struct commit *a, struct commit *b)
1652{
1653 int i, j;
3826902d 1654 struct object_array merges = OBJECT_ARRAY_INIT;
68d03e4a
HV
1655 struct commit *commit;
1656 int contains_another;
1657
1658 char merged_revision[42];
1659 const char *rev_args[] = { "rev-list", "--merges", "--ancestry-path",
1660 "--all", merged_revision, NULL };
1661 struct rev_info revs;
1662 struct setup_revision_opt rev_opts;
1663
68d03e4a
HV
1664 memset(result, 0, sizeof(struct object_array));
1665 memset(&rev_opts, 0, sizeof(rev_opts));
1666
1667 /* get all revisions that merge commit a */
1a168e5c 1668 xsnprintf(merged_revision, sizeof(merged_revision), "^%s",
f2fd0760 1669 oid_to_hex(&a->object.oid));
68d03e4a
HV
1670 init_revisions(&revs, NULL);
1671 rev_opts.submodule = path;
94c0cc8f 1672 setup_revisions(ARRAY_SIZE(rev_args)-1, rev_args, &revs, &rev_opts);
68d03e4a
HV
1673
1674 /* save all revisions from the above list that contain b */
1675 if (prepare_revision_walk(&revs))
1676 die("revision walk setup failed");
1677 while ((commit = get_revision(&revs)) != NULL) {
1678 struct object *o = &(commit->object);
a20efee9 1679 if (in_merge_bases(b, commit))
68d03e4a
HV
1680 add_object_array(o, NULL, &merges);
1681 }
bcc0a3ea 1682 reset_revision_walk();
68d03e4a
HV
1683
1684 /* Now we've got all merges that contain a and b. Prune all
1685 * merges that contain another found merge and save them in
1686 * result.
1687 */
1688 for (i = 0; i < merges.nr; i++) {
1689 struct commit *m1 = (struct commit *) merges.objects[i].item;
1690
1691 contains_another = 0;
1692 for (j = 0; j < merges.nr; j++) {
1693 struct commit *m2 = (struct commit *) merges.objects[j].item;
a20efee9 1694 if (i != j && in_merge_bases(m2, m1)) {
68d03e4a
HV
1695 contains_another = 1;
1696 break;
1697 }
1698 }
1699
1700 if (!contains_another)
5de0c015 1701 add_object_array(merges.objects[i].item, NULL, result);
68d03e4a
HV
1702 }
1703
1704 free(merges.objects);
1705 return result->nr;
1706}
1707
1708static void print_commit(struct commit *commit)
1709{
1710 struct strbuf sb = STRBUF_INIT;
1711 struct pretty_print_context ctx = {0};
a5481a6c 1712 ctx.date_mode.type = DATE_NORMAL;
68d03e4a
HV
1713 format_commit_message(commit, " %h: %m %s", &sb, &ctx);
1714 fprintf(stderr, "%s\n", sb.buf);
1715 strbuf_release(&sb);
1716}
1717
1718#define MERGE_WARNING(path, msg) \
1719 warning("Failed to merge submodule %s (%s)", path, msg);
1720
71f35d5c 1721int merge_submodule(struct object_id *result, const char *path,
1722 const struct object_id *base, const struct object_id *a,
1723 const struct object_id *b, int search)
68d03e4a
HV
1724{
1725 struct commit *commit_base, *commit_a, *commit_b;
1726 int parent_count;
1727 struct object_array merges;
1728
1729 int i;
1730
1731 /* store a in result in case we fail */
71f35d5c 1732 oidcpy(result, a);
68d03e4a
HV
1733
1734 /* we can not handle deletion conflicts */
71f35d5c 1735 if (is_null_oid(base))
68d03e4a 1736 return 0;
71f35d5c 1737 if (is_null_oid(a))
68d03e4a 1738 return 0;
71f35d5c 1739 if (is_null_oid(b))
68d03e4a
HV
1740 return 0;
1741
1742 if (add_submodule_odb(path)) {
1743 MERGE_WARNING(path, "not checked out");
1744 return 0;
1745 }
1746
1747 if (!(commit_base = lookup_commit_reference(base)) ||
1748 !(commit_a = lookup_commit_reference(a)) ||
1749 !(commit_b = lookup_commit_reference(b))) {
1750 MERGE_WARNING(path, "commits not present");
1751 return 0;
1752 }
1753
1754 /* check whether both changes are forward */
a20efee9
JH
1755 if (!in_merge_bases(commit_base, commit_a) ||
1756 !in_merge_bases(commit_base, commit_b)) {
68d03e4a
HV
1757 MERGE_WARNING(path, "commits don't follow merge-base");
1758 return 0;
1759 }
1760
1761 /* Case #1: a is contained in b or vice versa */
a20efee9 1762 if (in_merge_bases(commit_a, commit_b)) {
71f35d5c 1763 oidcpy(result, b);
68d03e4a
HV
1764 return 1;
1765 }
a20efee9 1766 if (in_merge_bases(commit_b, commit_a)) {
71f35d5c 1767 oidcpy(result, a);
68d03e4a
HV
1768 return 1;
1769 }
1770
1771 /*
1772 * Case #2: There are one or more merges that contain a and b in
1773 * the submodule. If there is only one, then present it as a
1774 * suggestion to the user, but leave it marked unmerged so the
1775 * user needs to confirm the resolution.
1776 */
1777
80988783
BK
1778 /* Skip the search if makes no sense to the calling context. */
1779 if (!search)
1780 return 0;
1781
68d03e4a
HV
1782 /* find commit which merges them */
1783 parent_count = find_first_merges(&merges, path, commit_a, commit_b);
1784 switch (parent_count) {
1785 case 0:
1786 MERGE_WARNING(path, "merge following commits not found");
1787 break;
1788
1789 case 1:
1790 MERGE_WARNING(path, "not fast-forward");
1791 fprintf(stderr, "Found a possible merge resolution "
1792 "for the submodule:\n");
1793 print_commit((struct commit *) merges.objects[0].item);
1794 fprintf(stderr,
1795 "If this is correct simply add it to the index "
1796 "for example\n"
1797 "by using:\n\n"
1798 " git update-index --cacheinfo 160000 %s \"%s\"\n\n"
1799 "which will accept this suggestion.\n",
f2fd0760 1800 oid_to_hex(&merges.objects[0].item->oid), path);
68d03e4a
HV
1801 break;
1802
1803 default:
1804 MERGE_WARNING(path, "multiple merges found");
1805 for (i = 0; i < merges.nr; i++)
1806 print_commit((struct commit *) merges.objects[i].item);
1807 }
1808
1809 free(merges.objects);
1810 return 0;
1811}
a88c915d 1812
f6f85861
SB
1813/*
1814 * Embeds a single submodules git directory into the superprojects git dir,
1815 * non recursively.
1816 */
1817static void relocate_single_git_dir_into_superproject(const char *prefix,
1818 const char *path)
1819{
1820 char *old_git_dir = NULL, *real_old_git_dir = NULL, *real_new_git_dir = NULL;
1821 const char *new_git_dir;
1822 const struct submodule *sub;
1823
1824 if (submodule_uses_worktrees(path))
1825 die(_("relocate_gitdir for submodule '%s' with "
1826 "more than one worktree not supported"), path);
1827
1828 old_git_dir = xstrfmt("%s/.git", path);
1829 if (read_gitfile(old_git_dir))
1830 /* If it is an actual gitfile, it doesn't need migration. */
1831 return;
1832
ce83eadd 1833 real_old_git_dir = real_pathdup(old_git_dir, 1);
f6f85861
SB
1834
1835 sub = submodule_from_path(null_sha1, path);
1836 if (!sub)
1837 die(_("could not lookup name for submodule '%s'"), path);
1838
1839 new_git_dir = git_path("modules/%s", sub->name);
1840 if (safe_create_leading_directories_const(new_git_dir) < 0)
1841 die(_("could not create directory '%s'"), new_git_dir);
ce83eadd 1842 real_new_git_dir = real_pathdup(new_git_dir, 1);
f6f85861 1843
f6f85861 1844 fprintf(stderr, _("Migrating git directory of '%s%s' from\n'%s' to\n'%s'\n"),
202275b9 1845 get_super_prefix_or_empty(), path,
f6f85861
SB
1846 real_old_git_dir, real_new_git_dir);
1847
1848 relocate_gitdir(path, real_old_git_dir, real_new_git_dir);
1849
1850 free(old_git_dir);
1851 free(real_old_git_dir);
1852 free(real_new_git_dir);
1853}
1854
1855/*
1856 * Migrate the git directory of the submodule given by path from
1857 * having its git directory within the working tree to the git dir nested
1858 * in its superprojects git dir under modules/.
1859 */
1860void absorb_git_dir_into_superproject(const char *prefix,
1861 const char *path,
1862 unsigned flags)
1863{
ec9629b3
SB
1864 int err_code;
1865 const char *sub_git_dir;
f6f85861 1866 struct strbuf gitdir = STRBUF_INIT;
f6f85861 1867 strbuf_addf(&gitdir, "%s/.git", path);
ec9629b3 1868 sub_git_dir = resolve_gitdir_gently(gitdir.buf, &err_code);
f6f85861
SB
1869
1870 /* Not populated? */
ec9629b3 1871 if (!sub_git_dir) {
ec9629b3
SB
1872 const struct submodule *sub;
1873
1874 if (err_code == READ_GITFILE_ERR_STAT_FAILED) {
1875 /* unpopulated as expected */
1876 strbuf_release(&gitdir);
1877 return;
1878 }
1879
1880 if (err_code != READ_GITFILE_ERR_NOT_A_REPO)
1881 /* We don't know what broke here. */
1882 read_gitfile_error_die(err_code, path, NULL);
1883
1884 /*
1885 * Maybe populated, but no git directory was found?
1886 * This can happen if the superproject is a submodule
1887 * itself and was just absorbed. The absorption of the
1888 * superproject did not rewrite the git file links yet,
1889 * fix it now.
1890 */
1891 sub = submodule_from_path(null_sha1, path);
1892 if (!sub)
1893 die(_("could not lookup name for submodule '%s'"), path);
365444a6
SB
1894 connect_work_tree_and_git_dir(path,
1895 git_path("modules/%s", sub->name));
ec9629b3
SB
1896 } else {
1897 /* Is it already absorbed into the superprojects git dir? */
ce83eadd
JS
1898 char *real_sub_git_dir = real_pathdup(sub_git_dir, 1);
1899 char *real_common_git_dir = real_pathdup(get_git_common_dir(), 1);
f6f85861 1900
ec9629b3
SB
1901 if (!starts_with(real_sub_git_dir, real_common_git_dir))
1902 relocate_single_git_dir_into_superproject(prefix, path);
1903
1904 free(real_sub_git_dir);
1905 free(real_common_git_dir);
1906 }
1907 strbuf_release(&gitdir);
f6f85861
SB
1908
1909 if (flags & ABSORB_GITDIR_RECURSE_SUBMODULES) {
1910 struct child_process cp = CHILD_PROCESS_INIT;
1911 struct strbuf sb = STRBUF_INIT;
1912
1913 if (flags & ~ABSORB_GITDIR_RECURSE_SUBMODULES)
1914 die("BUG: we don't know how to pass the flags down?");
1915
202275b9 1916 strbuf_addstr(&sb, get_super_prefix_or_empty());
f6f85861
SB
1917 strbuf_addstr(&sb, path);
1918 strbuf_addch(&sb, '/');
1919
1920 cp.dir = path;
1921 cp.git_cmd = 1;
1922 cp.no_stdin = 1;
1923 argv_array_pushl(&cp.args, "--super-prefix", sb.buf,
1924 "submodule--helper",
1925 "absorb-git-dirs", NULL);
1926 prepare_submodule_repo_env(&cp.env_array);
1927 if (run_command(&cp))
1928 die(_("could not recurse into submodule '%s'"), path);
1929
1930 strbuf_release(&sb);
1931 }
f6f85861 1932}
bf0231c6
SB
1933
1934const char *get_superproject_working_tree(void)
1935{
1936 struct child_process cp = CHILD_PROCESS_INIT;
1937 struct strbuf sb = STRBUF_INIT;
1938 const char *one_up = real_path_if_valid("../");
1939 const char *cwd = xgetcwd();
1940 const char *ret = NULL;
1941 const char *subpath;
1942 int code;
1943 ssize_t len;
1944
1945 if (!is_inside_work_tree())
1946 /*
1947 * FIXME:
1948 * We might have a superproject, but it is harder
1949 * to determine.
1950 */
1951 return NULL;
1952
1953 if (!one_up)
1954 return NULL;
1955
1956 subpath = relative_path(cwd, one_up, &sb);
1957
1958 prepare_submodule_repo_env(&cp.env_array);
1959 argv_array_pop(&cp.env_array);
1960
1961 argv_array_pushl(&cp.args, "--literal-pathspecs", "-C", "..",
1962 "ls-files", "-z", "--stage", "--full-name", "--",
1963 subpath, NULL);
1964 strbuf_reset(&sb);
1965
1966 cp.no_stdin = 1;
1967 cp.no_stderr = 1;
1968 cp.out = -1;
1969 cp.git_cmd = 1;
1970
1971 if (start_command(&cp))
1972 die(_("could not start ls-files in .."));
1973
1974 len = strbuf_read(&sb, cp.out, PATH_MAX);
1975 close(cp.out);
1976
1977 if (starts_with(sb.buf, "160000")) {
1978 int super_sub_len;
1979 int cwd_len = strlen(cwd);
1980 char *super_sub, *super_wt;
1981
1982 /*
1983 * There is a superproject having this repo as a submodule.
1984 * The format is <mode> SP <hash> SP <stage> TAB <full name> \0,
1985 * We're only interested in the name after the tab.
1986 */
1987 super_sub = strchr(sb.buf, '\t') + 1;
1988 super_sub_len = sb.buf + sb.len - super_sub - 1;
1989
1990 if (super_sub_len > cwd_len ||
1991 strcmp(&cwd[cwd_len - super_sub_len], super_sub))
1992 die (_("BUG: returned path string doesn't match cwd?"));
1993
1994 super_wt = xstrdup(cwd);
1995 super_wt[cwd_len - super_sub_len] = '\0';
1996
1997 ret = real_path(super_wt);
1998 free(super_wt);
1999 }
2000 strbuf_release(&sb);
2001
2002 code = finish_command(&cp);
2003
2004 if (code == 128)
2005 /* '../' is not a git repository */
2006 return NULL;
2007 if (code == 0 && len == 0)
2008 /* There is an unrelated git repository at '../' */
2009 return NULL;
2010 if (code)
2011 die(_("ls-tree returned unexpected return code %d"), code);
2012
2013 return ret;
2014}
bbbb7de7
NTND
2015
2016int submodule_to_gitdir(struct strbuf *buf, const char *submodule)
2017{
2018 const struct submodule *sub;
2019 const char *git_dir;
2020 int ret = 0;
2021
2022 strbuf_reset(buf);
2023 strbuf_addstr(buf, submodule);
2024 strbuf_complete(buf, '/');
2025 strbuf_addstr(buf, ".git");
2026
2027 git_dir = read_gitfile(buf->buf);
2028 if (git_dir) {
2029 strbuf_reset(buf);
2030 strbuf_addstr(buf, git_dir);
2031 }
2032 if (!is_git_directory(buf->buf)) {
2033 gitmodules_config();
2034 sub = submodule_from_path(null_sha1, submodule);
2035 if (!sub) {
2036 ret = -1;
2037 goto cleanup;
2038 }
2039 strbuf_reset(buf);
2040 strbuf_git_path(buf, "%s/%s", "modules", sub->name);
2041 }
2042
2043cleanup:
2044 return ret;
2045}