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