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