Start the post 2.27 cycle
[git.git] / submodule-config.c
blobe175dfbc388ab50a55429bfff287541bb2a48530
1 #include "cache.h"
2 #include "dir.h"
3 #include "repository.h"
4 #include "config.h"
5 #include "submodule-config.h"
6 #include "submodule.h"
7 #include "strbuf.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
28 * the hashmap
30 struct submodule_entry {
31 struct hashmap_entry ent;
32 struct submodule *config;
35 enum lookup_type {
36 lookup_name,
37 lookup_path
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);
86 free(entry->config);
89 static void submodule_cache_clear(struct submodule_cache *cache)
91 struct hashmap_iter iter;
92 struct submodule_entry *entry;
94 if (!cache->initialized)
95 return;
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_free_entries(&cache->for_path, struct submodule_entry, ent);
107 hashmap_free_entries(&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);
115 free(cache);
118 static unsigned int hash_oid_string(const struct object_id *oid,
119 const char *string)
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,
128 submodule->path);
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,
139 submodule->path);
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);
145 free(removed);
148 static void cache_add(struct submodule_cache *cache,
149 struct submodule *submodule)
151 unsigned int hash = hash_oid_string(&submodule->gitmodules_oid,
152 submodule->name);
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);
174 if (entry)
175 return entry->config;
176 return NULL;
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);
194 if (entry)
195 return entry->config;
196 return NULL;
199 int check_submodule_name(const char *name)
201 /* Disallow empty names */
202 if (!*name)
203 return -1;
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 */
211 while (*name) {
212 char c = *name++;
213 if (c == '/' || c == '\\') {
214 in_component:
215 if (name[0] == '.' && name[1] == '.' &&
216 (!name[2] || name[2] == '/' || name[2] == '\\'))
217 return -1;
221 return 0;
224 static int name_and_item_from_var(const char *var, struct strbuf *name,
225 struct strbuf *item)
227 const char *subsection, *key;
228 size_t subsection_len;
229 int parse;
230 parse = parse_config_key(var, "submodule", &subsection,
231 &subsection_len, &key);
232 if (parse < 0 || !subsection)
233 return 0;
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);
239 return 0;
242 strbuf_addstr(item, key);
244 return 1;
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);
254 if (submodule)
255 return submodule;
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);
275 return submodule;
278 static int parse_fetch_recurse(const char *opt, const char *arg,
279 int die_on_error)
281 switch (git_parse_maybe_bool(arg)) {
282 case 1:
283 return RECURSE_SUBMODULES_ON;
284 case 0:
285 return RECURSE_SUBMODULES_OFF;
286 default:
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.
293 if (die_on_error)
294 die("bad %s argument: %s", opt, arg);
295 else
296 return RECURSE_SUBMODULES_ERROR;
300 int parse_submodule_fetchjobs(const char *var, const char *value)
302 int fetchjobs = git_config_int(var, value);
303 if (fetchjobs < 0)
304 die(_("negative values not allowed for submodule.fetchjobs"));
305 return 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)
316 int *v;
318 if (!opt->value)
319 return -1;
321 v = opt->value;
323 if (unset) {
324 *v = RECURSE_SUBMODULES_OFF;
325 } else {
326 if (arg)
327 *v = parse_fetch_recurse_submodules_arg(opt->long_name, arg);
328 else
329 *v = RECURSE_SUBMODULES_ON;
331 return 0;
334 static int parse_update_recurse(const char *opt, const char *arg,
335 int die_on_error)
337 switch (git_parse_maybe_bool(arg)) {
338 case 1:
339 return RECURSE_SUBMODULES_ON;
340 case 0:
341 return RECURSE_SUBMODULES_OFF;
342 default:
343 if (die_on_error)
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,
355 int die_on_error)
357 switch (git_parse_maybe_bool(arg)) {
358 case 1:
359 /* There's no simple "on" value when pushing */
360 if (die_on_error)
361 die("bad %s argument: %s", opt, arg);
362 else
363 return RECURSE_SUBMODULES_ERROR;
364 case 0:
365 return RECURSE_SUBMODULES_OFF;
366 default:
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);
379 else
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";
393 if (treeish_name)
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;
410 int overwrite;
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;
425 int ret = 0;
427 /* this also ensures that we only parse submodule entries */
428 if (!name_and_item_from_var(var, &name, &item))
429 return 0;
431 submodule = lookup_or_create_by_name(me->cache,
432 me->gitmodules_oid,
433 name.buf);
435 if (!strcmp(item.buf, "path")) {
436 if (!value)
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,
442 "path");
443 else {
444 if (submodule->path)
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");
457 else
458 submodule->fetch_recurse = parse_fetch_recurse(
459 var, value,
460 die_on_error);
461 } else if (!strcmp(item.buf, "ignore")) {
462 if (!value)
463 ret = config_error_nonbool(var);
464 else if (!me->overwrite && submodule->ignore)
465 warn_multiple_config(me->treeish_name, submodule->name,
466 "ignore");
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);
473 else {
474 free((void *) submodule->ignore);
475 submodule->ignore = xstrdup(value);
477 } else if (!strcmp(item.buf, "url")) {
478 if (!value) {
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,
484 "url");
485 } else {
486 free((void *) submodule->url);
487 submodule->url = xstrdup(value);
489 } else if (!strcmp(item.buf, "update")) {
490 if (!value)
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,
495 "update");
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,
503 "shallow");
504 else
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,
510 "branch");
511 else {
512 free((void *)submodule->branch);
513 submodule->branch = xstrdup(value);
517 strbuf_release(&name);
518 strbuf_release(&item);
520 return ret;
523 static int gitmodule_oid_from_commit(const struct object_id *treeish_name,
524 struct object_id *gitmodules_oid,
525 struct strbuf *rev)
527 int ret = 0;
529 if (is_null_oid(treeish_name)) {
530 oidclr(gitmodules_oid);
531 return 1;
534 strbuf_addf(rev, "%s:.gitmodules", oid_to_hex(treeish_name));
535 if (get_oid(rev->buf, gitmodules_oid) >= 0)
536 ret = 1;
538 return ret;
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
543 * revisions.
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;
551 char *config = NULL;
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 */);
569 if (!entry)
570 return NULL;
571 return entry->config;
574 if (!gitmodule_oid_from_commit(treeish_name, &oid, &rev))
575 goto out;
577 switch (lookup_type) {
578 case lookup_name:
579 submodule = cache_lookup_name(cache, &oid, key);
580 break;
581 case lookup_path:
582 submodule = cache_lookup_path(cache, &oid, key);
583 break;
585 if (submodule)
586 goto out;
588 config = read_object_file(&oid, &type, &config_size);
589 if (!config || type != OBJ_BLOB)
590 goto out;
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, &parameter, NULL);
599 strbuf_release(&rev);
600 free(config);
602 switch (lookup_type) {
603 case lookup_name:
604 return cache_lookup_name(cache, &oid, key);
605 case lookup_path:
606 return cache_lookup_path(cache, &oid, key);
607 default:
608 return NULL;
611 out:
612 strbuf_release(&rev);
613 free(config);
614 return submodule;
617 static void submodule_cache_check_init(struct repository *repo)
619 if (repo->submodule_cache && repo->submodule_cache->initialized)
620 return;
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
631 * the repository.
633 * Runs the provided config function on the '.gitmodules' file found in the
634 * working directory.
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;
644 char *file;
645 char *oidstr = NULL;
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);
655 } else {
656 goto out;
659 config_with_options(fn, data, &config_source, &opts);
661 out:
662 free(oidstr);
663 free(file);
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, &parameter);
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)
685 return;
687 if (repo_read_index(repo) < 0)
688 return;
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,
714 const char *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,
722 const char *path)
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);
741 return 0;
744 int print_config_from_gitmodules(struct repository *repo, const char *key)
746 int ret;
747 char *store_key;
749 ret = git_config_parse_key(key, &store_key, NULL);
750 if (ret < 0)
751 return CONFIG_INVALID_KEY;
753 config_from_gitmodules(config_print_callback, repo, store_key);
755 free(store_key);
756 return 0;
759 int config_set_in_gitmodules_file_gently(const char *key, const char *value)
761 int ret;
763 ret = git_config_set_in_file_gently(GITMODULES_FILE, key, value);
764 if (ret < 0)
765 /* Maybe the user already did that, don't error out here */
766 warning(_("Could not update .gitmodules entry %s"), key);
768 return ret;
771 struct fetch_config {
772 int *max_children;
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 *(config->max_children) = parse_submodule_fetchjobs(var, value);
781 return 0;
782 } else if (!strcmp(var, "fetch.recursesubmodules")) {
783 *(config->recurse_submodules) = parse_fetch_recurse_submodules_arg(var, value);
784 return 0;
787 return 0;
790 void fetch_config_from_gitmodules(int *max_children, int *recurse_submodules)
792 struct fetch_config config = {
793 .max_children = max_children,
794 .recurse_submodules = recurse_submodules
796 config_from_gitmodules(gitmodules_fetch_config, the_repository, &config);
799 static int gitmodules_update_clone_config(const char *var, const char *value,
800 void *cb)
802 int *max_jobs = cb;
803 if (!strcmp(var, "submodule.fetchjobs"))
804 *max_jobs = parse_submodule_fetchjobs(var, value);
805 return 0;
808 void update_clone_config_from_gitmodules(int *max_jobs)
810 config_from_gitmodules(gitmodules_update_clone_config, the_repository, &max_jobs);