?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
pack-bitmap: improve grammar of "xor chain" error message
[git/debian.git] / builtin / submodule--helper.c
blobb63f420ecef3c8f53b6043b7fdacacc945bd99bb
1 #define USE_THE_INDEX_COMPATIBILITY_MACROS
2 #include "builtin.h"
3 #include "repository.h"
4 #include "cache.h"
5 #include "config.h"
6 #include "parse-options.h"
7 #include "quote.h"
8 #include "pathspec.h"
9 #include "dir.h"
10 #include "submodule.h"
11 #include "submodule-config.h"
12 #include "string-list.h"
13 #include "run-command.h"
14 #include "remote.h"
15 #include "refs.h"
16 #include "refspec.h"
17 #include "connect.h"
18 #include "revision.h"
19 #include "diffcore.h"
20 #include "diff.h"
21 #include "object-store.h"
22 #include "advice.h"
23 #include "branch.h"
24 #include "list-objects-filter-options.h"
25
26 #define OPT_QUIET (1 << 0)
27 #define OPT_CACHED (1 << 1)
28 #define OPT_RECURSIVE (1 << 2)
29 #define OPT_FORCE (1 << 3)
30
31 typedef void (*each_submodule_fn)(const struct cache_entry *list_item,
32 void *cb_data);
33
34 static char *repo_get_default_remote(struct repository *repo)
35 {
36 char *dest = NULL, *ret;
37 struct strbuf sb = STRBUF_INIT;
38 struct ref_store *store = get_main_ref_store(repo);
39 const char *refname = refs_resolve_ref_unsafe(store, "HEAD", 0, NULL,
40 NULL);
41
42 if (!refname)
43 die(_("No such ref: %s"), "HEAD");
44
45 /* detached HEAD */
46 if (!strcmp(refname, "HEAD"))
47 return xstrdup("origin");
48
49 if (!skip_prefix(refname, "refs/heads/", &refname))
50 die(_("Expecting a full ref name, got %s"), refname);
51
52 strbuf_addf(&sb, "branch.%s.remote", refname);
53 if (repo_config_get_string(repo, sb.buf, &dest))
54 ret = xstrdup("origin");
55 else
56 ret = dest;
57
58 strbuf_release(&sb);
59 return ret;
60 }
61
62 static char *get_default_remote_submodule(const char *module_path)
63 {
64 struct repository subrepo;
65
66 repo_submodule_init(&subrepo, the_repository, module_path, null_oid());
67 return repo_get_default_remote(&subrepo);
68 }
69
70 static char *get_default_remote(void)
71 {
72 return repo_get_default_remote(the_repository);
73 }
74
75 static char *resolve_relative_url(const char *rel_url, const char *up_path, int quiet)
76 {
77 char *remoteurl, *resolved_url;
78 char *remote = get_default_remote();
79 struct strbuf remotesb = STRBUF_INIT;
80
81 strbuf_addf(&remotesb, "remote.%s.url", remote);
82 if (git_config_get_string(remotesb.buf, &remoteurl)) {
83 if (!quiet)
84 warning(_("could not look up configuration '%s'. "
85 "Assuming this repository is its own "
86 "authoritative upstream."),
87 remotesb.buf);
88 remoteurl = xgetcwd();
89 }
90 resolved_url = relative_url(remoteurl, rel_url, up_path);
91
92 free(remote);
93 free(remoteurl);
94 strbuf_release(&remotesb);
95
96 return resolved_url;
97 }
98
99 static int resolve_relative_url_test(int argc, const char **argv, const char *prefix)
100 {
101 char *remoteurl, *res;
102 const char *up_path, *url;
103
104 if (argc != 4)
105 die("resolve-relative-url-test only accepts three arguments: <up_path> <remoteurl> <url>");
106
107 up_path = argv[1];
108 remoteurl = xstrdup(argv[2]);
109 url = argv[3];
110
111 if (!strcmp(up_path, "(null)"))
112 up_path = NULL;
113
114 res = relative_url(remoteurl, url, up_path);
115 puts(res);
116 free(res);
117 free(remoteurl);
118 return 0;
119 }
120
121 /* the result should be freed by the caller. */
122 static char *get_submodule_displaypath(const char *path, const char *prefix)
123 {
124 const char *super_prefix = get_super_prefix();
125
126 if (prefix && super_prefix) {
127 BUG("cannot have prefix '%s' and superprefix '%s'",
128 prefix, super_prefix);
129 } else if (prefix) {
130 struct strbuf sb = STRBUF_INIT;
131 char *displaypath = xstrdup(relative_path(path, prefix, &sb));
132 strbuf_release(&sb);
133 return displaypath;
134 } else if (super_prefix) {
135 return xstrfmt("%s%s", super_prefix, path);
136 } else {
137 return xstrdup(path);
138 }
139 }
140
141 static char *compute_rev_name(const char *sub_path, const char* object_id)
142 {
143 struct strbuf sb = STRBUF_INIT;
144 const char ***d;
145
146 static const char *describe_bare[] = { NULL };
147
148 static const char *describe_tags[] = { "--tags", NULL };
149
150 static const char *describe_contains[] = { "--contains", NULL };
151
152 static const char *describe_all_always[] = { "--all", "--always", NULL };
153
154 static const char **describe_argv[] = { describe_bare, describe_tags,
155 describe_contains,
156 describe_all_always, NULL };
157
158 for (d = describe_argv; *d; d++) {
159 struct child_process cp = CHILD_PROCESS_INIT;
160 prepare_submodule_repo_env(&cp.env);
161 cp.dir = sub_path;
162 cp.git_cmd = 1;
163 cp.no_stderr = 1;
164
165 strvec_push(&cp.args, "describe");
166 strvec_pushv(&cp.args, *d);
167 strvec_push(&cp.args, object_id);
168
169 if (!capture_command(&cp, &sb, 0)) {
170 strbuf_strip_suffix(&sb, "\n");
171 return strbuf_detach(&sb, NULL);
172 }
173 }
174
175 strbuf_release(&sb);
176 return NULL;
177 }
178
179 struct module_list {
180 const struct cache_entry **entries;
181 int alloc, nr;
182 };
183 #define MODULE_LIST_INIT { 0 }
184
185 static int module_list_compute(int argc, const char **argv,
186 const char *prefix,
187 struct pathspec *pathspec,
188 struct module_list *list)
189 {
190 int i, result = 0;
191 char *ps_matched = NULL;
192 parse_pathspec(pathspec, 0,
193 PATHSPEC_PREFER_FULL,
194 prefix, argv);
195
196 if (pathspec->nr)
197 ps_matched = xcalloc(pathspec->nr, 1);
198
199 if (read_cache() < 0)
200 die(_("index file corrupt"));
201
202 for (i = 0; i < active_nr; i++) {
203 const struct cache_entry *ce = active_cache[i];
204
205 if (!match_pathspec(&the_index, pathspec, ce->name, ce_namelen(ce),
206 0, ps_matched, 1) ||
207 !S_ISGITLINK(ce->ce_mode))
208 continue;
209
210 ALLOC_GROW(list->entries, list->nr + 1, list->alloc);
211 list->entries[list->nr++] = ce;
212 while (i + 1 < active_nr &&
213 !strcmp(ce->name, active_cache[i + 1]->name))
214 /*
215 * Skip entries with the same name in different stages
216 * to make sure an entry is returned only once.
217 */
218 i++;
219 }
220
221 if (ps_matched && report_path_error(ps_matched, pathspec))
222 result = -1;
223
224 free(ps_matched);
225
226 return result;
227 }
228
229 static void module_list_active(struct module_list *list)
230 {
231 int i;
232 struct module_list active_modules = MODULE_LIST_INIT;
233
234 for (i = 0; i < list->nr; i++) {
235 const struct cache_entry *ce = list->entries[i];
236
237 if (!is_submodule_active(the_repository, ce->name))
238 continue;
239
240 ALLOC_GROW(active_modules.entries,
241 active_modules.nr + 1,
242 active_modules.alloc);
243 active_modules.entries[active_modules.nr++] = ce;
244 }
245
246 free(list->entries);
247 *list = active_modules;
248 }
249
250 static char *get_up_path(const char *path)
251 {
252 int i;
253 struct strbuf sb = STRBUF_INIT;
254
255 for (i = count_slashes(path); i; i--)
256 strbuf_addstr(&sb, "../");
257
258 /*
259 * Check if 'path' ends with slash or not
260 * for having the same output for dir/sub_dir
261 * and dir/sub_dir/
262 */
263 if (!is_dir_sep(path[strlen(path) - 1]))
264 strbuf_addstr(&sb, "../");
265
266 return strbuf_detach(&sb, NULL);
267 }
268
269 static int module_list(int argc, const char **argv, const char *prefix)
270 {
271 int i;
272 struct pathspec pathspec;
273 struct module_list list = MODULE_LIST_INIT;
274
275 struct option module_list_options[] = {
276 OPT_STRING(0, "prefix", &prefix,
277 N_("path"),
278 N_("alternative anchor for relative paths")),
279 OPT_END()
280 };
281
282 const char *const git_submodule_helper_usage[] = {
283 N_("git submodule--helper list [--prefix=<path>] [<path>...]"),
284 NULL
285 };
286
287 argc = parse_options(argc, argv, prefix, module_list_options,
288 git_submodule_helper_usage, 0);
289
290 if (module_list_compute(argc, argv, prefix, &pathspec, &list) < 0)
291 return 1;
292
293 for (i = 0; i < list.nr; i++) {
294 const struct cache_entry *ce = list.entries[i];
295
296 if (ce_stage(ce))
297 printf("%06o %s U\t", ce->ce_mode,
298 oid_to_hex(null_oid()));
299 else
300 printf("%06o %s %d\t", ce->ce_mode,
301 oid_to_hex(&ce->oid), ce_stage(ce));
302
303 fprintf(stdout, "%s\n", ce->name);
304 }
305 return 0;
306 }
307
308 static void for_each_listed_submodule(const struct module_list *list,
309 each_submodule_fn fn, void *cb_data)
310 {
311 int i;
312 for (i = 0; i < list->nr; i++)
313 fn(list->entries[i], cb_data);
314 }
315
316 struct foreach_cb {
317 int argc;
318 const char **argv;
319 const char *prefix;
320 int quiet;
321 int recursive;
322 };
323 #define FOREACH_CB_INIT { 0 }
324
325 static void runcommand_in_submodule_cb(const struct cache_entry *list_item,
326 void *cb_data)
327 {
328 struct foreach_cb *info = cb_data;
329 const char *path = list_item->name;
330 const struct object_id *ce_oid = &list_item->oid;
331
332 const struct submodule *sub;
333 struct child_process cp = CHILD_PROCESS_INIT;
334 char *displaypath;
335
336 displaypath = get_submodule_displaypath(path, info->prefix);
337
338 sub = submodule_from_path(the_repository, null_oid(), path);
339
340 if (!sub)
341 die(_("No url found for submodule path '%s' in .gitmodules"),
342 displaypath);
343
344 if (!is_submodule_populated_gently(path, NULL))
345 goto cleanup;
346
347 prepare_submodule_repo_env(&cp.env);
348
349 /*
350 * For the purpose of executing <command> in the submodule,
351 * separate shell is used for the purpose of running the
352 * child process.
353 */
354 cp.use_shell = 1;
355 cp.dir = path;
356
357 /*
358 * NEEDSWORK: the command currently has access to the variables $name,
359 * $sm_path, $displaypath, $sha1 and $toplevel only when the command
360 * contains a single argument. This is done for maintaining a faithful
361 * translation from shell script.
362 */
363 if (info->argc == 1) {
364 char *toplevel = xgetcwd();
365 struct strbuf sb = STRBUF_INIT;
366
367 strvec_pushf(&cp.env, "name=%s", sub->name);
368 strvec_pushf(&cp.env, "sm_path=%s", path);
369 strvec_pushf(&cp.env, "displaypath=%s", displaypath);
370 strvec_pushf(&cp.env, "sha1=%s",
371 oid_to_hex(ce_oid));
372 strvec_pushf(&cp.env, "toplevel=%s", toplevel);
373
374 /*
375 * Since the path variable was accessible from the script
376 * before porting, it is also made available after porting.
377 * The environment variable "PATH" has a very special purpose
378 * on windows. And since environment variables are
379 * case-insensitive in windows, it interferes with the
380 * existing PATH variable. Hence, to avoid that, we expose
381 * path via the args strvec and not via env.
382 */
383 sq_quote_buf(&sb, path);
384 strvec_pushf(&cp.args, "path=%s; %s",
385 sb.buf, info->argv[0]);
386 strbuf_release(&sb);
387 free(toplevel);
388 } else {
389 strvec_pushv(&cp.args, info->argv);
390 }
391
392 if (!info->quiet)
393 printf(_("Entering '%s'\n"), displaypath);
394
395 if (info->argv[0] && run_command(&cp))
396 die(_("run_command returned non-zero status for %s\n."),
397 displaypath);
398
399 if (info->recursive) {
400 struct child_process cpr = CHILD_PROCESS_INIT;
401
402 cpr.git_cmd = 1;
403 cpr.dir = path;
404 prepare_submodule_repo_env(&cpr.env);
405
406 strvec_pushl(&cpr.args, "--super-prefix", NULL);
407 strvec_pushf(&cpr.args, "%s/", displaypath);
408 strvec_pushl(&cpr.args, "submodule--helper", "foreach", "--recursive",
409 NULL);
410
411 if (info->quiet)
412 strvec_push(&cpr.args, "--quiet");
413
414 strvec_push(&cpr.args, "--");
415 strvec_pushv(&cpr.args, info->argv);
416
417 if (run_command(&cpr))
418 die(_("run_command returned non-zero status while "
419 "recursing in the nested submodules of %s\n."),
420 displaypath);
421 }
422
423 cleanup:
424 free(displaypath);
425 }
426
427 static int module_foreach(int argc, const char **argv, const char *prefix)
428 {
429 struct foreach_cb info = FOREACH_CB_INIT;
430 struct pathspec pathspec;
431 struct module_list list = MODULE_LIST_INIT;
432
433 struct option module_foreach_options[] = {
434 OPT__QUIET(&info.quiet, N_("suppress output of entering each submodule command")),
435 OPT_BOOL(0, "recursive", &info.recursive,
436 N_("recurse into nested submodules")),
437 OPT_END()
438 };
439
440 const char *const git_submodule_helper_usage[] = {
441 N_("git submodule foreach [--quiet] [--recursive] [--] <command>"),
442 NULL
443 };
444
445 argc = parse_options(argc, argv, prefix, module_foreach_options,
446 git_submodule_helper_usage, 0);
447
448 if (module_list_compute(0, NULL, prefix, &pathspec, &list) < 0)
449 return 1;
450
451 info.argc = argc;
452 info.argv = argv;
453 info.prefix = prefix;
454
455 for_each_listed_submodule(&list, runcommand_in_submodule_cb, &info);
456
457 return 0;
458 }
459
460 static int starts_with_dot_slash(const char *const path)
461 {
462 return path_match_flags(path, PATH_MATCH_STARTS_WITH_DOT_SLASH |
463 PATH_MATCH_XPLATFORM);
464 }
465
466 static int starts_with_dot_dot_slash(const char *const path)
467 {
468 return path_match_flags(path, PATH_MATCH_STARTS_WITH_DOT_DOT_SLASH |
469 PATH_MATCH_XPLATFORM);
470 }
471
472 struct init_cb {
473 const char *prefix;
474 unsigned int flags;
475 };
476 #define INIT_CB_INIT { 0 }
477
478 static void init_submodule(const char *path, const char *prefix,
479 unsigned int flags)
480 {
481 const struct submodule *sub;
482 struct strbuf sb = STRBUF_INIT;
483 char *upd = NULL, *url = NULL, *displaypath;
484
485 displaypath = get_submodule_displaypath(path, prefix);
486
487 sub = submodule_from_path(the_repository, null_oid(), path);
488
489 if (!sub)
490 die(_("No url found for submodule path '%s' in .gitmodules"),
491 displaypath);
492
493 /*
494 * NEEDSWORK: In a multi-working-tree world, this needs to be
495 * set in the per-worktree config.
496 *
497 * Set active flag for the submodule being initialized
498 */
499 if (!is_submodule_active(the_repository, path)) {
500 strbuf_addf(&sb, "submodule.%s.active", sub->name);
501 git_config_set_gently(sb.buf, "true");
502 strbuf_reset(&sb);
503 }
504
505 /*
506 * Copy url setting when it is not set yet.
507 * To look up the url in .git/config, we must not fall back to
508 * .gitmodules, so look it up directly.
509 */
510 strbuf_addf(&sb, "submodule.%s.url", sub->name);
511 if (git_config_get_string(sb.buf, &url)) {
512 if (!sub->url)
513 die(_("No url found for submodule path '%s' in .gitmodules"),
514 displaypath);
515
516 url = xstrdup(sub->url);
517
518 /* Possibly a url relative to parent */
519 if (starts_with_dot_dot_slash(url) ||
520 starts_with_dot_slash(url)) {
521 char *oldurl = url;
522 url = resolve_relative_url(oldurl, NULL, 0);
523 free(oldurl);
524 }
525
526 if (git_config_set_gently(sb.buf, url))
527 die(_("Failed to register url for submodule path '%s'"),
528 displaypath);
529 if (!(flags & OPT_QUIET))
530 fprintf(stderr,
531 _("Submodule '%s' (%s) registered for path '%s'\n"),
532 sub->name, url, displaypath);
533 }
534 strbuf_reset(&sb);
535
536 /* Copy "update" setting when it is not set yet */
537 strbuf_addf(&sb, "submodule.%s.update", sub->name);
538 if (git_config_get_string(sb.buf, &upd) &&
539 sub->update_strategy.type != SM_UPDATE_UNSPECIFIED) {
540 if (sub->update_strategy.type == SM_UPDATE_COMMAND) {
541 fprintf(stderr, _("warning: command update mode suggested for submodule '%s'\n"),
542 sub->name);
543 upd = xstrdup("none");
544 } else
545 upd = xstrdup(submodule_strategy_to_string(&sub->update_strategy));
546
547 if (git_config_set_gently(sb.buf, upd))
548 die(_("Failed to register update mode for submodule path '%s'"), displaypath);
549 }
550 strbuf_release(&sb);
551 free(displaypath);
552 free(url);
553 free(upd);
554 }
555
556 static void init_submodule_cb(const struct cache_entry *list_item, void *cb_data)
557 {
558 struct init_cb *info = cb_data;
559 init_submodule(list_item->name, info->prefix, info->flags);
560 }
561
562 static int module_init(int argc, const char **argv, const char *prefix)
563 {
564 struct init_cb info = INIT_CB_INIT;
565 struct pathspec pathspec;
566 struct module_list list = MODULE_LIST_INIT;
567 int quiet = 0;
568
569 struct option module_init_options[] = {
570 OPT__QUIET(&quiet, N_("suppress output for initializing a submodule")),
571 OPT_END()
572 };
573
574 const char *const git_submodule_helper_usage[] = {
575 N_("git submodule init [<options>] [<path>]"),
576 NULL
577 };
578
579 argc = parse_options(argc, argv, prefix, module_init_options,
580 git_submodule_helper_usage, 0);
581
582 if (module_list_compute(argc, argv, prefix, &pathspec, &list) < 0)
583 return 1;
584
585 /*
586 * If there are no path args and submodule.active is set then,
587 * by default, only initialize 'active' modules.
588 */
589 if (!argc && git_config_get_value_multi("submodule.active"))
590 module_list_active(&list);
591
592 info.prefix = prefix;
593 if (quiet)
594 info.flags |= OPT_QUIET;
595
596 for_each_listed_submodule(&list, init_submodule_cb, &info);
597
598 return 0;
599 }
600
601 struct status_cb {
602 const char *prefix;
603 unsigned int flags;
604 };
605 #define STATUS_CB_INIT { 0 }
606
607 static void print_status(unsigned int flags, char state, const char *path,
608 const struct object_id *oid, const char *displaypath)
609 {
610 if (flags & OPT_QUIET)
611 return;
612
613 printf("%c%s %s", state, oid_to_hex(oid), displaypath);
614
615 if (state == ' ' || state == '+') {
616 const char *name = compute_rev_name(path, oid_to_hex(oid));
617
618 if (name)
619 printf(" (%s)", name);
620 }
621
622 printf("\n");
623 }
624
625 static int handle_submodule_head_ref(const char *refname,
626 const struct object_id *oid, int flags,
627 void *cb_data)
628 {
629 struct object_id *output = cb_data;
630 if (oid)
631 oidcpy(output, oid);
632
633 return 0;
634 }
635
636 static void status_submodule(const char *path, const struct object_id *ce_oid,
637 unsigned int ce_flags, const char *prefix,
638 unsigned int flags)
639 {
640 char *displaypath;
641 struct strvec diff_files_args = STRVEC_INIT;
642 struct rev_info rev = REV_INFO_INIT;
643 int diff_files_result;
644 struct strbuf buf = STRBUF_INIT;
645 const char *git_dir;
646
647 if (!submodule_from_path(the_repository, null_oid(), path))
648 die(_("no submodule mapping found in .gitmodules for path '%s'"),
649 path);
650
651 displaypath = get_submodule_displaypath(path, prefix);
652
653 if ((CE_STAGEMASK & ce_flags) >> CE_STAGESHIFT) {
654 print_status(flags, 'U', path, null_oid(), displaypath);
655 goto cleanup;
656 }
657
658 strbuf_addf(&buf, "%s/.git", path);
659 git_dir = read_gitfile(buf.buf);
660 if (!git_dir)
661 git_dir = buf.buf;
662
663 if (!is_submodule_active(the_repository, path) ||
664 !is_git_directory(git_dir)) {
665 print_status(flags, '-', path, ce_oid, displaypath);
666 strbuf_release(&buf);
667 goto cleanup;
668 }
669 strbuf_release(&buf);
670
671 strvec_pushl(&diff_files_args, "diff-files",
672 "--ignore-submodules=dirty", "--quiet", "--",
673 path, NULL);
674
675 git_config(git_diff_basic_config, NULL);
676
677 repo_init_revisions(the_repository, &rev, NULL);
678 rev.abbrev = 0;
679 diff_files_args.nr = setup_revisions(diff_files_args.nr,
680 diff_files_args.v,
681 &rev, NULL);
682 diff_files_result = run_diff_files(&rev, 0);
683
684 if (!diff_result_code(&rev.diffopt, diff_files_result)) {
685 print_status(flags, ' ', path, ce_oid,
686 displaypath);
687 } else if (!(flags & OPT_CACHED)) {
688 struct object_id oid;
689 struct ref_store *refs = get_submodule_ref_store(path);
690
691 if (!refs) {
692 print_status(flags, '-', path, ce_oid, displaypath);
693 goto cleanup;
694 }
695 if (refs_head_ref(refs, handle_submodule_head_ref, &oid))
696 die(_("could not resolve HEAD ref inside the "
697 "submodule '%s'"), path);
698
699 print_status(flags, '+', path, &oid, displaypath);
700 } else {
701 print_status(flags, '+', path, ce_oid, displaypath);
702 }
703
704 if (flags & OPT_RECURSIVE) {
705 struct child_process cpr = CHILD_PROCESS_INIT;
706
707 cpr.git_cmd = 1;
708 cpr.dir = path;
709 prepare_submodule_repo_env(&cpr.env);
710
711 strvec_push(&cpr.args, "--super-prefix");
712 strvec_pushf(&cpr.args, "%s/", displaypath);
713 strvec_pushl(&cpr.args, "submodule--helper", "status",
714 "--recursive", NULL);
715
716 if (flags & OPT_CACHED)
717 strvec_push(&cpr.args, "--cached");
718
719 if (flags & OPT_QUIET)
720 strvec_push(&cpr.args, "--quiet");
721
722 if (run_command(&cpr))
723 die(_("failed to recurse into submodule '%s'"), path);
724 }
725
726 cleanup:
727 strvec_clear(&diff_files_args);
728 free(displaypath);
729 release_revisions(&rev);
730 }
731
732 static void status_submodule_cb(const struct cache_entry *list_item,
733 void *cb_data)
734 {
735 struct status_cb *info = cb_data;
736 status_submodule(list_item->name, &list_item->oid, list_item->ce_flags,
737 info->prefix, info->flags);
738 }
739
740 static int module_status(int argc, const char **argv, const char *prefix)
741 {
742 struct status_cb info = STATUS_CB_INIT;
743 struct pathspec pathspec;
744 struct module_list list = MODULE_LIST_INIT;
745 int quiet = 0;
746
747 struct option module_status_options[] = {
748 OPT__QUIET(&quiet, N_("suppress submodule status output")),
749 OPT_BIT(0, "cached", &info.flags, N_("use commit stored in the index instead of the one stored in the submodule HEAD"), OPT_CACHED),
750 OPT_BIT(0, "recursive", &info.flags, N_("recurse into nested submodules"), OPT_RECURSIVE),
751 OPT_END()
752 };
753
754 const char *const git_submodule_helper_usage[] = {
755 N_("git submodule status [--quiet] [--cached] [--recursive] [<path>...]"),
756 NULL
757 };
758
759 argc = parse_options(argc, argv, prefix, module_status_options,
760 git_submodule_helper_usage, 0);
761
762 if (module_list_compute(argc, argv, prefix, &pathspec, &list) < 0)
763 return 1;
764
765 info.prefix = prefix;
766 if (quiet)
767 info.flags |= OPT_QUIET;
768
769 for_each_listed_submodule(&list, status_submodule_cb, &info);
770
771 return 0;
772 }
773
774 static int module_name(int argc, const char **argv, const char *prefix)
775 {
776 const struct submodule *sub;
777
778 if (argc != 2)
779 usage(_("git submodule--helper name <path>"));
780
781 sub = submodule_from_path(the_repository, null_oid(), argv[1]);
782
783 if (!sub)
784 die(_("no submodule mapping found in .gitmodules for path '%s'"),
785 argv[1]);
786
787 printf("%s\n", sub->name);
788
789 return 0;
790 }
791
792 struct module_cb {
793 unsigned int mod_src;
794 unsigned int mod_dst;
795 struct object_id oid_src;
796 struct object_id oid_dst;
797 char status;
798 const char *sm_path;
799 };
800 #define MODULE_CB_INIT { 0 }
801
802 struct module_cb_list {
803 struct module_cb **entries;
804 int alloc, nr;
805 };
806 #define MODULE_CB_LIST_INIT { 0 }
807
808 struct summary_cb {
809 int argc;
810 const char **argv;
811 const char *prefix;
812 unsigned int cached: 1;
813 unsigned int for_status: 1;
814 unsigned int files: 1;
815 int summary_limit;
816 };
817 #define SUMMARY_CB_INIT { 0 }
818
819 enum diff_cmd {
820 DIFF_INDEX,
821 DIFF_FILES
822 };
823
824 static char *verify_submodule_committish(const char *sm_path,
825 const char *committish)
826 {
827 struct child_process cp_rev_parse = CHILD_PROCESS_INIT;
828 struct strbuf result = STRBUF_INIT;
829
830 cp_rev_parse.git_cmd = 1;
831 cp_rev_parse.dir = sm_path;
832 prepare_submodule_repo_env(&cp_rev_parse.env);
833 strvec_pushl(&cp_rev_parse.args, "rev-parse", "-q", "--short", NULL);
834 strvec_pushf(&cp_rev_parse.args, "%s^0", committish);
835 strvec_push(&cp_rev_parse.args, "--");
836
837 if (capture_command(&cp_rev_parse, &result, 0))
838 return NULL;
839
840 strbuf_trim_trailing_newline(&result);
841 return strbuf_detach(&result, NULL);
842 }
843
844 static void print_submodule_summary(struct summary_cb *info, char *errmsg,
845 int total_commits, const char *displaypath,
846 const char *src_abbrev, const char *dst_abbrev,
847 struct module_cb *p)
848 {
849 if (p->status == 'T') {
850 if (S_ISGITLINK(p->mod_dst))
851 printf(_("* %s %s(blob)->%s(submodule)"),
852 displaypath, src_abbrev, dst_abbrev);
853 else
854 printf(_("* %s %s(submodule)->%s(blob)"),
855 displaypath, src_abbrev, dst_abbrev);
856 } else {
857 printf("* %s %s...%s",
858 displaypath, src_abbrev, dst_abbrev);
859 }
860
861 if (total_commits < 0)
862 printf(":\n");
863 else
864 printf(" (%d):\n", total_commits);
865
866 if (errmsg) {
867 printf(_("%s"), errmsg);
868 } else if (total_commits > 0) {
869 struct child_process cp_log = CHILD_PROCESS_INIT;
870
871 cp_log.git_cmd = 1;
872 cp_log.dir = p->sm_path;
873 prepare_submodule_repo_env(&cp_log.env);
874 strvec_pushl(&cp_log.args, "log", NULL);
875
876 if (S_ISGITLINK(p->mod_src) && S_ISGITLINK(p->mod_dst)) {
877 if (info->summary_limit > 0)
878 strvec_pushf(&cp_log.args, "-%d",
879 info->summary_limit);
880
881 strvec_pushl(&cp_log.args, "--pretty= %m %s",
882 "--first-parent", NULL);
883 strvec_pushf(&cp_log.args, "%s...%s",
884 src_abbrev, dst_abbrev);
885 } else if (S_ISGITLINK(p->mod_dst)) {
886 strvec_pushl(&cp_log.args, "--pretty= > %s",
887 "-1", dst_abbrev, NULL);
888 } else {
889 strvec_pushl(&cp_log.args, "--pretty= < %s",
890 "-1", src_abbrev, NULL);
891 }
892 run_command(&cp_log);
893 }
894 printf("\n");
895 }
896
897 static void generate_submodule_summary(struct summary_cb *info,
898 struct module_cb *p)
899 {
900 char *displaypath, *src_abbrev = NULL, *dst_abbrev;
901 int missing_src = 0, missing_dst = 0;
902 char *errmsg = NULL;
903 int total_commits = -1;
904
905 if (!info->cached && oideq(&p->oid_dst, null_oid())) {
906 if (S_ISGITLINK(p->mod_dst)) {
907 struct ref_store *refs = get_submodule_ref_store(p->sm_path);
908 if (refs)
909 refs_head_ref(refs, handle_submodule_head_ref, &p->oid_dst);
910 } else if (S_ISLNK(p->mod_dst) || S_ISREG(p->mod_dst)) {
911 struct stat st;
912 int fd = open(p->sm_path, O_RDONLY);
913
914 if (fd < 0 || fstat(fd, &st) < 0 ||
915 index_fd(&the_index, &p->oid_dst, fd, &st, OBJ_BLOB,
916 p->sm_path, 0))
917 error(_("couldn't hash object from '%s'"), p->sm_path);
918 } else {
919 /* for a submodule removal (mode:0000000), don't warn */
920 if (p->mod_dst)
921 warning(_("unexpected mode %o\n"), p->mod_dst);
922 }
923 }
924
925 if (S_ISGITLINK(p->mod_src)) {
926 if (p->status != 'D')
927 src_abbrev = verify_submodule_committish(p->sm_path,
928 oid_to_hex(&p->oid_src));
929 if (!src_abbrev) {
930 missing_src = 1;
931 /*
932 * As `rev-parse` failed, we fallback to getting
933 * the abbreviated hash using oid_src. We do
934 * this as we might still need the abbreviated
935 * hash in cases like a submodule type change, etc.
936 */
937 src_abbrev = xstrndup(oid_to_hex(&p->oid_src), 7);
938 }
939 } else {
940 /*
941 * The source does not point to a submodule.
942 * So, we fallback to getting the abbreviation using
943 * oid_src as we might still need the abbreviated
944 * hash in cases like submodule add, etc.
945 */
946 src_abbrev = xstrndup(oid_to_hex(&p->oid_src), 7);
947 }
948
949 if (S_ISGITLINK(p->mod_dst)) {
950 dst_abbrev = verify_submodule_committish(p->sm_path,
951 oid_to_hex(&p->oid_dst));
952 if (!dst_abbrev) {
953 missing_dst = 1;
954 /*
955 * As `rev-parse` failed, we fallback to getting
956 * the abbreviated hash using oid_dst. We do
957 * this as we might still need the abbreviated
958 * hash in cases like a submodule type change, etc.
959 */
960 dst_abbrev = xstrndup(oid_to_hex(&p->oid_dst), 7);
961 }
962 } else {
963 /*
964 * The destination does not point to a submodule.
965 * So, we fallback to getting the abbreviation using
966 * oid_dst as we might still need the abbreviated
967 * hash in cases like a submodule removal, etc.
968 */
969 dst_abbrev = xstrndup(oid_to_hex(&p->oid_dst), 7);
970 }
971
972 displaypath = get_submodule_displaypath(p->sm_path, info->prefix);
973
974 if (!missing_src && !missing_dst) {
975 struct child_process cp_rev_list = CHILD_PROCESS_INIT;
976 struct strbuf sb_rev_list = STRBUF_INIT;
977
978 strvec_pushl(&cp_rev_list.args, "rev-list",
979 "--first-parent", "--count", NULL);
980 if (S_ISGITLINK(p->mod_src) && S_ISGITLINK(p->mod_dst))
981 strvec_pushf(&cp_rev_list.args, "%s...%s",
982 src_abbrev, dst_abbrev);
983 else
984 strvec_push(&cp_rev_list.args, S_ISGITLINK(p->mod_src) ?
985 src_abbrev : dst_abbrev);
986 strvec_push(&cp_rev_list.args, "--");
987
988 cp_rev_list.git_cmd = 1;
989 cp_rev_list.dir = p->sm_path;
990 prepare_submodule_repo_env(&cp_rev_list.env);
991
992 if (!capture_command(&cp_rev_list, &sb_rev_list, 0))
993 total_commits = atoi(sb_rev_list.buf);
994
995 strbuf_release(&sb_rev_list);
996 } else {
997 /*
998 * Don't give error msg for modification whose dst is not
999 * submodule, i.e., deleted or changed to blob
1000 */
1001 if (S_ISGITLINK(p->mod_dst)) {
1002 struct strbuf errmsg_str = STRBUF_INIT;
1003 if (missing_src && missing_dst) {
1004 strbuf_addf(&errmsg_str, " Warn: %s doesn't contain commits %s and %s\n",
1005 displaypath, oid_to_hex(&p->oid_src),
1006 oid_to_hex(&p->oid_dst));
1007 } else {
1008 strbuf_addf(&errmsg_str, " Warn: %s doesn't contain commit %s\n",
1009 displaypath, missing_src ?
1010 oid_to_hex(&p->oid_src) :
1011 oid_to_hex(&p->oid_dst));
1012 }
1013 errmsg = strbuf_detach(&errmsg_str, NULL);
1014 }
1015 }
1016
1017 print_submodule_summary(info, errmsg, total_commits,
1018 displaypath, src_abbrev,
1019 dst_abbrev, p);
1020
1021 free(displaypath);
1022 free(src_abbrev);
1023 free(dst_abbrev);
1024 }
1025
1026 static void prepare_submodule_summary(struct summary_cb *info,
1027 struct module_cb_list *list)
1028 {
1029 int i;
1030 for (i = 0; i < list->nr; i++) {
1031 const struct submodule *sub;
1032 struct module_cb *p = list->entries[i];
1033 struct strbuf sm_gitdir = STRBUF_INIT;
1034
1035 if (p->status == 'D' || p->status == 'T') {
1036 generate_submodule_summary(info, p);
1037 continue;
1038 }
1039
1040 if (info->for_status && p->status != 'A' &&
1041 (sub = submodule_from_path(the_repository,
1042 null_oid(), p->sm_path))) {
1043 char *config_key = NULL;
1044 const char *value;
1045 int ignore_all = 0;
1046
1047 config_key = xstrfmt("submodule.%s.ignore",
1048 sub->name);
1049 if (!git_config_get_string_tmp(config_key, &value))
1050 ignore_all = !strcmp(value, "all");
1051 else if (sub->ignore)
1052 ignore_all = !strcmp(sub->ignore, "all");
1053
1054 free(config_key);
1055 if (ignore_all)
1056 continue;
1057 }
1058
1059 /* Also show added or modified modules which are checked out */
1060 strbuf_addstr(&sm_gitdir, p->sm_path);
1061 if (is_nonbare_repository_dir(&sm_gitdir))
1062 generate_submodule_summary(info, p);
1063 strbuf_release(&sm_gitdir);
1064 }
1065 }
1066
1067 static void submodule_summary_callback(struct diff_queue_struct *q,
1068 struct diff_options *options,
1069 void *data)
1070 {
1071 int i;
1072 struct module_cb_list *list = data;
1073 for (i = 0; i < q->nr; i++) {
1074 struct diff_filepair *p = q->queue[i];
1075 struct module_cb *temp;
1076
1077 if (!S_ISGITLINK(p->one->mode) && !S_ISGITLINK(p->two->mode))
1078 continue;
1079 temp = (struct module_cb*)malloc(sizeof(struct module_cb));
1080 temp->mod_src = p->one->mode;
1081 temp->mod_dst = p->two->mode;
1082 temp->oid_src = p->one->oid;
1083 temp->oid_dst = p->two->oid;
1084 temp->status = p->status;
1085 temp->sm_path = xstrdup(p->one->path);
1086
1087 ALLOC_GROW(list->entries, list->nr + 1, list->alloc);
1088 list->entries[list->nr++] = temp;
1089 }
1090 }
1091
1092 static const char *get_diff_cmd(enum diff_cmd diff_cmd)
1093 {
1094 switch (diff_cmd) {
1095 case DIFF_INDEX: return "diff-index";
1096 case DIFF_FILES: return "diff-files";
1097 default: BUG("bad diff_cmd value %d", diff_cmd);
1098 }
1099 }
1100
1101 static int compute_summary_module_list(struct object_id *head_oid,
1102 struct summary_cb *info,
1103 enum diff_cmd diff_cmd)
1104 {
1105 struct strvec diff_args = STRVEC_INIT;
1106 struct rev_info rev;
1107 struct setup_revision_opt opt = {
1108 .free_removed_argv_elements = 1,
1109 };
1110 struct module_cb_list list = MODULE_CB_LIST_INIT;
1111 int ret = 0;
1112
1113 strvec_push(&diff_args, get_diff_cmd(diff_cmd));
1114 if (info->cached)
1115 strvec_push(&diff_args, "--cached");
1116 strvec_pushl(&diff_args, "--ignore-submodules=dirty", "--raw", NULL);
1117 if (head_oid)
1118 strvec_push(&diff_args, oid_to_hex(head_oid));
1119 strvec_push(&diff_args, "--");
1120 if (info->argc)
1121 strvec_pushv(&diff_args, info->argv);
1122
1123 git_config(git_diff_basic_config, NULL);
1124 init_revisions(&rev, info->prefix);
1125 rev.abbrev = 0;
1126 precompose_argv_prefix(diff_args.nr, diff_args.v, NULL);
1127 setup_revisions(diff_args.nr, diff_args.v, &rev, &opt);
1128 rev.diffopt.output_format = DIFF_FORMAT_NO_OUTPUT | DIFF_FORMAT_CALLBACK;
1129 rev.diffopt.format_callback = submodule_summary_callback;
1130 rev.diffopt.format_callback_data = &list;
1131
1132 if (!info->cached) {
1133 if (diff_cmd == DIFF_INDEX)
1134 setup_work_tree();
1135 if (read_cache_preload(&rev.diffopt.pathspec) < 0) {
1136 perror("read_cache_preload");
1137 ret = -1;
1138 goto cleanup;
1139 }
1140 } else if (read_cache() < 0) {
1141 perror("read_cache");
1142 ret = -1;
1143 goto cleanup;
1144 }
1145
1146 if (diff_cmd == DIFF_INDEX)
1147 run_diff_index(&rev, info->cached);
1148 else
1149 run_diff_files(&rev, 0);
1150 prepare_submodule_summary(info, &list);
1151 cleanup:
1152 strvec_clear(&diff_args);
1153 release_revisions(&rev);
1154 return ret;
1155 }
1156
1157 static int module_summary(int argc, const char **argv, const char *prefix)
1158 {
1159 struct summary_cb info = SUMMARY_CB_INIT;
1160 int cached = 0;
1161 int for_status = 0;
1162 int files = 0;
1163 int summary_limit = -1;
1164 enum diff_cmd diff_cmd = DIFF_INDEX;
1165 struct object_id head_oid;
1166 int ret;
1167
1168 struct option module_summary_options[] = {
1169 OPT_BOOL(0, "cached", &cached,
1170 N_("use the commit stored in the index instead of the submodule HEAD")),
1171 OPT_BOOL(0, "files", &files,
1172 N_("compare the commit in the index with that in the submodule HEAD")),
1173 OPT_BOOL(0, "for-status", &for_status,
1174 N_("skip submodules with 'ignore_config' value set to 'all'")),
1175 OPT_INTEGER('n', "summary-limit", &summary_limit,
1176 N_("limit the summary size")),
1177 OPT_END()
1178 };
1179
1180 const char *const git_submodule_helper_usage[] = {
1181 N_("git submodule summary [<options>] [<commit>] [--] [<path>]"),
1182 NULL
1183 };
1184
1185 argc = parse_options(argc, argv, prefix, module_summary_options,
1186 git_submodule_helper_usage, 0);
1187
1188 if (!summary_limit)
1189 return 0;
1190
1191 if (!get_oid(argc ? argv[0] : "HEAD", &head_oid)) {
1192 if (argc) {
1193 argv++;
1194 argc--;
1195 }
1196 } else if (!argc || !strcmp(argv[0], "HEAD")) {
1197 /* before the first commit: compare with an empty tree */
1198 oidcpy(&head_oid, the_hash_algo->empty_tree);
1199 if (argc) {
1200 argv++;
1201 argc--;
1202 }
1203 } else {
1204 if (get_oid("HEAD", &head_oid))
1205 die(_("could not fetch a revision for HEAD"));
1206 }
1207
1208 if (files) {
1209 if (cached)
1210 die(_("options '%s' and '%s' cannot be used together"), "--cached", "--files");
1211 diff_cmd = DIFF_FILES;
1212 }
1213
1214 info.argc = argc;
1215 info.argv = argv;
1216 info.prefix = prefix;
1217 info.cached = !!cached;
1218 info.files = !!files;
1219 info.for_status = !!for_status;
1220 info.summary_limit = summary_limit;
1221
1222 ret = compute_summary_module_list((diff_cmd == DIFF_INDEX) ? &head_oid : NULL,
1223 &info, diff_cmd);
1224 return ret;
1225 }
1226
1227 struct sync_cb {
1228 const char *prefix;
1229 unsigned int flags;
1230 };
1231 #define SYNC_CB_INIT { 0 }
1232
1233 static void sync_submodule(const char *path, const char *prefix,
1234 unsigned int flags)
1235 {
1236 const struct submodule *sub;
1237 char *remote_key = NULL;
1238 char *sub_origin_url, *super_config_url, *displaypath, *default_remote;
1239 struct strbuf sb = STRBUF_INIT;
1240 char *sub_config_path = NULL;
1241
1242 if (!is_submodule_active(the_repository, path))
1243 return;
1244
1245 sub = submodule_from_path(the_repository, null_oid(), path);
1246
1247 if (sub && sub->url) {
1248 if (starts_with_dot_dot_slash(sub->url) ||
1249 starts_with_dot_slash(sub->url)) {
1250 char *up_path = get_up_path(path);
1251 sub_origin_url = resolve_relative_url(sub->url, up_path, 1);
1252 super_config_url = resolve_relative_url(sub->url, NULL, 1);
1253 free(up_path);
1254 } else {
1255 sub_origin_url = xstrdup(sub->url);
1256 super_config_url = xstrdup(sub->url);
1257 }
1258 } else {
1259 sub_origin_url = xstrdup("");
1260 super_config_url = xstrdup("");
1261 }
1262
1263 displaypath = get_submodule_displaypath(path, prefix);
1264
1265 if (!(flags & OPT_QUIET))
1266 printf(_("Synchronizing submodule url for '%s'\n"),
1267 displaypath);
1268
1269 strbuf_reset(&sb);
1270 strbuf_addf(&sb, "submodule.%s.url", sub->name);
1271 if (git_config_set_gently(sb.buf, super_config_url))
1272 die(_("failed to register url for submodule path '%s'"),
1273 displaypath);
1274
1275 if (!is_submodule_populated_gently(path, NULL))
1276 goto cleanup;
1277
1278 strbuf_reset(&sb);
1279 default_remote = get_default_remote_submodule(path);
1280 if (!default_remote)
1281 die(_("failed to get the default remote for submodule '%s'"),
1282 path);
1283
1284 remote_key = xstrfmt("remote.%s.url", default_remote);
1285 free(default_remote);
1286
1287 submodule_to_gitdir(&sb, path);
1288 strbuf_addstr(&sb, "/config");
1289
1290 if (git_config_set_in_file_gently(sb.buf, remote_key, sub_origin_url))
1291 die(_("failed to update remote for submodule '%s'"),
1292 path);
1293
1294 if (flags & OPT_RECURSIVE) {
1295 struct child_process cpr = CHILD_PROCESS_INIT;
1296
1297 cpr.git_cmd = 1;
1298 cpr.dir = path;
1299 prepare_submodule_repo_env(&cpr.env);
1300
1301 strvec_push(&cpr.args, "--super-prefix");
1302 strvec_pushf(&cpr.args, "%s/", displaypath);
1303 strvec_pushl(&cpr.args, "submodule--helper", "sync",
1304 "--recursive", NULL);
1305
1306 if (flags & OPT_QUIET)
1307 strvec_push(&cpr.args, "--quiet");
1308
1309 if (run_command(&cpr))
1310 die(_("failed to recurse into submodule '%s'"),
1311 path);
1312 }
1313
1314 cleanup:
1315 free(super_config_url);
1316 free(sub_origin_url);
1317 strbuf_release(&sb);
1318 free(remote_key);
1319 free(displaypath);
1320 free(sub_config_path);
1321 }
1322
1323 static void sync_submodule_cb(const struct cache_entry *list_item, void *cb_data)
1324 {
1325 struct sync_cb *info = cb_data;
1326 sync_submodule(list_item->name, info->prefix, info->flags);
1327 }
1328
1329 static int module_sync(int argc, const char **argv, const char *prefix)
1330 {
1331 struct sync_cb info = SYNC_CB_INIT;
1332 struct pathspec pathspec;
1333 struct module_list list = MODULE_LIST_INIT;
1334 int quiet = 0;
1335 int recursive = 0;
1336
1337 struct option module_sync_options[] = {
1338 OPT__QUIET(&quiet, N_("suppress output of synchronizing submodule url")),
1339 OPT_BOOL(0, "recursive", &recursive,
1340 N_("recurse into nested submodules")),
1341 OPT_END()
1342 };
1343
1344 const char *const git_submodule_helper_usage[] = {
1345 N_("git submodule sync [--quiet] [--recursive] [<path>]"),
1346 NULL
1347 };
1348
1349 argc = parse_options(argc, argv, prefix, module_sync_options,
1350 git_submodule_helper_usage, 0);
1351
1352 if (module_list_compute(argc, argv, prefix, &pathspec, &list) < 0)
1353 return 1;
1354
1355 info.prefix = prefix;
1356 if (quiet)
1357 info.flags |= OPT_QUIET;
1358 if (recursive)
1359 info.flags |= OPT_RECURSIVE;
1360
1361 for_each_listed_submodule(&list, sync_submodule_cb, &info);
1362
1363 return 0;
1364 }
1365
1366 struct deinit_cb {
1367 const char *prefix;
1368 unsigned int flags;
1369 };
1370 #define DEINIT_CB_INIT { 0 }
1371
1372 static void deinit_submodule(const char *path, const char *prefix,
1373 unsigned int flags)
1374 {
1375 const struct submodule *sub;
1376 char *displaypath = NULL;
1377 struct child_process cp_config = CHILD_PROCESS_INIT;
1378 struct strbuf sb_config = STRBUF_INIT;
1379 char *sub_git_dir = xstrfmt("%s/.git", path);
1380
1381 sub = submodule_from_path(the_repository, null_oid(), path);
1382
1383 if (!sub || !sub->name)
1384 goto cleanup;
1385
1386 displaypath = get_submodule_displaypath(path, prefix);
1387
1388 /* remove the submodule work tree (unless the user already did it) */
1389 if (is_directory(path)) {
1390 struct strbuf sb_rm = STRBUF_INIT;
1391 const char *format;
1392
1393 if (is_directory(sub_git_dir)) {
1394 if (!(flags & OPT_QUIET))
1395 warning(_("Submodule work tree '%s' contains a .git "
1396 "directory. This will be replaced with a "
1397 ".git file by using absorbgitdirs."),
1398 displaypath);
1399
1400 absorb_git_dir_into_superproject(path,
1401 ABSORB_GITDIR_RECURSE_SUBMODULES);
1402
1403 }
1404
1405 if (!(flags & OPT_FORCE)) {
1406 struct child_process cp_rm = CHILD_PROCESS_INIT;
1407 cp_rm.git_cmd = 1;
1408 strvec_pushl(&cp_rm.args, "rm", "-qn",
1409 path, NULL);
1410
1411 if (run_command(&cp_rm))
1412 die(_("Submodule work tree '%s' contains local "
1413 "modifications; use '-f' to discard them"),
1414 displaypath);
1415 }
1416
1417 strbuf_addstr(&sb_rm, path);
1418
1419 if (!remove_dir_recursively(&sb_rm, 0))
1420 format = _("Cleared directory '%s'\n");
1421 else
1422 format = _("Could not remove submodule work tree '%s'\n");
1423
1424 if (!(flags & OPT_QUIET))
1425 printf(format, displaypath);
1426
1427 submodule_unset_core_worktree(sub);
1428
1429 strbuf_release(&sb_rm);
1430 }
1431
1432 if (mkdir(path, 0777))
1433 printf(_("could not create empty submodule directory %s"),
1434 displaypath);
1435
1436 cp_config.git_cmd = 1;
1437 strvec_pushl(&cp_config.args, "config", "--get-regexp", NULL);
1438 strvec_pushf(&cp_config.args, "submodule.%s\\.", sub->name);
1439
1440 /* remove the .git/config entries (unless the user already did it) */
1441 if (!capture_command(&cp_config, &sb_config, 0) && sb_config.len) {
1442 char *sub_key = xstrfmt("submodule.%s", sub->name);
1443 /*
1444 * remove the whole section so we have a clean state when
1445 * the user later decides to init this submodule again
1446 */
1447 git_config_rename_section_in_file(NULL, sub_key, NULL);
1448 if (!(flags & OPT_QUIET))
1449 printf(_("Submodule '%s' (%s) unregistered for path '%s'\n"),
1450 sub->name, sub->url, displaypath);
1451 free(sub_key);
1452 }
1453
1454 cleanup:
1455 free(displaypath);
1456 free(sub_git_dir);
1457 strbuf_release(&sb_config);
1458 }
1459
1460 static void deinit_submodule_cb(const struct cache_entry *list_item,
1461 void *cb_data)
1462 {
1463 struct deinit_cb *info = cb_data;
1464 deinit_submodule(list_item->name, info->prefix, info->flags);
1465 }
1466
1467 static int module_deinit(int argc, const char **argv, const char *prefix)
1468 {
1469 struct deinit_cb info = DEINIT_CB_INIT;
1470 struct pathspec pathspec;
1471 struct module_list list = MODULE_LIST_INIT;
1472 int quiet = 0;
1473 int force = 0;
1474 int all = 0;
1475
1476 struct option module_deinit_options[] = {
1477 OPT__QUIET(&quiet, N_("suppress submodule status output")),
1478 OPT__FORCE(&force, N_("remove submodule working trees even if they contain local changes"), 0),
1479 OPT_BOOL(0, "all", &all, N_("unregister all submodules")),
1480 OPT_END()
1481 };
1482
1483 const char *const git_submodule_helper_usage[] = {
1484 N_("git submodule deinit [--quiet] [-f | --force] [--all | [--] [<path>...]]"),
1485 NULL
1486 };
1487
1488 argc = parse_options(argc, argv, prefix, module_deinit_options,
1489 git_submodule_helper_usage, 0);
1490
1491 if (all && argc) {
1492 error("pathspec and --all are incompatible");
1493 usage_with_options(git_submodule_helper_usage,
1494 module_deinit_options);
1495 }
1496
1497 if (!argc && !all)
1498 die(_("Use '--all' if you really want to deinitialize all submodules"));
1499
1500 if (module_list_compute(argc, argv, prefix, &pathspec, &list) < 0)
1501 return 1;
1502
1503 info.prefix = prefix;
1504 if (quiet)
1505 info.flags |= OPT_QUIET;
1506 if (force)
1507 info.flags |= OPT_FORCE;
1508
1509 for_each_listed_submodule(&list, deinit_submodule_cb, &info);
1510
1511 return 0;
1512 }
1513
1514 struct module_clone_data {
1515 const char *prefix;
1516 const char *path;
1517 const char *name;
1518 const char *url;
1519 const char *depth;
1520 struct list_objects_filter_options *filter_options;
1521 struct string_list reference;
1522 unsigned int quiet: 1;
1523 unsigned int progress: 1;
1524 unsigned int dissociate: 1;
1525 unsigned int require_init: 1;
1526 int single_branch;
1527 };
1528 #define MODULE_CLONE_DATA_INIT { \
1529 .reference = STRING_LIST_INIT_NODUP, \
1530 .single_branch = -1, \
1531 }
1532
1533 struct submodule_alternate_setup {
1534 const char *submodule_name;
1535 enum SUBMODULE_ALTERNATE_ERROR_MODE {
1536 SUBMODULE_ALTERNATE_ERROR_DIE,
1537 SUBMODULE_ALTERNATE_ERROR_INFO,
1538 SUBMODULE_ALTERNATE_ERROR_IGNORE
1539 } error_mode;
1540 struct string_list *reference;
1541 };
1542 #define SUBMODULE_ALTERNATE_SETUP_INIT { \
1543 .error_mode = SUBMODULE_ALTERNATE_ERROR_IGNORE, \
1544 }
1545
1546 static const char alternate_error_advice[] = N_(
1547 "An alternate computed from a superproject's alternate is invalid.\n"
1548 "To allow Git to clone without an alternate in such a case, set\n"
1549 "submodule.alternateErrorStrategy to 'info' or, equivalently, clone with\n"
1550 "'--reference-if-able' instead of '--reference'."
1551 );
1552
1553 static int add_possible_reference_from_superproject(
1554 struct object_directory *odb, void *sas_cb)
1555 {
1556 struct submodule_alternate_setup *sas = sas_cb;
1557 size_t len;
1558
1559 /*
1560 * If the alternate object store is another repository, try the
1561 * standard layout with .git/(modules/<name>)+/objects
1562 */
1563 if (strip_suffix(odb->path, "/objects", &len)) {
1564 struct repository alternate;
1565 char *sm_alternate;
1566 struct strbuf sb = STRBUF_INIT;
1567 struct strbuf err = STRBUF_INIT;
1568 strbuf_add(&sb, odb->path, len);
1569
1570 repo_init(&alternate, sb.buf, NULL);
1571
1572 /*
1573 * We need to end the new path with '/' to mark it as a dir,
1574 * otherwise a submodule name containing '/' will be broken
1575 * as the last part of a missing submodule reference would
1576 * be taken as a file name.
1577 */
1578 strbuf_reset(&sb);
1579 submodule_name_to_gitdir(&sb, &alternate, sas->submodule_name);
1580 strbuf_addch(&sb, '/');
1581 repo_clear(&alternate);
1582
1583 sm_alternate = compute_alternate_path(sb.buf, &err);
1584 if (sm_alternate) {
1585 string_list_append(sas->reference, xstrdup(sb.buf));
1586 free(sm_alternate);
1587 } else {
1588 switch (sas->error_mode) {
1589 case SUBMODULE_ALTERNATE_ERROR_DIE:
1590 if (advice_enabled(ADVICE_SUBMODULE_ALTERNATE_ERROR_STRATEGY_DIE))
1591 advise(_(alternate_error_advice));
1592 die(_("submodule '%s' cannot add alternate: %s"),
1593 sas->submodule_name, err.buf);
1594 case SUBMODULE_ALTERNATE_ERROR_INFO:
1595 fprintf_ln(stderr, _("submodule '%s' cannot add alternate: %s"),
1596 sas->submodule_name, err.buf);
1597 case SUBMODULE_ALTERNATE_ERROR_IGNORE:
1598 ; /* nothing */
1599 }
1600 }
1601 strbuf_release(&sb);
1602 }
1603
1604 return 0;
1605 }
1606
1607 static void prepare_possible_alternates(const char *sm_name,
1608 struct string_list *reference)
1609 {
1610 char *sm_alternate = NULL, *error_strategy = NULL;
1611 struct submodule_alternate_setup sas = SUBMODULE_ALTERNATE_SETUP_INIT;
1612
1613 git_config_get_string("submodule.alternateLocation", &sm_alternate);
1614 if (!sm_alternate)
1615 return;
1616
1617 git_config_get_string("submodule.alternateErrorStrategy", &error_strategy);
1618
1619 if (!error_strategy)
1620 error_strategy = xstrdup("die");
1621
1622 sas.submodule_name = sm_name;
1623 sas.reference = reference;
1624 if (!strcmp(error_strategy, "die"))
1625 sas.error_mode = SUBMODULE_ALTERNATE_ERROR_DIE;
1626 else if (!strcmp(error_strategy, "info"))
1627 sas.error_mode = SUBMODULE_ALTERNATE_ERROR_INFO;
1628 else if (!strcmp(error_strategy, "ignore"))
1629 sas.error_mode = SUBMODULE_ALTERNATE_ERROR_IGNORE;
1630 else
1631 die(_("Value '%s' for submodule.alternateErrorStrategy is not recognized"), error_strategy);
1632
1633 if (!strcmp(sm_alternate, "superproject"))
1634 foreach_alt_odb(add_possible_reference_from_superproject, &sas);
1635 else if (!strcmp(sm_alternate, "no"))
1636 ; /* do nothing */
1637 else
1638 die(_("Value '%s' for submodule.alternateLocation is not recognized"), sm_alternate);
1639
1640 free(sm_alternate);
1641 free(error_strategy);
1642 }
1643
1644 static int clone_submodule(struct module_clone_data *clone_data)
1645 {
1646 char *p, *sm_gitdir;
1647 char *sm_alternate = NULL, *error_strategy = NULL;
1648 struct strbuf sb = STRBUF_INIT;
1649 struct child_process cp = CHILD_PROCESS_INIT;
1650
1651 submodule_name_to_gitdir(&sb, the_repository, clone_data->name);
1652 sm_gitdir = absolute_pathdup(sb.buf);
1653 strbuf_reset(&sb);
1654
1655 if (!is_absolute_path(clone_data->path)) {
1656 strbuf_addf(&sb, "%s/%s", get_git_work_tree(), clone_data->path);
1657 clone_data->path = strbuf_detach(&sb, NULL);
1658 } else {
1659 clone_data->path = xstrdup(clone_data->path);
1660 }
1661
1662 if (validate_submodule_git_dir(sm_gitdir, clone_data->name) < 0)
1663 die(_("refusing to create/use '%s' in another submodule's "
1664 "git dir"), sm_gitdir);
1665
1666 if (!file_exists(sm_gitdir)) {
1667 if (safe_create_leading_directories_const(sm_gitdir) < 0)
1668 die(_("could not create directory '%s'"), sm_gitdir);
1669
1670 prepare_possible_alternates(clone_data->name, &clone_data->reference);
1671
1672 strvec_push(&cp.args, "clone");
1673 strvec_push(&cp.args, "--no-checkout");
1674 if (clone_data->quiet)
1675 strvec_push(&cp.args, "--quiet");
1676 if (clone_data->progress)
1677 strvec_push(&cp.args, "--progress");
1678 if (clone_data->depth && *(clone_data->depth))
1679 strvec_pushl(&cp.args, "--depth", clone_data->depth, NULL);
1680 if (clone_data->reference.nr) {
1681 struct string_list_item *item;
1682 for_each_string_list_item(item, &clone_data->reference)
1683 strvec_pushl(&cp.args, "--reference",
1684 item->string, NULL);
1685 }
1686 if (clone_data->dissociate)
1687 strvec_push(&cp.args, "--dissociate");
1688 if (sm_gitdir && *sm_gitdir)
1689 strvec_pushl(&cp.args, "--separate-git-dir", sm_gitdir, NULL);
1690 if (clone_data->filter_options && clone_data->filter_options->choice)
1691 strvec_pushf(&cp.args, "--filter=%s",
1692 expand_list_objects_filter_spec(
1693 clone_data->filter_options));
1694 if (clone_data->single_branch >= 0)
1695 strvec_push(&cp.args, clone_data->single_branch ?
1696 "--single-branch" :
1697 "--no-single-branch");
1698
1699 strvec_push(&cp.args, "--");
1700 strvec_push(&cp.args, clone_data->url);
1701 strvec_push(&cp.args, clone_data->path);
1702
1703 cp.git_cmd = 1;
1704 prepare_submodule_repo_env(&cp.env);
1705 cp.no_stdin = 1;
1706
1707 if(run_command(&cp))
1708 die(_("clone of '%s' into submodule path '%s' failed"),
1709 clone_data->url, clone_data->path);
1710 } else {
1711 if (clone_data->require_init && !access(clone_data->path, X_OK) &&
1712 !is_empty_dir(clone_data->path))
1713 die(_("directory not empty: '%s'"), clone_data->path);
1714 if (safe_create_leading_directories_const(clone_data->path) < 0)
1715 die(_("could not create directory '%s'"), clone_data->path);
1716 strbuf_addf(&sb, "%s/index", sm_gitdir);
1717 unlink_or_warn(sb.buf);
1718 strbuf_reset(&sb);
1719 }
1720
1721 connect_work_tree_and_git_dir(clone_data->path, sm_gitdir, 0);
1722
1723 p = git_pathdup_submodule(clone_data->path, "config");
1724 if (!p)
1725 die(_("could not get submodule directory for '%s'"), clone_data->path);
1726
1727 /* setup alternateLocation and alternateErrorStrategy in the cloned submodule if needed */
1728 git_config_get_string("submodule.alternateLocation", &sm_alternate);
1729 if (sm_alternate)
1730 git_config_set_in_file(p, "submodule.alternateLocation",
1731 sm_alternate);
1732 git_config_get_string("submodule.alternateErrorStrategy", &error_strategy);
1733 if (error_strategy)
1734 git_config_set_in_file(p, "submodule.alternateErrorStrategy",
1735 error_strategy);
1736
1737 free(sm_alternate);
1738 free(error_strategy);
1739
1740 strbuf_release(&sb);
1741 free(sm_gitdir);
1742 free(p);
1743 return 0;
1744 }
1745
1746 static int module_clone(int argc, const char **argv, const char *prefix)
1747 {
1748 int dissociate = 0, quiet = 0, progress = 0, require_init = 0;
1749 struct module_clone_data clone_data = MODULE_CLONE_DATA_INIT;
1750 struct list_objects_filter_options filter_options;
1751
1752 struct option module_clone_options[] = {
1753 OPT_STRING(0, "prefix", &clone_data.prefix,
1754 N_("path"),
1755 N_("alternative anchor for relative paths")),
1756 OPT_STRING(0, "path", &clone_data.path,
1757 N_("path"),
1758 N_("where the new submodule will be cloned to")),
1759 OPT_STRING(0, "name", &clone_data.name,
1760 N_("string"),
1761 N_("name of the new submodule")),
1762 OPT_STRING(0, "url", &clone_data.url,
1763 N_("string"),
1764 N_("url where to clone the submodule from")),
1765 OPT_STRING_LIST(0, "reference", &clone_data.reference,
1766 N_("repo"),
1767 N_("reference repository")),
1768 OPT_BOOL(0, "dissociate", &dissociate,
1769 N_("use --reference only while cloning")),
1770 OPT_STRING(0, "depth", &clone_data.depth,
1771 N_("string"),
1772 N_("depth for shallow clones")),
1773 OPT__QUIET(&quiet, "suppress output for cloning a submodule"),
1774 OPT_BOOL(0, "progress", &progress,
1775 N_("force cloning progress")),
1776 OPT_BOOL(0, "require-init", &require_init,
1777 N_("disallow cloning into non-empty directory")),
1778 OPT_BOOL(0, "single-branch", &clone_data.single_branch,
1779 N_("clone only one branch, HEAD or --branch")),
1780 OPT_PARSE_LIST_OBJECTS_FILTER(&filter_options),
1781 OPT_END()
1782 };
1783
1784 const char *const git_submodule_helper_usage[] = {
1785 N_("git submodule--helper clone [--prefix=<path>] [--quiet] "
1786 "[--reference <repository>] [--name <name>] [--depth <depth>] "
1787 "[--single-branch] [--filter <filter-spec>] "
1788 "--url <url> --path <path>"),
1789 NULL
1790 };
1791
1792 memset(&filter_options, 0, sizeof(filter_options));
1793 argc = parse_options(argc, argv, prefix, module_clone_options,
1794 git_submodule_helper_usage, 0);
1795
1796 clone_data.dissociate = !!dissociate;
1797 clone_data.quiet = !!quiet;
1798 clone_data.progress = !!progress;
1799 clone_data.require_init = !!require_init;
1800 clone_data.filter_options = &filter_options;
1801
1802 if (argc || !clone_data.url || !clone_data.path || !*(clone_data.path))
1803 usage_with_options(git_submodule_helper_usage,
1804 module_clone_options);
1805
1806 clone_submodule(&clone_data);
1807 list_objects_filter_release(&filter_options);
1808 return 0;
1809 }
1810
1811 static void determine_submodule_update_strategy(struct repository *r,
1812 int just_cloned,
1813 const char *path,
1814 enum submodule_update_type update,
1815 struct submodule_update_strategy *out)
1816 {
1817 const struct submodule *sub = submodule_from_path(r, null_oid(), path);
1818 char *key;
1819 const char *val;
1820
1821 key = xstrfmt("submodule.%s.update", sub->name);
1822
1823 if (update) {
1824 out->type = update;
1825 } else if (!repo_config_get_string_tmp(r, key, &val)) {
1826 if (parse_submodule_update_strategy(val, out) < 0)
1827 die(_("Invalid update mode '%s' configured for submodule path '%s'"),
1828 val, path);
1829 } else if (sub->update_strategy.type != SM_UPDATE_UNSPECIFIED) {
1830 if (sub->update_strategy.type == SM_UPDATE_COMMAND)
1831 BUG("how did we read update = !command from .gitmodules?");
1832 out->type = sub->update_strategy.type;
1833 out->command = sub->update_strategy.command;
1834 } else
1835 out->type = SM_UPDATE_CHECKOUT;
1836
1837 if (just_cloned &&
1838 (out->type == SM_UPDATE_MERGE ||
1839 out->type == SM_UPDATE_REBASE ||
1840 out->type == SM_UPDATE_NONE))
1841 out->type = SM_UPDATE_CHECKOUT;
1842
1843 free(key);
1844 }
1845
1846 struct update_clone_data {
1847 const struct submodule *sub;
1848 struct object_id oid;
1849 unsigned just_cloned;
1850 };
1851
1852 struct submodule_update_clone {
1853 /* index into 'update_data.list', the list of submodules to look into for cloning */
1854 int current;
1855
1856 /* configuration parameters which are passed on to the children */
1857 struct update_data *update_data;
1858
1859 /* to be consumed by update_submodule() */
1860 struct update_clone_data *update_clone;
1861 int update_clone_nr; int update_clone_alloc;
1862
1863 /* If we want to stop as fast as possible and return an error */
1864 unsigned quickstop : 1;
1865
1866 /* failed clones to be retried again */
1867 const struct cache_entry **failed_clones;
1868 int failed_clones_nr, failed_clones_alloc;
1869 };
1870 #define SUBMODULE_UPDATE_CLONE_INIT { 0 }
1871
1872 struct update_data {
1873 const char *prefix;
1874 const char *displaypath;
1875 enum submodule_update_type update_default;
1876 struct object_id suboid;
1877 struct string_list references;
1878 struct submodule_update_strategy update_strategy;
1879 struct list_objects_filter_options *filter_options;
1880 struct module_list list;
1881 int depth;
1882 int max_jobs;
1883 int single_branch;
1884 int recommend_shallow;
1885 unsigned int require_init;
1886 unsigned int force;
1887 unsigned int quiet;
1888 unsigned int nofetch;
1889 unsigned int remote;
1890 unsigned int progress;
1891 unsigned int dissociate;
1892 unsigned int init;
1893 unsigned int warn_if_uninitialized;
1894 unsigned int recursive;
1895
1896 /* copied over from update_clone_data */
1897 struct object_id oid;
1898 unsigned int just_cloned;
1899 const char *sm_path;
1900 };
1901 #define UPDATE_DATA_INIT { \
1902 .update_strategy = SUBMODULE_UPDATE_STRATEGY_INIT, \
1903 .list = MODULE_LIST_INIT, \
1904 .recommend_shallow = -1, \
1905 .references = STRING_LIST_INIT_DUP, \
1906 .single_branch = -1, \
1907 .max_jobs = 1, \
1908 }
1909
1910 static void next_submodule_warn_missing(struct submodule_update_clone *suc,
1911 struct strbuf *out, const char *displaypath)
1912 {
1913 /*
1914 * Only mention uninitialized submodules when their
1915 * paths have been specified.
1916 */
1917 if (suc->update_data->warn_if_uninitialized) {
1918 strbuf_addf(out,
1919 _("Submodule path '%s' not initialized"),
1920 displaypath);
1921 strbuf_addch(out, '\n');
1922 strbuf_addstr(out,
1923 _("Maybe you want to use 'update --init'?"));
1924 strbuf_addch(out, '\n');
1925 }
1926 }
1927
1928 /**
1929 * Determine whether 'ce' needs to be cloned. If so, prepare the 'child' to
1930 * run the clone. Returns 1 if 'ce' needs to be cloned, 0 otherwise.
1931 */
1932 static int prepare_to_clone_next_submodule(const struct cache_entry *ce,
1933 struct child_process *child,
1934 struct submodule_update_clone *suc,
1935 struct strbuf *out)
1936 {
1937 const struct submodule *sub = NULL;
1938 const char *url = NULL;
1939 const char *update_string;
1940 enum submodule_update_type update_type;
1941 char *key;
1942 struct update_data *ud = suc->update_data;
1943 char *displaypath = get_submodule_displaypath(ce->name, ud->prefix);
1944 struct strbuf sb = STRBUF_INIT;
1945 int needs_cloning = 0;
1946 int need_free_url = 0;
1947
1948 if (ce_stage(ce)) {
1949 strbuf_addf(out, _("Skipping unmerged submodule %s"), displaypath);
1950 strbuf_addch(out, '\n');
1951 goto cleanup;
1952 }
1953
1954 sub = submodule_from_path(the_repository, null_oid(), ce->name);
1955
1956 if (!sub) {
1957 next_submodule_warn_missing(suc, out, displaypath);
1958 goto cleanup;
1959 }
1960
1961 key = xstrfmt("submodule.%s.update", sub->name);
1962 if (!repo_config_get_string_tmp(the_repository, key, &update_string)) {
1963 update_type = parse_submodule_update_type(update_string);
1964 } else {
1965 update_type = sub->update_strategy.type;
1966 }
1967 free(key);
1968
1969 if (suc->update_data->update_strategy.type == SM_UPDATE_NONE
1970 || (suc->update_data->update_strategy.type == SM_UPDATE_UNSPECIFIED
1971 && update_type == SM_UPDATE_NONE)) {
1972 strbuf_addf(out, _("Skipping submodule '%s'"), displaypath);
1973 strbuf_addch(out, '\n');
1974 goto cleanup;
1975 }
1976
1977 /* Check if the submodule has been initialized. */
1978 if (!is_submodule_active(the_repository, ce->name)) {
1979 next_submodule_warn_missing(suc, out, displaypath);
1980 goto cleanup;
1981 }
1982
1983 strbuf_reset(&sb);
1984 strbuf_addf(&sb, "submodule.%s.url", sub->name);
1985 if (repo_config_get_string_tmp(the_repository, sb.buf, &url)) {
1986 if (starts_with_dot_slash(sub->url) ||
1987 starts_with_dot_dot_slash(sub->url)) {
1988 url = resolve_relative_url(sub->url, NULL, 0);
1989 need_free_url = 1;
1990 } else
1991 url = sub->url;
1992 }
1993
1994 strbuf_reset(&sb);
1995 strbuf_addf(&sb, "%s/.git", ce->name);
1996 needs_cloning = !file_exists(sb.buf);
1997
1998 ALLOC_GROW(suc->update_clone, suc->update_clone_nr + 1,
1999 suc->update_clone_alloc);
2000 oidcpy(&suc->update_clone[suc->update_clone_nr].oid, &ce->oid);
2001 suc->update_clone[suc->update_clone_nr].just_cloned = needs_cloning;
2002 suc->update_clone[suc->update_clone_nr].sub = sub;
2003 suc->update_clone_nr++;
2004
2005 if (!needs_cloning)
2006 goto cleanup;
2007
2008 child->git_cmd = 1;
2009 child->no_stdin = 1;
2010 child->stdout_to_stderr = 1;
2011 child->err = -1;
2012 strvec_push(&child->args, "submodule--helper");
2013 strvec_push(&child->args, "clone");
2014 if (suc->update_data->progress)
2015 strvec_push(&child->args, "--progress");
2016 if (suc->update_data->quiet)
2017 strvec_push(&child->args, "--quiet");
2018 if (suc->update_data->prefix)
2019 strvec_pushl(&child->args, "--prefix", suc->update_data->prefix, NULL);
2020 if (suc->update_data->recommend_shallow && sub->recommend_shallow == 1)
2021 strvec_push(&child->args, "--depth=1");
2022 else if (suc->update_data->depth)
2023 strvec_pushf(&child->args, "--depth=%d", suc->update_data->depth);
2024 if (suc->update_data->filter_options && suc->update_data->filter_options->choice)
2025 strvec_pushf(&child->args, "--filter=%s",
2026 expand_list_objects_filter_spec(suc->update_data->filter_options));
2027 if (suc->update_data->require_init)
2028 strvec_push(&child->args, "--require-init");
2029 strvec_pushl(&child->args, "--path", sub->path, NULL);
2030 strvec_pushl(&child->args, "--name", sub->name, NULL);
2031 strvec_pushl(&child->args, "--url", url, NULL);
2032 if (suc->update_data->references.nr) {
2033 struct string_list_item *item;
2034 for_each_string_list_item(item, &suc->update_data->references)
2035 strvec_pushl(&child->args, "--reference", item->string, NULL);
2036 }
2037 if (suc->update_data->dissociate)
2038 strvec_push(&child->args, "--dissociate");
2039 if (suc->update_data->single_branch >= 0)
2040 strvec_push(&child->args, suc->update_data->single_branch ?
2041 "--single-branch" :
2042 "--no-single-branch");
2043
2044 cleanup:
2045 free(displaypath);
2046 strbuf_release(&sb);
2047 if (need_free_url)
2048 free((void*)url);
2049
2050 return needs_cloning;
2051 }
2052
2053 static int update_clone_get_next_task(struct child_process *child,
2054 struct strbuf *err,
2055 void *suc_cb,
2056 void **idx_task_cb)
2057 {
2058 struct submodule_update_clone *suc = suc_cb;
2059 const struct cache_entry *ce;
2060 int index;
2061
2062 for (; suc->current < suc->update_data->list.nr; suc->current++) {
2063 ce = suc->update_data->list.entries[suc->current];
2064 if (prepare_to_clone_next_submodule(ce, child, suc, err)) {
2065 int *p = xmalloc(sizeof(*p));
2066 *p = suc->current;
2067 *idx_task_cb = p;
2068 suc->current++;
2069 return 1;
2070 }
2071 }
2072
2073 /*
2074 * The loop above tried cloning each submodule once, now try the
2075 * stragglers again, which we can imagine as an extension of the
2076 * entry list.
2077 */
2078 index = suc->current - suc->update_data->list.nr;
2079 if (index < suc->failed_clones_nr) {
2080 int *p;
2081 ce = suc->failed_clones[index];
2082 if (!prepare_to_clone_next_submodule(ce, child, suc, err)) {
2083 suc->current ++;
2084 strbuf_addstr(err, "BUG: submodule considered for "
2085 "cloning, doesn't need cloning "
2086 "any more?\n");
2087 return 0;
2088 }
2089 p = xmalloc(sizeof(*p));
2090 *p = suc->current;
2091 *idx_task_cb = p;
2092 suc->current ++;
2093 return 1;
2094 }
2095
2096 return 0;
2097 }
2098
2099 static int update_clone_start_failure(struct strbuf *err,
2100 void *suc_cb,
2101 void *idx_task_cb)
2102 {
2103 struct submodule_update_clone *suc = suc_cb;
2104 suc->quickstop = 1;
2105 return 1;
2106 }
2107
2108 static int update_clone_task_finished(int result,
2109 struct strbuf *err,
2110 void *suc_cb,
2111 void *idx_task_cb)
2112 {
2113 const struct cache_entry *ce;
2114 struct submodule_update_clone *suc = suc_cb;
2115
2116 int *idxP = idx_task_cb;
2117 int idx = *idxP;
2118 free(idxP);
2119
2120 if (!result)
2121 return 0;
2122
2123 if (idx < suc->update_data->list.nr) {
2124 ce = suc->update_data->list.entries[idx];
2125 strbuf_addf(err, _("Failed to clone '%s'. Retry scheduled"),
2126 ce->name);
2127 strbuf_addch(err, '\n');
2128 ALLOC_GROW(suc->failed_clones,
2129 suc->failed_clones_nr + 1,
2130 suc->failed_clones_alloc);
2131 suc->failed_clones[suc->failed_clones_nr++] = ce;
2132 return 0;
2133 } else {
2134 idx -= suc->update_data->list.nr;
2135 ce = suc->failed_clones[idx];
2136 strbuf_addf(err, _("Failed to clone '%s' a second time, aborting"),
2137 ce->name);
2138 strbuf_addch(err, '\n');
2139 suc->quickstop = 1;
2140 return 1;
2141 }
2142
2143 return 0;
2144 }
2145
2146 static int git_update_clone_config(const char *var, const char *value,
2147 void *cb)
2148 {
2149 int *max_jobs = cb;
2150 if (!strcmp(var, "submodule.fetchjobs"))
2151 *max_jobs = parse_submodule_fetchjobs(var, value);
2152 return 0;
2153 }
2154
2155 static int is_tip_reachable(const char *path, struct object_id *oid)
2156 {
2157 struct child_process cp = CHILD_PROCESS_INIT;
2158 struct strbuf rev = STRBUF_INIT;
2159 char *hex = oid_to_hex(oid);
2160
2161 cp.git_cmd = 1;
2162 cp.dir = xstrdup(path);
2163 cp.no_stderr = 1;
2164 strvec_pushl(&cp.args, "rev-list", "-n", "1", hex, "--not", "--all", NULL);
2165
2166 prepare_submodule_repo_env(&cp.env);
2167
2168 if (capture_command(&cp, &rev, GIT_MAX_HEXSZ + 1) || rev.len)
2169 return 0;
2170
2171 return 1;
2172 }
2173
2174 static int fetch_in_submodule(const char *module_path, int depth, int quiet, struct object_id *oid)
2175 {
2176 struct child_process cp = CHILD_PROCESS_INIT;
2177
2178 prepare_submodule_repo_env(&cp.env);
2179 cp.git_cmd = 1;
2180 cp.dir = xstrdup(module_path);
2181
2182 strvec_push(&cp.args, "fetch");
2183 if (quiet)
2184 strvec_push(&cp.args, "--quiet");
2185 if (depth)
2186 strvec_pushf(&cp.args, "--depth=%d", depth);
2187 if (oid) {
2188 char *hex = oid_to_hex(oid);
2189 char *remote = get_default_remote();
2190 strvec_pushl(&cp.args, remote, hex, NULL);
2191 free(remote);
2192 }
2193
2194 return run_command(&cp);
2195 }
2196
2197 static int run_update_command(struct update_data *ud, int subforce)
2198 {
2199 struct child_process cp = CHILD_PROCESS_INIT;
2200 char *oid = oid_to_hex(&ud->oid);
2201 int must_die_on_failure = 0;
2202
2203 switch (ud->update_strategy.type) {
2204 case SM_UPDATE_CHECKOUT:
2205 cp.git_cmd = 1;
2206 strvec_pushl(&cp.args, "checkout", "-q", NULL);
2207 if (subforce)
2208 strvec_push(&cp.args, "-f");
2209 break;
2210 case SM_UPDATE_REBASE:
2211 cp.git_cmd = 1;
2212 strvec_push(&cp.args, "rebase");
2213 if (ud->quiet)
2214 strvec_push(&cp.args, "--quiet");
2215 must_die_on_failure = 1;
2216 break;
2217 case SM_UPDATE_MERGE:
2218 cp.git_cmd = 1;
2219 strvec_push(&cp.args, "merge");
2220 if (ud->quiet)
2221 strvec_push(&cp.args, "--quiet");
2222 must_die_on_failure = 1;
2223 break;
2224 case SM_UPDATE_COMMAND:
2225 cp.use_shell = 1;
2226 strvec_push(&cp.args, ud->update_strategy.command);
2227 must_die_on_failure = 1;
2228 break;
2229 default:
2230 BUG("unexpected update strategy type: %s",
2231 submodule_strategy_to_string(&ud->update_strategy));
2232 }
2233 strvec_push(&cp.args, oid);
2234
2235 cp.dir = xstrdup(ud->sm_path);
2236 prepare_submodule_repo_env(&cp.env);
2237 if (run_command(&cp)) {
2238 switch (ud->update_strategy.type) {
2239 case SM_UPDATE_CHECKOUT:
2240 die_message(_("Unable to checkout '%s' in submodule path '%s'"),
2241 oid, ud->displaypath);
2242 break;
2243 case SM_UPDATE_REBASE:
2244 die_message(_("Unable to rebase '%s' in submodule path '%s'"),
2245 oid, ud->displaypath);
2246 break;
2247 case SM_UPDATE_MERGE:
2248 die_message(_("Unable to merge '%s' in submodule path '%s'"),
2249 oid, ud->displaypath);
2250 break;
2251 case SM_UPDATE_COMMAND:
2252 die_message(_("Execution of '%s %s' failed in submodule path '%s'"),
2253 ud->update_strategy.command, oid, ud->displaypath);
2254 break;
2255 default:
2256 BUG("unexpected update strategy type: %s",
2257 submodule_strategy_to_string(&ud->update_strategy));
2258 }
2259 if (must_die_on_failure)
2260 exit(128);
2261
2262 /* the command failed, but update must continue */
2263 return 1;
2264 }
2265
2266 if (ud->quiet)
2267 return 0;
2268
2269 switch (ud->update_strategy.type) {
2270 case SM_UPDATE_CHECKOUT:
2271 printf(_("Submodule path '%s': checked out '%s'\n"),
2272 ud->displaypath, oid);
2273 break;
2274 case SM_UPDATE_REBASE:
2275 printf(_("Submodule path '%s': rebased into '%s'\n"),
2276 ud->displaypath, oid);
2277 break;
2278 case SM_UPDATE_MERGE:
2279 printf(_("Submodule path '%s': merged in '%s'\n"),
2280 ud->displaypath, oid);
2281 break;
2282 case SM_UPDATE_COMMAND:
2283 printf(_("Submodule path '%s': '%s %s'\n"),
2284 ud->displaypath, ud->update_strategy.command, oid);
2285 break;
2286 default:
2287 BUG("unexpected update strategy type: %s",
2288 submodule_strategy_to_string(&ud->update_strategy));
2289 }
2290
2291 return 0;
2292 }
2293
2294 static int run_update_procedure(struct update_data *ud)
2295 {
2296 int subforce = is_null_oid(&ud->suboid) || ud->force;
2297
2298 if (!ud->nofetch) {
2299 /*
2300 * Run fetch only if `oid` isn't present or it
2301 * is not reachable from a ref.
2302 */
2303 if (!is_tip_reachable(ud->sm_path, &ud->oid) &&
2304 fetch_in_submodule(ud->sm_path, ud->depth, ud->quiet, NULL) &&
2305 !ud->quiet)
2306 fprintf_ln(stderr,
2307 _("Unable to fetch in submodule path '%s'; "
2308 "trying to directly fetch %s:"),
2309 ud->displaypath, oid_to_hex(&ud->oid));
2310 /*
2311 * Now we tried the usual fetch, but `oid` may
2312 * not be reachable from any of the refs.
2313 */
2314 if (!is_tip_reachable(ud->sm_path, &ud->oid) &&
2315 fetch_in_submodule(ud->sm_path, ud->depth, ud->quiet, &ud->oid))
2316 die(_("Fetched in submodule path '%s', but it did not "
2317 "contain %s. Direct fetching of that commit failed."),
2318 ud->displaypath, oid_to_hex(&ud->oid));
2319 }
2320
2321 return run_update_command(ud, subforce);
2322 }
2323
2324 static const char *remote_submodule_branch(const char *path)
2325 {
2326 const struct submodule *sub;
2327 const char *branch = NULL;
2328 char *key;
2329
2330 sub = submodule_from_path(the_repository, null_oid(), path);
2331 if (!sub)
2332 return NULL;
2333
2334 key = xstrfmt("submodule.%s.branch", sub->name);
2335 if (repo_config_get_string_tmp(the_repository, key, &branch))
2336 branch = sub->branch;
2337 free(key);
2338
2339 if (!branch)
2340 return "HEAD";
2341
2342 if (!strcmp(branch, ".")) {
2343 const char *refname = resolve_ref_unsafe("HEAD", 0, NULL, NULL);
2344
2345 if (!refname)
2346 die(_("No such ref: %s"), "HEAD");
2347
2348 /* detached HEAD */
2349 if (!strcmp(refname, "HEAD"))
2350 die(_("Submodule (%s) branch configured to inherit "
2351 "branch from superproject, but the superproject "
2352 "is not on any branch"), sub->name);
2353
2354 if (!skip_prefix(refname, "refs/heads/", &refname))
2355 die(_("Expecting a full ref name, got %s"), refname);
2356 return refname;
2357 }
2358
2359 return branch;
2360 }
2361
2362 static void ensure_core_worktree(const char *path)
2363 {
2364 const char *cw;
2365 struct repository subrepo;
2366
2367 if (repo_submodule_init(&subrepo, the_repository, path, null_oid()))
2368 die(_("could not get a repository handle for submodule '%s'"), path);
2369
2370 if (!repo_config_get_string_tmp(&subrepo, "core.worktree", &cw)) {
2371 char *cfg_file, *abs_path;
2372 const char *rel_path;
2373 struct strbuf sb = STRBUF_INIT;
2374
2375 cfg_file = repo_git_path(&subrepo, "config");
2376
2377 abs_path = absolute_pathdup(path);
2378 rel_path = relative_path(abs_path, subrepo.gitdir, &sb);
2379
2380 git_config_set_in_file(cfg_file, "core.worktree", rel_path);
2381
2382 free(cfg_file);
2383 free(abs_path);
2384 strbuf_release(&sb);
2385 }
2386 }
2387
2388 static const char *submodule_update_type_to_label(enum submodule_update_type type)
2389 {
2390 switch (type) {
2391 case SM_UPDATE_CHECKOUT:
2392 return "checkout";
2393 case SM_UPDATE_MERGE:
2394 return "merge";
2395 case SM_UPDATE_REBASE:
2396 return "rebase";
2397 case SM_UPDATE_UNSPECIFIED:
2398 case SM_UPDATE_NONE:
2399 case SM_UPDATE_COMMAND:
2400 break;
2401 }
2402 BUG("unreachable with type %d", type);
2403 }
2404
2405 static void update_data_to_args(struct update_data *update_data, struct strvec *args)
2406 {
2407 enum submodule_update_type update_type = update_data->update_default;
2408
2409 if (update_data->displaypath) {
2410 strvec_push(args, "--super-prefix");
2411 strvec_pushf(args, "%s/", update_data->displaypath);
2412 }
2413 strvec_pushl(args, "submodule--helper", "update", "--recursive", NULL);
2414 strvec_pushf(args, "--jobs=%d", update_data->max_jobs);
2415 if (update_data->quiet)
2416 strvec_push(args, "--quiet");
2417 if (update_data->force)
2418 strvec_push(args, "--force");
2419 if (update_data->init)
2420 strvec_push(args, "--init");
2421 if (update_data->remote)
2422 strvec_push(args, "--remote");
2423 if (update_data->nofetch)
2424 strvec_push(args, "--no-fetch");
2425 if (update_data->dissociate)
2426 strvec_push(args, "--dissociate");
2427 if (update_data->progress)
2428 strvec_push(args, "--progress");
2429 if (update_data->require_init)
2430 strvec_push(args, "--require-init");
2431 if (update_data->depth)
2432 strvec_pushf(args, "--depth=%d", update_data->depth);
2433 if (update_type != SM_UPDATE_UNSPECIFIED)
2434 strvec_pushf(args, "--%s",
2435 submodule_update_type_to_label(update_type));
2436
2437 if (update_data->references.nr) {
2438 struct string_list_item *item;
2439 for_each_string_list_item(item, &update_data->references)
2440 strvec_pushl(args, "--reference", item->string, NULL);
2441 }
2442 if (update_data->filter_options && update_data->filter_options->choice)
2443 strvec_pushf(args, "--filter=%s",
2444 expand_list_objects_filter_spec(
2445 update_data->filter_options));
2446 if (update_data->recommend_shallow == 0)
2447 strvec_push(args, "--no-recommend-shallow");
2448 else if (update_data->recommend_shallow == 1)
2449 strvec_push(args, "--recommend-shallow");
2450 if (update_data->single_branch >= 0)
2451 strvec_push(args, update_data->single_branch ?
2452 "--single-branch" :
2453 "--no-single-branch");
2454 }
2455
2456 static int update_submodule(struct update_data *update_data)
2457 {
2458 ensure_core_worktree(update_data->sm_path);
2459
2460 update_data->displaypath = get_submodule_displaypath(
2461 update_data->sm_path, update_data->prefix);
2462
2463 determine_submodule_update_strategy(the_repository, update_data->just_cloned,
2464 update_data->sm_path, update_data->update_default,
2465 &update_data->update_strategy);
2466
2467 if (update_data->just_cloned)
2468 oidcpy(&update_data->suboid, null_oid());
2469 else if (resolve_gitlink_ref(update_data->sm_path, "HEAD", &update_data->suboid))
2470 die(_("Unable to find current revision in submodule path '%s'"),
2471 update_data->displaypath);
2472
2473 if (update_data->remote) {
2474 char *remote_name = get_default_remote_submodule(update_data->sm_path);
2475 const char *branch = remote_submodule_branch(update_data->sm_path);
2476 char *remote_ref = xstrfmt("refs/remotes/%s/%s", remote_name, branch);
2477
2478 if (!update_data->nofetch) {
2479 if (fetch_in_submodule(update_data->sm_path, update_data->depth,
2480 0, NULL))
2481 die(_("Unable to fetch in submodule path '%s'"),
2482 update_data->sm_path);
2483 }
2484
2485 if (resolve_gitlink_ref(update_data->sm_path, remote_ref, &update_data->oid))
2486 die(_("Unable to find %s revision in submodule path '%s'"),
2487 remote_ref, update_data->sm_path);
2488
2489 free(remote_ref);
2490 }
2491
2492 if (!oideq(&update_data->oid, &update_data->suboid) || update_data->force)
2493 if (run_update_procedure(update_data))
2494 return 1;
2495
2496 if (update_data->recursive) {
2497 struct child_process cp = CHILD_PROCESS_INIT;
2498 struct update_data next = *update_data;
2499 int res;
2500
2501 next.prefix = NULL;
2502 oidcpy(&next.oid, null_oid());
2503 oidcpy(&next.suboid, null_oid());
2504
2505 cp.dir = update_data->sm_path;
2506 cp.git_cmd = 1;
2507 prepare_submodule_repo_env(&cp.env);
2508 update_data_to_args(&next, &cp.args);
2509
2510 /* die() if child process die()'d */
2511 res = run_command(&cp);
2512 if (!res)
2513 return 0;
2514 die_message(_("Failed to recurse into submodule path '%s'"),
2515 update_data->displaypath);
2516 if (res == 128)
2517 exit(res);
2518 else if (res)
2519 return 1;
2520 }
2521
2522 return 0;
2523 }
2524
2525 static int update_submodules(struct update_data *update_data)
2526 {
2527 int i, res = 0;
2528 struct submodule_update_clone suc = SUBMODULE_UPDATE_CLONE_INIT;
2529
2530 suc.update_data = update_data;
2531 run_processes_parallel_tr2(suc.update_data->max_jobs, update_clone_get_next_task,
2532 update_clone_start_failure,
2533 update_clone_task_finished, &suc, "submodule",
2534 "parallel/update");
2535
2536 /*
2537 * We saved the output and put it out all at once now.
2538 * That means:
2539 * - the listener does not have to interleave their (checkout)
2540 * work with our fetching. The writes involved in a
2541 * checkout involve more straightforward sequential I/O.
2542 * - the listener can avoid doing any work if fetching failed.
2543 */
2544 if (suc.quickstop) {
2545 res = 1;
2546 goto cleanup;
2547 }
2548
2549 for (i = 0; i < suc.update_clone_nr; i++) {
2550 struct update_clone_data ucd = suc.update_clone[i];
2551
2552 oidcpy(&update_data->oid, &ucd.oid);
2553 update_data->just_cloned = ucd.just_cloned;
2554 update_data->sm_path = ucd.sub->path;
2555
2556 if (update_submodule(update_data))
2557 res = 1;
2558 }
2559
2560 cleanup:
2561 string_list_clear(&update_data->references, 0);
2562 return res;
2563 }
2564
2565 static int module_update(int argc, const char **argv, const char *prefix)
2566 {
2567 struct pathspec pathspec;
2568 struct update_data opt = UPDATE_DATA_INIT;
2569 struct list_objects_filter_options filter_options;
2570 int ret;
2571
2572 struct option module_update_options[] = {
2573 OPT__FORCE(&opt.force, N_("force checkout updates"), 0),
2574 OPT_BOOL(0, "init", &opt.init,
2575 N_("initialize uninitialized submodules before update")),
2576 OPT_BOOL(0, "remote", &opt.remote,
2577 N_("use SHA-1 of submodule's remote tracking branch")),
2578 OPT_BOOL(0, "recursive", &opt.recursive,
2579 N_("traverse submodules recursively")),
2580 OPT_BOOL('N', "no-fetch", &opt.nofetch,
2581 N_("don't fetch new objects from the remote site")),
2582 OPT_STRING(0, "prefix", &opt.prefix,
2583 N_("path"),
2584 N_("path into the working tree")),
2585 OPT_SET_INT(0, "checkout", &opt.update_default,
2586 N_("use the 'checkout' update strategy (default)"),
2587 SM_UPDATE_CHECKOUT),
2588 OPT_SET_INT('m', "merge", &opt.update_default,
2589 N_("use the 'merge' update strategy"),
2590 SM_UPDATE_MERGE),
2591 OPT_SET_INT('r', "rebase", &opt.update_default,
2592 N_("use the 'rebase' update strategy"),
2593 SM_UPDATE_REBASE),
2594 OPT_STRING_LIST(0, "reference", &opt.references, N_("repo"),
2595 N_("reference repository")),
2596 OPT_BOOL(0, "dissociate", &opt.dissociate,
2597 N_("use --reference only while cloning")),
2598 OPT_INTEGER(0, "depth", &opt.depth,
2599 N_("create a shallow clone truncated to the "
2600 "specified number of revisions")),
2601 OPT_INTEGER('j', "jobs", &opt.max_jobs,
2602 N_("parallel jobs")),
2603 OPT_BOOL(0, "recommend-shallow", &opt.recommend_shallow,
2604 N_("whether the initial clone should follow the shallow recommendation")),
2605 OPT__QUIET(&opt.quiet, N_("don't print cloning progress")),
2606 OPT_BOOL(0, "progress", &opt.progress,
2607 N_("force cloning progress")),
2608 OPT_BOOL(0, "require-init", &opt.require_init,
2609 N_("disallow cloning into non-empty directory, implies --init")),
2610 OPT_BOOL(0, "single-branch", &opt.single_branch,
2611 N_("clone only one branch, HEAD or --branch")),
2612 OPT_PARSE_LIST_OBJECTS_FILTER(&filter_options),
2613 OPT_END()
2614 };
2615
2616 const char *const git_submodule_helper_usage[] = {
2617 N_("git submodule [--quiet] update"
2618 " [--init [--filter=<filter-spec>]] [--remote]"
2619 " [-N|--no-fetch] [-f|--force]"
2620 " [--checkout|--merge|--rebase]"
2621 " [--[no-]recommend-shallow] [--reference <repository>]"
2622 " [--recursive] [--[no-]single-branch] [--] [<path>...]"),
2623 NULL
2624 };
2625
2626 update_clone_config_from_gitmodules(&opt.max_jobs);
2627 git_config(git_update_clone_config, &opt.max_jobs);
2628
2629 memset(&filter_options, 0, sizeof(filter_options));
2630 argc = parse_options(argc, argv, prefix, module_update_options,
2631 git_submodule_helper_usage, 0);
2632
2633 if (opt.require_init)
2634 opt.init = 1;
2635
2636 if (filter_options.choice && !opt.init) {
2637 usage_with_options(git_submodule_helper_usage,
2638 module_update_options);
2639 }
2640
2641 opt.filter_options = &filter_options;
2642
2643 if (opt.update_default)
2644 opt.update_strategy.type = opt.update_default;
2645
2646 if (module_list_compute(argc, argv, prefix, &pathspec, &opt.list) < 0) {
2647 list_objects_filter_release(&filter_options);
2648 return 1;
2649 }
2650
2651 if (pathspec.nr)
2652 opt.warn_if_uninitialized = 1;
2653
2654 if (opt.init) {
2655 struct module_list list = MODULE_LIST_INIT;
2656 struct init_cb info = INIT_CB_INIT;
2657
2658 if (module_list_compute(argc, argv, opt.prefix,
2659 &pathspec, &list) < 0)
2660 return 1;
2661
2662 /*
2663 * If there are no path args and submodule.active is set then,
2664 * by default, only initialize 'active' modules.
2665 */
2666 if (!argc && git_config_get_value_multi("submodule.active"))
2667 module_list_active(&list);
2668
2669 info.prefix = opt.prefix;
2670 if (opt.quiet)
2671 info.flags |= OPT_QUIET;
2672
2673 for_each_listed_submodule(&list, init_submodule_cb, &info);
2674 }
2675
2676 ret = update_submodules(&opt);
2677 list_objects_filter_release(&filter_options);
2678 return ret;
2679 }
2680
2681 static int push_check(int argc, const char **argv, const char *prefix)
2682 {
2683 struct remote *remote;
2684 const char *superproject_head;
2685 char *head;
2686 int detached_head = 0;
2687 struct object_id head_oid;
2688
2689 if (argc < 3)
2690 die("submodule--helper push-check requires at least 2 arguments");
2691
2692 /*
2693 * superproject's resolved head ref.
2694 * if HEAD then the superproject is in a detached head state, otherwise
2695 * it will be the resolved head ref.
2696 */
2697 superproject_head = argv[1];
2698 argv++;
2699 argc--;
2700 /* Get the submodule's head ref and determine if it is detached */
2701 head = resolve_refdup("HEAD", 0, &head_oid, NULL);
2702 if (!head)
2703 die(_("Failed to resolve HEAD as a valid ref."));
2704 if (!strcmp(head, "HEAD"))
2705 detached_head = 1;
2706
2707 /*
2708 * The remote must be configured.
2709 * This is to avoid pushing to the exact same URL as the parent.
2710 */
2711 remote = pushremote_get(argv[1]);
2712 if (!remote || remote->origin == REMOTE_UNCONFIGURED)
2713 die("remote '%s' not configured", argv[1]);
2714
2715 /* Check the refspec */
2716 if (argc > 2) {
2717 int i;
2718 struct ref *local_refs = get_local_heads();
2719 struct refspec refspec = REFSPEC_INIT_PUSH;
2720
2721 refspec_appendn(&refspec, argv + 2, argc - 2);
2722
2723 for (i = 0; i < refspec.nr; i++) {
2724 const struct refspec_item *rs = &refspec.items[i];
2725
2726 if (rs->pattern || rs->matching)
2727 continue;
2728
2729 /* LHS must match a single ref */
2730 switch (count_refspec_match(rs->src, local_refs, NULL)) {
2731 case 1:
2732 break;
2733 case 0:
2734 /*
2735 * If LHS matches 'HEAD' then we need to ensure
2736 * that it matches the same named branch
2737 * checked out in the superproject.
2738 */
2739 if (!strcmp(rs->src, "HEAD")) {
2740 if (!detached_head &&
2741 !strcmp(head, superproject_head))
2742 break;
2743 die("HEAD does not match the named branch in the superproject");
2744 }
2745 /* fallthrough */
2746 default:
2747 die("src refspec '%s' must name a ref",
2748 rs->src);
2749 }
2750 }
2751 refspec_clear(&refspec);
2752 }
2753 free(head);
2754
2755 return 0;
2756 }
2757
2758 static int absorb_git_dirs(int argc, const char **argv, const char *prefix)
2759 {
2760 int i;
2761 struct pathspec pathspec;
2762 struct module_list list = MODULE_LIST_INIT;
2763 unsigned flags = ABSORB_GITDIR_RECURSE_SUBMODULES;
2764
2765 struct option embed_gitdir_options[] = {
2766 OPT_STRING(0, "prefix", &prefix,
2767 N_("path"),
2768 N_("path into the working tree")),
2769 OPT_BIT(0, "--recursive", &flags, N_("recurse into submodules"),
2770 ABSORB_GITDIR_RECURSE_SUBMODULES),
2771 OPT_END()
2772 };
2773
2774 const char *const git_submodule_helper_usage[] = {
2775 N_("git submodule absorbgitdirs [<options>] [<path>...]"),
2776 NULL
2777 };
2778
2779 argc = parse_options(argc, argv, prefix, embed_gitdir_options,
2780 git_submodule_helper_usage, 0);
2781
2782 if (module_list_compute(argc, argv, prefix, &pathspec, &list) < 0)
2783 return 1;
2784
2785 for (i = 0; i < list.nr; i++)
2786 absorb_git_dir_into_superproject(list.entries[i]->name, flags);
2787
2788 return 0;
2789 }
2790
2791 static int is_active(int argc, const char **argv, const char *prefix)
2792 {
2793 if (argc != 2)
2794 die("submodule--helper is-active takes exactly 1 argument");
2795
2796 return !is_submodule_active(the_repository, argv[1]);
2797 }
2798
2799 /*
2800 * Exit non-zero if any of the submodule names given on the command line is
2801 * invalid. If no names are given, filter stdin to print only valid names
2802 * (which is primarily intended for testing).
2803 */
2804 static int check_name(int argc, const char **argv, const char *prefix)
2805 {
2806 if (argc > 1) {
2807 while (*++argv) {
2808 if (check_submodule_name(*argv) < 0)
2809 return 1;
2810 }
2811 } else {
2812 struct strbuf buf = STRBUF_INIT;
2813 while (strbuf_getline(&buf, stdin) != EOF) {
2814 if (!check_submodule_name(buf.buf))
2815 printf("%s\n", buf.buf);
2816 }
2817 strbuf_release(&buf);
2818 }
2819 return 0;
2820 }
2821
2822 static int module_config(int argc, const char **argv, const char *prefix)
2823 {
2824 enum {
2825 CHECK_WRITEABLE = 1,
2826 DO_UNSET = 2
2827 } command = 0;
2828
2829 struct option module_config_options[] = {
2830 OPT_CMDMODE(0, "check-writeable", &command,
2831 N_("check if it is safe to write to the .gitmodules file"),
2832 CHECK_WRITEABLE),
2833 OPT_CMDMODE(0, "unset", &command,
2834 N_("unset the config in the .gitmodules file"),
2835 DO_UNSET),
2836 OPT_END()
2837 };
2838 const char *const git_submodule_helper_usage[] = {
2839 N_("git submodule--helper config <name> [<value>]"),
2840 N_("git submodule--helper config --unset <name>"),
2841 "git submodule--helper config --check-writeable",
2842 NULL
2843 };
2844
2845 argc = parse_options(argc, argv, prefix, module_config_options,
2846 git_submodule_helper_usage, PARSE_OPT_KEEP_ARGV0);
2847
2848 if (argc == 1 && command == CHECK_WRITEABLE)
2849 return is_writing_gitmodules_ok() ? 0 : -1;
2850
2851 /* Equivalent to ACTION_GET in builtin/config.c */
2852 if (argc == 2 && command != DO_UNSET)
2853 return print_config_from_gitmodules(the_repository, argv[1]);
2854
2855 /* Equivalent to ACTION_SET in builtin/config.c */
2856 if (argc == 3 || (argc == 2 && command == DO_UNSET)) {
2857 const char *value = (argc == 3) ? argv[2] : NULL;
2858
2859 if (!is_writing_gitmodules_ok())
2860 die(_("please make sure that the .gitmodules file is in the working tree"));
2861
2862 return config_set_in_gitmodules_file_gently(argv[1], value);
2863 }
2864
2865 usage_with_options(git_submodule_helper_usage, module_config_options);
2866 }
2867
2868 static int module_set_url(int argc, const char **argv, const char *prefix)
2869 {
2870 int quiet = 0;
2871 const char *newurl;
2872 const char *path;
2873 char *config_name;
2874
2875 struct option options[] = {
2876 OPT__QUIET(&quiet, N_("suppress output for setting url of a submodule")),
2877 OPT_END()
2878 };
2879 const char *const usage[] = {
2880 N_("git submodule set-url [--quiet] <path> <newurl>"),
2881 NULL
2882 };
2883
2884 argc = parse_options(argc, argv, prefix, options, usage, 0);
2885
2886 if (argc != 2 || !(path = argv[0]) || !(newurl = argv[1]))
2887 usage_with_options(usage, options);
2888
2889 config_name = xstrfmt("submodule.%s.url", path);
2890
2891 config_set_in_gitmodules_file_gently(config_name, newurl);
2892 sync_submodule(path, prefix, quiet ? OPT_QUIET : 0);
2893
2894 free(config_name);
2895
2896 return 0;
2897 }
2898
2899 static int module_set_branch(int argc, const char **argv, const char *prefix)
2900 {
2901 int opt_default = 0, ret;
2902 const char *opt_branch = NULL;
2903 const char *path;
2904 char *config_name;
2905
2906 /*
2907 * We accept the `quiet` option for uniformity across subcommands,
2908 * though there is nothing to make less verbose in this subcommand.
2909 */
2910 struct option options[] = {
2911 OPT_NOOP_NOARG('q', "quiet"),
2912 OPT_BOOL('d', "default", &opt_default,
2913 N_("set the default tracking branch to master")),
2914 OPT_STRING('b', "branch", &opt_branch, N_("branch"),
2915 N_("set the default tracking branch")),
2916 OPT_END()
2917 };
2918 const char *const usage[] = {
2919 N_("git submodule set-branch [-q|--quiet] (-d|--default) <path>"),
2920 N_("git submodule set-branch [-q|--quiet] (-b|--branch) <branch> <path>"),
2921 NULL
2922 };
2923
2924 argc = parse_options(argc, argv, prefix, options, usage, 0);
2925
2926 if (!opt_branch && !opt_default)
2927 die(_("--branch or --default required"));
2928
2929 if (opt_branch && opt_default)
2930 die(_("options '%s' and '%s' cannot be used together"), "--branch", "--default");
2931
2932 if (argc != 1 || !(path = argv[0]))
2933 usage_with_options(usage, options);
2934
2935 config_name = xstrfmt("submodule.%s.branch", path);
2936 ret = config_set_in_gitmodules_file_gently(config_name, opt_branch);
2937
2938 free(config_name);
2939 return !!ret;
2940 }
2941
2942 static int module_create_branch(int argc, const char **argv, const char *prefix)
2943 {
2944 enum branch_track track;
2945 int quiet = 0, force = 0, reflog = 0, dry_run = 0;
2946
2947 struct option options[] = {
2948 OPT__QUIET(&quiet, N_("print only error messages")),
2949 OPT__FORCE(&force, N_("force creation"), 0),
2950 OPT_BOOL(0, "create-reflog", &reflog,
2951 N_("create the branch's reflog")),
2952 OPT_CALLBACK_F('t', "track", &track, "(direct|inherit)",
2953 N_("set branch tracking configuration"),
2954 PARSE_OPT_OPTARG,
2955 parse_opt_tracking_mode),
2956 OPT__DRY_RUN(&dry_run,
2957 N_("show whether the branch would be created")),
2958 OPT_END()
2959 };
2960 const char *const usage[] = {
2961 N_("git submodule--helper create-branch [-f|--force] [--create-reflog] [-q|--quiet] [-t|--track] [-n|--dry-run] <name> <start-oid> <start-name>"),
2962 NULL
2963 };
2964
2965 git_config(git_default_config, NULL);
2966 track = git_branch_track;
2967 argc = parse_options(argc, argv, prefix, options, usage, 0);
2968
2969 if (argc != 3)
2970 usage_with_options(usage, options);
2971
2972 if (!quiet && !dry_run)
2973 printf_ln(_("creating branch '%s'"), argv[0]);
2974
2975 create_branches_recursively(the_repository, argv[0], argv[1], argv[2],
2976 force, reflog, quiet, track, dry_run);
2977 return 0;
2978 }
2979
2980 struct add_data {
2981 const char *prefix;
2982 const char *branch;
2983 const char *reference_path;
2984 char *sm_path;
2985 const char *sm_name;
2986 const char *repo;
2987 const char *realrepo;
2988 int depth;
2989 unsigned int force: 1;
2990 unsigned int quiet: 1;
2991 unsigned int progress: 1;
2992 unsigned int dissociate: 1;
2993 };
2994 #define ADD_DATA_INIT { .depth = -1 }
2995
2996 static void append_fetch_remotes(struct strbuf *msg, const char *git_dir_path)
2997 {
2998 struct child_process cp_remote = CHILD_PROCESS_INIT;
2999 struct strbuf sb_remote_out = STRBUF_INIT;
3000
3001 cp_remote.git_cmd = 1;
3002 strvec_pushf(&cp_remote.env,
3003 "GIT_DIR=%s", git_dir_path);
3004 strvec_push(&cp_remote.env, "GIT_WORK_TREE=.");
3005 strvec_pushl(&cp_remote.args, "remote", "-v", NULL);
3006 if (!capture_command(&cp_remote, &sb_remote_out, 0)) {
3007 char *next_line;
3008 char *line = sb_remote_out.buf;
3009 while ((next_line = strchr(line, '\n')) != NULL) {
3010 size_t len = next_line - line;
3011 if (strip_suffix_mem(line, &len, " (fetch)"))
3012 strbuf_addf(msg, " %.*s\n", (int)len, line);
3013 line = next_line + 1;
3014 }
3015 }
3016
3017 strbuf_release(&sb_remote_out);
3018 }
3019
3020 static int add_submodule(const struct add_data *add_data)
3021 {
3022 char *submod_gitdir_path;
3023 struct module_clone_data clone_data = MODULE_CLONE_DATA_INIT;
3024
3025 /* perhaps the path already exists and is already a git repo, else clone it */
3026 if (is_directory(add_data->sm_path)) {
3027 struct strbuf sm_path = STRBUF_INIT;
3028 strbuf_addstr(&sm_path, add_data->sm_path);
3029 submod_gitdir_path = xstrfmt("%s/.git", add_data->sm_path);
3030 if (is_nonbare_repository_dir(&sm_path))
3031 printf(_("Adding existing repo at '%s' to the index\n"),
3032 add_data->sm_path);
3033 else
3034 die(_("'%s' already exists and is not a valid git repo"),
3035 add_data->sm_path);
3036 strbuf_release(&sm_path);
3037 free(submod_gitdir_path);
3038 } else {
3039 struct child_process cp = CHILD_PROCESS_INIT;
3040 submod_gitdir_path = xstrfmt(".git/modules/%s", add_data->sm_name);
3041
3042 if (is_directory(submod_gitdir_path)) {
3043 if (!add_data->force) {
3044 struct strbuf msg = STRBUF_INIT;
3045 char *die_msg;
3046
3047 strbuf_addf(&msg, _("A git directory for '%s' is found "
3048 "locally with remote(s):\n"),
3049 add_data->sm_name);
3050
3051 append_fetch_remotes(&msg, submod_gitdir_path);
3052 free(submod_gitdir_path);
3053
3054 strbuf_addf(&msg, _("If you want to reuse this local git "
3055 "directory instead of cloning again from\n"
3056 " %s\n"
3057 "use the '--force' option. If the local git "
3058 "directory is not the correct repo\n"
3059 "or you are unsure what this means choose "
3060 "another name with the '--name' option."),
3061 add_data->realrepo);
3062
3063 die_msg = strbuf_detach(&msg, NULL);
3064 die("%s", die_msg);
3065 } else {
3066 printf(_("Reactivating local git directory for "
3067 "submodule '%s'\n"), add_data->sm_name);
3068 }
3069 }
3070 free(submod_gitdir_path);
3071
3072 clone_data.prefix = add_data->prefix;
3073 clone_data.path = add_data->sm_path;
3074 clone_data.name = add_data->sm_name;
3075 clone_data.url = add_data->realrepo;
3076 clone_data.quiet = add_data->quiet;
3077 clone_data.progress = add_data->progress;
3078 if (add_data->reference_path)
3079 string_list_append(&clone_data.reference,
3080 xstrdup(add_data->reference_path));
3081 clone_data.dissociate = add_data->dissociate;
3082 if (add_data->depth >= 0)
3083 clone_data.depth = xstrfmt("%d", add_data->depth);
3084
3085 if (clone_submodule(&clone_data))
3086 return -1;
3087
3088 prepare_submodule_repo_env(&cp.env);
3089 cp.git_cmd = 1;
3090 cp.dir = add_data->sm_path;
3091 /*
3092 * NOTE: we only get here if add_data->force is true, so
3093 * passing --force to checkout is reasonable.
3094 */
3095 strvec_pushl(&cp.args, "checkout", "-f", "-q", NULL);
3096
3097 if (add_data->branch) {
3098 strvec_pushl(&cp.args, "-B", add_data->branch, NULL);
3099 strvec_pushf(&cp.args, "origin/%s", add_data->branch);
3100 }
3101
3102 if (run_command(&cp))
3103 die(_("unable to checkout submodule '%s'"), add_data->sm_path);
3104 }
3105 return 0;
3106 }
3107
3108 static int config_submodule_in_gitmodules(const char *name, const char *var, const char *value)
3109 {
3110 char *key;
3111 int ret;
3112
3113 if (!is_writing_gitmodules_ok())
3114 die(_("please make sure that the .gitmodules file is in the working tree"));
3115
3116 key = xstrfmt("submodule.%s.%s", name, var);
3117 ret = config_set_in_gitmodules_file_gently(key, value);
3118 free(key);
3119
3120 return ret;
3121 }
3122
3123 static void configure_added_submodule(struct add_data *add_data)
3124 {
3125 char *key;
3126 char *val = NULL;
3127 struct child_process add_submod = CHILD_PROCESS_INIT;
3128 struct child_process add_gitmodules = CHILD_PROCESS_INIT;
3129
3130 key = xstrfmt("submodule.%s.url", add_data->sm_name);
3131 git_config_set_gently(key, add_data->realrepo);
3132 free(key);
3133
3134 add_submod.git_cmd = 1;
3135 strvec_pushl(&add_submod.args, "add",
3136 "--no-warn-embedded-repo", NULL);
3137 if (add_data->force)
3138 strvec_push(&add_submod.args, "--force");
3139 strvec_pushl(&add_submod.args, "--", add_data->sm_path, NULL);
3140
3141 if (run_command(&add_submod))
3142 die(_("Failed to add submodule '%s'"), add_data->sm_path);
3143
3144 if (config_submodule_in_gitmodules(add_data->sm_name, "path", add_data->sm_path) ||
3145 config_submodule_in_gitmodules(add_data->sm_name, "url", add_data->repo))
3146 die(_("Failed to register submodule '%s'"), add_data->sm_path);
3147
3148 if (add_data->branch) {
3149 if (config_submodule_in_gitmodules(add_data->sm_name,
3150 "branch", add_data->branch))
3151 die(_("Failed to register submodule '%s'"), add_data->sm_path);
3152 }
3153
3154 add_gitmodules.git_cmd = 1;
3155 strvec_pushl(&add_gitmodules.args,
3156 "add", "--force", "--", ".gitmodules", NULL);
3157
3158 if (run_command(&add_gitmodules))
3159 die(_("Failed to register submodule '%s'"), add_data->sm_path);
3160
3161 /*
3162 * NEEDSWORK: In a multi-working-tree world this needs to be
3163 * set in the per-worktree config.
3164 */
3165 /*
3166 * NEEDSWORK: In the longer run, we need to get rid of this
3167 * pattern of querying "submodule.active" before calling
3168 * is_submodule_active(), since that function needs to find
3169 * out the value of "submodule.active" again anyway.
3170 */
3171 if (!git_config_get_string("submodule.active", &val) && val) {
3172 /*
3173 * If the submodule being added isn't already covered by the
3174 * current configured pathspec, set the submodule's active flag
3175 */
3176 if (!is_submodule_active(the_repository, add_data->sm_path)) {
3177 key = xstrfmt("submodule.%s.active", add_data->sm_name);
3178 git_config_set_gently(key, "true");
3179 free(key);
3180 }
3181 } else {
3182 key = xstrfmt("submodule.%s.active", add_data->sm_name);
3183 git_config_set_gently(key, "true");
3184 free(key);
3185 }
3186 }
3187
3188 static void die_on_index_match(const char *path, int force)
3189 {
3190 struct pathspec ps;
3191 const char *args[] = { path, NULL };
3192 parse_pathspec(&ps, 0, PATHSPEC_PREFER_CWD, NULL, args);
3193
3194 if (read_cache_preload(NULL) < 0)
3195 die(_("index file corrupt"));
3196
3197 if (ps.nr) {
3198 int i;
3199 char *ps_matched = xcalloc(ps.nr, 1);
3200
3201 /* TODO: audit for interaction with sparse-index. */
3202 ensure_full_index(&the_index);
3203
3204 /*
3205 * Since there is only one pathspec, we just need
3206 * need to check ps_matched[0] to know if a cache
3207 * entry matched.
3208 */
3209 for (i = 0; i < active_nr; i++) {
3210 ce_path_match(&the_index, active_cache[i], &ps,
3211 ps_matched);
3212
3213 if (ps_matched[0]) {
3214 if (!force)
3215 die(_("'%s' already exists in the index"),
3216 path);
3217 if (!S_ISGITLINK(active_cache[i]->ce_mode))
3218 die(_("'%s' already exists in the index "
3219 "and is not a submodule"), path);
3220 break;
3221 }
3222 }
3223 free(ps_matched);
3224 }
3225 clear_pathspec(&ps);
3226 }
3227
3228 static void die_on_repo_without_commits(const char *path)
3229 {
3230 struct strbuf sb = STRBUF_INIT;
3231 strbuf_addstr(&sb, path);
3232 if (is_nonbare_repository_dir(&sb)) {
3233 struct object_id oid;
3234 if (resolve_gitlink_ref(path, "HEAD", &oid) < 0)
3235 die(_("'%s' does not have a commit checked out"), path);
3236 }
3237 strbuf_release(&sb);
3238 }
3239
3240 static int module_add(int argc, const char **argv, const char *prefix)
3241 {
3242 int force = 0, quiet = 0, progress = 0, dissociate = 0;
3243 struct add_data add_data = ADD_DATA_INIT;
3244 char *to_free = NULL;
3245
3246 struct option options[] = {
3247 OPT_STRING('b', "branch", &add_data.branch, N_("branch"),
3248 N_("branch of repository to add as submodule")),
3249 OPT__FORCE(&force, N_("allow adding an otherwise ignored submodule path"),
3250 PARSE_OPT_NOCOMPLETE),
3251 OPT__QUIET(&quiet, N_("print only error messages")),
3252 OPT_BOOL(0, "progress", &progress, N_("force cloning progress")),
3253 OPT_STRING(0, "reference", &add_data.reference_path, N_("repository"),
3254 N_("reference repository")),
3255 OPT_BOOL(0, "dissociate", &dissociate, N_("borrow the objects from reference repositories")),
3256 OPT_STRING(0, "name", &add_data.sm_name, N_("name"),
3257 N_("sets the submodule's name to the given string "
3258 "instead of defaulting to its path")),
3259 OPT_INTEGER(0, "depth", &add_data.depth, N_("depth for shallow clones")),
3260 OPT_END()
3261 };
3262
3263 const char *const usage[] = {
3264 N_("git submodule add [<options>] [--] <repository> [<path>]"),
3265 NULL
3266 };
3267
3268 argc = parse_options(argc, argv, prefix, options, usage, 0);
3269
3270 if (!is_writing_gitmodules_ok())
3271 die(_("please make sure that the .gitmodules file is in the working tree"));
3272
3273 if (prefix && *prefix &&
3274 add_data.reference_path && !is_absolute_path(add_data.reference_path))
3275 add_data.reference_path = xstrfmt("%s%s", prefix, add_data.reference_path);
3276
3277 if (argc == 0 || argc > 2)
3278 usage_with_options(usage, options);
3279
3280 add_data.repo = argv[0];
3281 if (argc == 1)
3282 add_data.sm_path = git_url_basename(add_data.repo, 0, 0);
3283 else
3284 add_data.sm_path = xstrdup(argv[1]);
3285
3286 if (prefix && *prefix && !is_absolute_path(add_data.sm_path))
3287 add_data.sm_path = xstrfmt("%s%s", prefix, add_data.sm_path);
3288
3289 if (starts_with_dot_dot_slash(add_data.repo) ||
3290 starts_with_dot_slash(add_data.repo)) {
3291 if (prefix)
3292 die(_("Relative path can only be used from the toplevel "
3293 "of the working tree"));
3294
3295 /* dereference source url relative to parent's url */
3296 to_free = resolve_relative_url(add_data.repo, NULL, 1);
3297 add_data.realrepo = to_free;
3298 } else if (is_dir_sep(add_data.repo[0]) || strchr(add_data.repo, ':')) {
3299 add_data.realrepo = add_data.repo;
3300 } else {
3301 die(_("repo URL: '%s' must be absolute or begin with ./|../"),
3302 add_data.repo);
3303 }
3304
3305 /*
3306 * normalize path:
3307 * multiple //; leading ./; /./; /../;
3308 */
3309 normalize_path_copy(add_data.sm_path, add_data.sm_path);
3310 strip_dir_trailing_slashes(add_data.sm_path);
3311
3312 die_on_index_match(add_data.sm_path, force);
3313 die_on_repo_without_commits(add_data.sm_path);
3314
3315 if (!force) {
3316 int exit_code = -1;
3317 struct strbuf sb = STRBUF_INIT;
3318 struct child_process cp = CHILD_PROCESS_INIT;
3319 cp.git_cmd = 1;
3320 cp.no_stdout = 1;
3321 strvec_pushl(&cp.args, "add", "--dry-run", "--ignore-missing",
3322 "--no-warn-embedded-repo", add_data.sm_path, NULL);
3323 if ((exit_code = pipe_command(&cp, NULL, 0, NULL, 0, &sb, 0))) {
3324 strbuf_complete_line(&sb);
3325 fputs(sb.buf, stderr);
3326 free(add_data.sm_path);
3327 return exit_code;
3328 }
3329 strbuf_release(&sb);
3330 }
3331
3332 if(!add_data.sm_name)
3333 add_data.sm_name = add_data.sm_path;
3334
3335 if (check_submodule_name(add_data.sm_name))
3336 die(_("'%s' is not a valid submodule name"), add_data.sm_name);
3337
3338 add_data.prefix = prefix;
3339 add_data.force = !!force;
3340 add_data.quiet = !!quiet;
3341 add_data.progress = !!progress;
3342 add_data.dissociate = !!dissociate;
3343
3344 if (add_submodule(&add_data)) {
3345 free(add_data.sm_path);
3346 return 1;
3347 }
3348 configure_added_submodule(&add_data);
3349 free(add_data.sm_path);
3350 free(to_free);
3351
3352 return 0;
3353 }
3354
3355 #define SUPPORT_SUPER_PREFIX (1<<0)
3356
3357 struct cmd_struct {
3358 const char *cmd;
3359 int (*fn)(int, const char **, const char *);
3360 unsigned option;
3361 };
3362
3363 static struct cmd_struct commands[] = {
3364 {"list", module_list, 0},
3365 {"name", module_name, 0},
3366 {"clone", module_clone, SUPPORT_SUPER_PREFIX},
3367 {"add", module_add, 0},
3368 {"update", module_update, SUPPORT_SUPER_PREFIX},
3369 {"resolve-relative-url-test", resolve_relative_url_test, 0},
3370 {"foreach", module_foreach, SUPPORT_SUPER_PREFIX},
3371 {"init", module_init, 0},
3372 {"status", module_status, SUPPORT_SUPER_PREFIX},
3373 {"sync", module_sync, SUPPORT_SUPER_PREFIX},
3374 {"deinit", module_deinit, 0},
3375 {"summary", module_summary, 0},
3376 {"push-check", push_check, 0},
3377 {"absorbgitdirs", absorb_git_dirs, SUPPORT_SUPER_PREFIX},
3378 {"is-active", is_active, 0},
3379 {"check-name", check_name, 0},
3380 {"config", module_config, 0},
3381 {"set-url", module_set_url, 0},
3382 {"set-branch", module_set_branch, 0},
3383 {"create-branch", module_create_branch, 0},
3384 };
3385
3386 int cmd_submodule__helper(int argc, const char **argv, const char *prefix)
3387 {
3388 int i;
3389 if (argc < 2 || !strcmp(argv[1], "-h"))
3390 usage("git submodule--helper <command>");
3391
3392 for (i = 0; i < ARRAY_SIZE(commands); i++) {
3393 if (!strcmp(argv[1], commands[i].cmd)) {
3394 if (get_super_prefix() &&
3395 !(commands[i].option & SUPPORT_SUPER_PREFIX))
3396 die(_("%s doesn't support --super-prefix"),
3397 commands[i].cmd);
3398 return commands[i].fn(argc - 1, argv + 1, prefix);
3399 }
3400 }
3401
3402 die(_("'%s' is not a valid submodule--helper "
3403 "subcommand"), argv[1]);
3404 }
git for Debian