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