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