3 #include "repository.h"
5 #include "submodule-config.h"
8 #include "object-store.h"
9 #include "parse-options.h"
12 * submodule cache lookup structure
13 * There is one shared set of 'struct submodule' entries which can be
14 * looked up by their sha1 blob id of the .gitmodules file and either
15 * using path or name as key.
16 * for_path stores submodule entries with path as key
17 * for_name stores submodule entries with name as key
19 struct submodule_cache {
20 struct hashmap for_path;
21 struct hashmap for_name;
22 unsigned initialized:1;
23 unsigned gitmodules_read:1;
27 * thin wrapper struct needed to insert 'struct submodule' entries to
30 struct submodule_entry {
31 struct hashmap_entry ent;
32 struct submodule *config;
40 static int config_path_cmp(const void *unused_cmp_data,
41 const struct hashmap_entry *eptr,
42 const struct hashmap_entry *entry_or_key,
43 const void *unused_keydata)
45 const struct submodule_entry *a, *b;
47 a = container_of(eptr, const struct submodule_entry, ent);
48 b = container_of(entry_or_key, const struct submodule_entry, ent);
50 return strcmp(a->config->path, b->config->path) ||
51 !oideq(&a->config->gitmodules_oid, &b->config->gitmodules_oid);
54 static int config_name_cmp(const void *unused_cmp_data,
55 const struct hashmap_entry *eptr,
56 const struct hashmap_entry *entry_or_key,
57 const void *unused_keydata)
59 const struct submodule_entry *a, *b;
61 a = container_of(eptr, const struct submodule_entry, ent);
62 b = container_of(entry_or_key, const struct submodule_entry, ent);
64 return strcmp(a->config->name, b->config->name) ||
65 !oideq(&a->config->gitmodules_oid, &b->config->gitmodules_oid);
68 static struct submodule_cache *submodule_cache_alloc(void)
70 return xcalloc(1, sizeof(struct submodule_cache));
73 static void submodule_cache_init(struct submodule_cache *cache)
75 hashmap_init(&cache->for_path, config_path_cmp, NULL, 0);
76 hashmap_init(&cache->for_name, config_name_cmp, NULL, 0);
77 cache->initialized = 1;
80 static void free_one_config(struct submodule_entry *entry)
82 free((void *) entry->config->path);
83 free((void *) entry->config->name);
84 free((void *) entry->config->branch);
85 free((void *) entry->config->update_strategy.command);
89 static void submodule_cache_clear(struct submodule_cache *cache)
91 struct hashmap_iter iter;
92 struct submodule_entry *entry;
94 if (!cache->initialized)
98 * We iterate over the name hash here to be symmetric with the
99 * allocation of struct submodule entries. Each is allocated by
100 * their .gitmodules blob sha1 and submodule name.
102 hashmap_for_each_entry(&cache->for_name, &iter, entry,
103 ent /* member name */)
104 free_one_config(entry);
106 hashmap_clear_and_free(&cache->for_path, struct submodule_entry, ent);
107 hashmap_clear_and_free(&cache->for_name, struct submodule_entry, ent);
108 cache->initialized = 0;
109 cache->gitmodules_read = 0;
112 void submodule_cache_free(struct submodule_cache *cache)
114 submodule_cache_clear(cache);
118 static unsigned int hash_oid_string(const struct object_id *oid,
121 return memhash(oid->hash, the_hash_algo->rawsz) + strhash(string);
124 static void cache_put_path(struct submodule_cache *cache,
125 struct submodule *submodule)
127 unsigned int hash = hash_oid_string(&submodule->gitmodules_oid,
129 struct submodule_entry *e = xmalloc(sizeof(*e));
130 hashmap_entry_init(&e->ent, hash);
131 e->config = submodule;
132 hashmap_put(&cache->for_path, &e->ent);
135 static void cache_remove_path(struct submodule_cache *cache,
136 struct submodule *submodule)
138 unsigned int hash = hash_oid_string(&submodule->gitmodules_oid,
140 struct submodule_entry e;
141 struct submodule_entry *removed;
142 hashmap_entry_init(&e.ent, hash);
143 e.config = submodule;
144 removed = hashmap_remove_entry(&cache->for_path, &e, ent, NULL);
148 static void cache_add(struct submodule_cache *cache,
149 struct submodule *submodule)
151 unsigned int hash = hash_oid_string(&submodule->gitmodules_oid,
153 struct submodule_entry *e = xmalloc(sizeof(*e));
154 hashmap_entry_init(&e->ent, hash);
155 e->config = submodule;
156 hashmap_add(&cache->for_name, &e->ent);
159 static const struct submodule *cache_lookup_path(struct submodule_cache *cache,
160 const struct object_id *gitmodules_oid, const char *path)
162 struct submodule_entry *entry;
163 unsigned int hash = hash_oid_string(gitmodules_oid, path);
164 struct submodule_entry key;
165 struct submodule key_config;
167 oidcpy(&key_config.gitmodules_oid, gitmodules_oid);
168 key_config.path = path;
170 hashmap_entry_init(&key.ent, hash);
171 key.config = &key_config;
173 entry = hashmap_get_entry(&cache->for_path, &key, ent, NULL);
175 return entry->config;
179 static struct submodule *cache_lookup_name(struct submodule_cache *cache,
180 const struct object_id *gitmodules_oid, const char *name)
182 struct submodule_entry *entry;
183 unsigned int hash = hash_oid_string(gitmodules_oid, name);
184 struct submodule_entry key;
185 struct submodule key_config;
187 oidcpy(&key_config.gitmodules_oid, gitmodules_oid);
188 key_config.name = name;
190 hashmap_entry_init(&key.ent, hash);
191 key.config = &key_config;
193 entry = hashmap_get_entry(&cache->for_name, &key, ent, NULL);
195 return entry->config;
199 int check_submodule_name(const char *name)
201 /* Disallow empty names */
206 * Look for '..' as a path component. Check both '/' and '\\' as
207 * separators rather than is_dir_sep(), because we want the name rules
208 * to be consistent across platforms.
210 goto in_component; /* always start inside component */
213 if (c == '/' || c == '\\') {
215 if (name[0] == '.' && name[1] == '.' &&
216 (!name[2] || name[2] == '/' || name[2] == '\\'))
224 static int name_and_item_from_var(const char *var, struct strbuf *name,
227 const char *subsection, *key;
228 size_t subsection_len;
230 parse = parse_config_key(var, "submodule", &subsection,
231 &subsection_len, &key);
232 if (parse < 0 || !subsection)
235 strbuf_add(name, subsection, subsection_len);
236 if (check_submodule_name(name->buf) < 0) {
237 warning(_("ignoring suspicious submodule name: %s"), name->buf);
238 strbuf_release(name);
242 strbuf_addstr(item, key);
247 static struct submodule *lookup_or_create_by_name(struct submodule_cache *cache,
248 const struct object_id *gitmodules_oid, const char *name)
250 struct submodule *submodule;
251 struct strbuf name_buf = STRBUF_INIT;
253 submodule = cache_lookup_name(cache, gitmodules_oid, name);
257 submodule = xmalloc(sizeof(*submodule));
259 strbuf_addstr(&name_buf, name);
260 submodule->name = strbuf_detach(&name_buf, NULL);
262 submodule->path = NULL;
263 submodule->url = NULL;
264 submodule->update_strategy.type = SM_UPDATE_UNSPECIFIED;
265 submodule->update_strategy.command = NULL;
266 submodule->fetch_recurse = RECURSE_SUBMODULES_NONE;
267 submodule->ignore = NULL;
268 submodule->branch = NULL;
269 submodule->recommend_shallow = -1;
271 oidcpy(&submodule->gitmodules_oid, gitmodules_oid);
273 cache_add(cache, submodule);
278 static int parse_fetch_recurse(const char *opt, const char *arg,
281 switch (git_parse_maybe_bool(arg)) {
283 return RECURSE_SUBMODULES_ON;
285 return RECURSE_SUBMODULES_OFF;
287 if (!strcmp(arg, "on-demand"))
288 return RECURSE_SUBMODULES_ON_DEMAND;
290 * Please update $__git_fetch_recurse_submodules in
291 * git-completion.bash when you add new options.
294 die("bad %s argument: %s", opt, arg);
296 return RECURSE_SUBMODULES_ERROR;
300 int parse_submodule_fetchjobs(const char *var, const char *value)
302 int fetchjobs = git_config_int(var, value);
304 die(_("negative values not allowed for submodule.fetchjobs"));
308 int parse_fetch_recurse_submodules_arg(const char *opt, const char *arg)
310 return parse_fetch_recurse(opt, arg, 1);
313 int option_fetch_parse_recurse_submodules(const struct option *opt,
314 const char *arg, int unset)
324 *v = RECURSE_SUBMODULES_OFF;
327 *v = parse_fetch_recurse_submodules_arg(opt->long_name, arg);
329 *v = RECURSE_SUBMODULES_ON;
334 static int parse_update_recurse(const char *opt, const char *arg,
337 switch (git_parse_maybe_bool(arg)) {
339 return RECURSE_SUBMODULES_ON;
341 return RECURSE_SUBMODULES_OFF;
344 die("bad %s argument: %s", opt, arg);
345 return RECURSE_SUBMODULES_ERROR;
349 int parse_update_recurse_submodules_arg(const char *opt, const char *arg)
351 return parse_update_recurse(opt, arg, 1);
354 static int parse_push_recurse(const char *opt, const char *arg,
357 switch (git_parse_maybe_bool(arg)) {
359 /* There's no simple "on" value when pushing */
361 die("bad %s argument: %s", opt, arg);
363 return RECURSE_SUBMODULES_ERROR;
365 return RECURSE_SUBMODULES_OFF;
367 if (!strcmp(arg, "on-demand"))
368 return RECURSE_SUBMODULES_ON_DEMAND;
369 else if (!strcmp(arg, "check"))
370 return RECURSE_SUBMODULES_CHECK;
371 else if (!strcmp(arg, "only"))
372 return RECURSE_SUBMODULES_ONLY;
374 * Please update $__git_push_recurse_submodules in
375 * git-completion.bash when you add new modes.
377 else if (die_on_error)
378 die("bad %s argument: %s", opt, arg);
380 return RECURSE_SUBMODULES_ERROR;
384 int parse_push_recurse_submodules_arg(const char *opt, const char *arg)
386 return parse_push_recurse(opt, arg, 1);
389 static void warn_multiple_config(const struct object_id *treeish_name,
390 const char *name, const char *option)
392 const char *commit_string = "WORKTREE";
394 commit_string = oid_to_hex(treeish_name);
395 warning("%s:.gitmodules, multiple configurations found for "
396 "'submodule.%s.%s'. Skipping second one!",
397 commit_string, name, option);
400 static void warn_command_line_option(const char *var, const char *value)
402 warning(_("ignoring '%s' which may be interpreted as"
403 " a command-line option: %s"), var, value);
406 struct parse_config_parameter {
407 struct submodule_cache *cache;
408 const struct object_id *treeish_name;
409 const struct object_id *gitmodules_oid;
414 * Parse a config item from .gitmodules.
416 * This does not handle submodule-related configuration from the main
417 * config store (.git/config, etc). Callers are responsible for
418 * checking for overrides in the main config store when appropriate.
420 static int parse_config(const char *var, const char *value, void *data)
422 struct parse_config_parameter *me = data;
423 struct submodule *submodule;
424 struct strbuf name = STRBUF_INIT, item = STRBUF_INIT;
427 /* this also ensures that we only parse submodule entries */
428 if (!name_and_item_from_var(var, &name, &item))
431 submodule = lookup_or_create_by_name(me->cache,
435 if (!strcmp(item.buf, "path")) {
437 ret = config_error_nonbool(var);
438 else if (looks_like_command_line_option(value))
439 warn_command_line_option(var, value);
440 else if (!me->overwrite && submodule->path)
441 warn_multiple_config(me->treeish_name, submodule->name,
445 cache_remove_path(me->cache, submodule);
446 free((void *) submodule->path);
447 submodule->path = xstrdup(value);
448 cache_put_path(me->cache, submodule);
450 } else if (!strcmp(item.buf, "fetchrecursesubmodules")) {
451 /* when parsing worktree configurations we can die early */
452 int die_on_error = is_null_oid(me->gitmodules_oid);
453 if (!me->overwrite &&
454 submodule->fetch_recurse != RECURSE_SUBMODULES_NONE)
455 warn_multiple_config(me->treeish_name, submodule->name,
456 "fetchrecursesubmodules");
458 submodule->fetch_recurse = parse_fetch_recurse(
461 } else if (!strcmp(item.buf, "ignore")) {
463 ret = config_error_nonbool(var);
464 else if (!me->overwrite && submodule->ignore)
465 warn_multiple_config(me->treeish_name, submodule->name,
467 else if (strcmp(value, "untracked") &&
468 strcmp(value, "dirty") &&
469 strcmp(value, "all") &&
470 strcmp(value, "none"))
471 warning("Invalid parameter '%s' for config option "
472 "'submodule.%s.ignore'", value, name.buf);
474 free((void *) submodule->ignore);
475 submodule->ignore = xstrdup(value);
477 } else if (!strcmp(item.buf, "url")) {
479 ret = config_error_nonbool(var);
480 } else if (looks_like_command_line_option(value)) {
481 warn_command_line_option(var, value);
482 } else if (!me->overwrite && submodule->url) {
483 warn_multiple_config(me->treeish_name, submodule->name,
486 free((void *) submodule->url);
487 submodule->url = xstrdup(value);
489 } else if (!strcmp(item.buf, "update")) {
491 ret = config_error_nonbool(var);
492 else if (!me->overwrite &&
493 submodule->update_strategy.type != SM_UPDATE_UNSPECIFIED)
494 warn_multiple_config(me->treeish_name, submodule->name,
496 else if (parse_submodule_update_strategy(value,
497 &submodule->update_strategy) < 0 ||
498 submodule->update_strategy.type == SM_UPDATE_COMMAND)
499 die(_("invalid value for %s"), var);
500 } else if (!strcmp(item.buf, "shallow")) {
501 if (!me->overwrite && submodule->recommend_shallow != -1)
502 warn_multiple_config(me->treeish_name, submodule->name,
505 submodule->recommend_shallow =
506 git_config_bool(var, value);
507 } else if (!strcmp(item.buf, "branch")) {
508 if (!me->overwrite && submodule->branch)
509 warn_multiple_config(me->treeish_name, submodule->name,
512 free((void *)submodule->branch);
513 submodule->branch = xstrdup(value);
517 strbuf_release(&name);
518 strbuf_release(&item);
523 static int gitmodule_oid_from_commit(const struct object_id *treeish_name,
524 struct object_id *gitmodules_oid,
529 if (is_null_oid(treeish_name)) {
530 oidclr(gitmodules_oid);
534 strbuf_addf(rev, "%s:.gitmodules", oid_to_hex(treeish_name));
535 if (get_oid(rev->buf, gitmodules_oid) >= 0)
541 /* This does a lookup of a submodule configuration by name or by path
542 * (key) with on-demand reading of the appropriate .gitmodules from
545 static const struct submodule *config_from(struct submodule_cache *cache,
546 const struct object_id *treeish_name, const char *key,
547 enum lookup_type lookup_type)
549 struct strbuf rev = STRBUF_INIT;
550 unsigned long config_size;
552 struct object_id oid;
553 enum object_type type;
554 const struct submodule *submodule = NULL;
555 struct parse_config_parameter parameter;
558 * If any parameter except the cache is a NULL pointer just
559 * return the first submodule. Can be used to check whether
560 * there are any submodules parsed.
562 if (!treeish_name || !key) {
563 struct hashmap_iter iter;
564 struct submodule_entry *entry;
566 entry = hashmap_iter_first_entry(&cache->for_name, &iter,
567 struct submodule_entry,
568 ent /* member name */);
571 return entry->config;
574 if (!gitmodule_oid_from_commit(treeish_name, &oid, &rev))
577 switch (lookup_type) {
579 submodule = cache_lookup_name(cache, &oid, key);
582 submodule = cache_lookup_path(cache, &oid, key);
588 config = read_object_file(&oid, &type, &config_size);
589 if (!config || type != OBJ_BLOB)
592 /* fill the submodule config into the cache */
593 parameter.cache = cache;
594 parameter.treeish_name = treeish_name;
595 parameter.gitmodules_oid = &oid;
596 parameter.overwrite = 0;
597 git_config_from_mem(parse_config, CONFIG_ORIGIN_SUBMODULE_BLOB, rev.buf,
598 config, config_size, ¶meter, NULL);
599 strbuf_release(&rev);
602 switch (lookup_type) {
604 return cache_lookup_name(cache, &oid, key);
606 return cache_lookup_path(cache, &oid, key);
612 strbuf_release(&rev);
617 static void submodule_cache_check_init(struct repository *repo)
619 if (repo->submodule_cache && repo->submodule_cache->initialized)
622 if (!repo->submodule_cache)
623 repo->submodule_cache = submodule_cache_alloc();
625 submodule_cache_init(repo->submodule_cache);
629 * Note: This function is private for a reason, the '.gitmodules' file should
630 * not be used as a mechanism to retrieve arbitrary configuration stored in
633 * Runs the provided config function on the '.gitmodules' file found in the
636 static void config_from_gitmodules(config_fn_t fn, struct repository *repo, void *data)
638 if (repo->worktree) {
639 struct git_config_source config_source = {
640 0, .scope = CONFIG_SCOPE_SUBMODULE
642 const struct config_options opts = { 0 };
643 struct object_id oid;
647 file = repo_worktree_path(repo, GITMODULES_FILE);
648 if (file_exists(file)) {
649 config_source.file = file;
650 } else if (repo_get_oid(repo, GITMODULES_INDEX, &oid) >= 0 ||
651 repo_get_oid(repo, GITMODULES_HEAD, &oid) >= 0) {
652 config_source.blob = oidstr = xstrdup(oid_to_hex(&oid));
653 if (repo != the_repository)
654 add_to_alternates_memory(repo->objects->odb->path);
659 config_with_options(fn, data, &config_source, &opts);
667 static int gitmodules_cb(const char *var, const char *value, void *data)
669 struct repository *repo = data;
670 struct parse_config_parameter parameter;
672 parameter.cache = repo->submodule_cache;
673 parameter.treeish_name = NULL;
674 parameter.gitmodules_oid = &null_oid;
675 parameter.overwrite = 1;
677 return parse_config(var, value, ¶meter);
680 void repo_read_gitmodules(struct repository *repo, int skip_if_read)
682 submodule_cache_check_init(repo);
684 if (repo->submodule_cache->gitmodules_read && skip_if_read)
687 if (repo_read_index(repo) < 0)
690 if (!is_gitmodules_unmerged(repo->index))
691 config_from_gitmodules(gitmodules_cb, repo, repo);
693 repo->submodule_cache->gitmodules_read = 1;
696 void gitmodules_config_oid(const struct object_id *commit_oid)
698 struct strbuf rev = STRBUF_INIT;
699 struct object_id oid;
701 submodule_cache_check_init(the_repository);
703 if (gitmodule_oid_from_commit(commit_oid, &oid, &rev)) {
704 git_config_from_blob_oid(gitmodules_cb, rev.buf,
705 &oid, the_repository);
707 strbuf_release(&rev);
709 the_repository->submodule_cache->gitmodules_read = 1;
712 const struct submodule *submodule_from_name(struct repository *r,
713 const struct object_id *treeish_name,
716 repo_read_gitmodules(r, 1);
717 return config_from(r->submodule_cache, treeish_name, name, lookup_name);
720 const struct submodule *submodule_from_path(struct repository *r,
721 const struct object_id *treeish_name,
724 repo_read_gitmodules(r, 1);
725 return config_from(r->submodule_cache, treeish_name, path, lookup_path);
728 void submodule_free(struct repository *r)
730 if (r->submodule_cache)
731 submodule_cache_clear(r->submodule_cache);
734 static int config_print_callback(const char *var, const char *value, void *cb_data)
736 char *wanted_key = cb_data;
738 if (!strcmp(wanted_key, var))
739 printf("%s\n", value);
744 int print_config_from_gitmodules(struct repository *repo, const char *key)
749 ret = git_config_parse_key(key, &store_key, NULL);
751 return CONFIG_INVALID_KEY;
753 config_from_gitmodules(config_print_callback, repo, store_key);
759 int config_set_in_gitmodules_file_gently(const char *key, const char *value)
763 ret = git_config_set_in_file_gently(GITMODULES_FILE, key, value);
765 /* Maybe the user already did that, don't error out here */
766 warning(_("Could not update .gitmodules entry %s"), key);
771 struct fetch_config {
773 int *recurse_submodules;
776 static int gitmodules_fetch_config(const char *var, const char *value, void *cb)
778 struct fetch_config *config = cb;
779 if (!strcmp(var, "submodule.fetchjobs")) {
780 if (config->max_children)
781 *(config->max_children) =
782 parse_submodule_fetchjobs(var, value);
784 } else if (!strcmp(var, "fetch.recursesubmodules")) {
785 if (config->recurse_submodules)
786 *(config->recurse_submodules) =
787 parse_fetch_recurse_submodules_arg(var, value);
794 void fetch_config_from_gitmodules(int *max_children, int *recurse_submodules)
796 struct fetch_config config = {
797 .max_children = max_children,
798 .recurse_submodules = recurse_submodules
800 config_from_gitmodules(gitmodules_fetch_config, the_repository, &config);
803 static int gitmodules_update_clone_config(const char *var, const char *value,
807 if (!strcmp(var, "submodule.fetchjobs"))
808 *max_jobs = parse_submodule_fetchjobs(var, value);
812 void update_clone_config_from_gitmodules(int *max_jobs)
814 config_from_gitmodules(gitmodules_update_clone_config, the_repository, &max_jobs);