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