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