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