2015-08-18 03:21:57 +03:00
|
|
|
#ifndef SUBMODULE_CONFIG_CACHE_H
|
|
|
|
#define SUBMODULE_CONFIG_CACHE_H
|
|
|
|
|
|
|
|
#include "hashmap.h"
|
2016-03-01 05:07:11 +03:00
|
|
|
#include "submodule.h"
|
2015-08-18 03:21:57 +03:00
|
|
|
#include "strbuf.h"
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Submodule entry containing the information about a certain submodule
|
|
|
|
* in a certain revision.
|
|
|
|
*/
|
|
|
|
struct submodule {
|
|
|
|
const char *path;
|
|
|
|
const char *name;
|
|
|
|
const char *url;
|
|
|
|
int fetch_recurse;
|
|
|
|
const char *ignore;
|
2016-07-29 03:44:07 +03:00
|
|
|
const char *branch;
|
2016-03-01 05:07:11 +03:00
|
|
|
struct submodule_update_strategy update_strategy;
|
2015-08-18 03:21:57 +03:00
|
|
|
/* the sha1 blob id of the responsible .gitmodules file */
|
|
|
|
unsigned char gitmodules_sha1[20];
|
2016-05-27 00:59:42 +03:00
|
|
|
int recommend_shallow;
|
2015-08-18 03:21:57 +03:00
|
|
|
};
|
|
|
|
|
2017-10-16 16:58:27 +03:00
|
|
|
#define SUBMODULE_INIT { NULL, NULL, NULL, RECURSE_SUBMODULES_NONE, \
|
|
|
|
NULL, NULL, SUBMODULE_UPDATE_STRATEGY_INIT, {0}, -1 };
|
|
|
|
|
2017-06-22 21:43:44 +03:00
|
|
|
struct submodule_cache;
|
|
|
|
struct repository;
|
|
|
|
|
|
|
|
extern void submodule_cache_free(struct submodule_cache *cache);
|
|
|
|
|
2017-08-02 22:49:18 +03:00
|
|
|
extern int parse_submodule_fetchjobs(const char *var, const char *value);
|
2017-03-15 00:46:32 +03:00
|
|
|
extern int parse_fetch_recurse_submodules_arg(const char *opt, const char *arg);
|
2017-06-23 22:13:00 +03:00
|
|
|
struct option;
|
|
|
|
extern int option_fetch_parse_recurse_submodules(const struct option *opt,
|
|
|
|
const char *arg, int unset);
|
2017-03-15 00:46:32 +03:00
|
|
|
extern int parse_update_recurse_submodules_arg(const char *opt, const char *arg);
|
|
|
|
extern int parse_push_recurse_submodules_arg(const char *opt, const char *arg);
|
2017-08-03 21:19:57 +03:00
|
|
|
extern void repo_read_gitmodules(struct repository *repo);
|
|
|
|
extern void gitmodules_config_oid(const struct object_id *commit_oid);
|
2017-03-15 00:46:32 +03:00
|
|
|
extern const struct submodule *submodule_from_name(
|
2017-07-14 02:49:20 +03:00
|
|
|
const struct object_id *commit_or_tree, const char *name);
|
2017-03-15 00:46:32 +03:00
|
|
|
extern const struct submodule *submodule_from_path(
|
2017-07-14 02:49:20 +03:00
|
|
|
const struct object_id *commit_or_tree, const char *path);
|
2017-06-22 21:43:44 +03:00
|
|
|
extern const struct submodule *submodule_from_cache(struct repository *repo,
|
2017-07-14 02:49:20 +03:00
|
|
|
const struct object_id *treeish_name,
|
2017-06-22 21:43:44 +03:00
|
|
|
const char *key);
|
2017-03-15 00:46:32 +03:00
|
|
|
extern void submodule_free(void);
|
2015-08-18 03:21:57 +03:00
|
|
|
|
submodule-config: verify submodule names as paths
Submodule "names" come from the untrusted .gitmodules file,
but we blindly append them to $GIT_DIR/modules to create our
on-disk repo paths. This means you can do bad things by
putting "../" into the name (among other things).
Let's sanity-check these names to avoid building a path that
can be exploited. There are two main decisions:
1. What should the allowed syntax be?
It's tempting to reuse verify_path(), since submodule
names typically come from in-repo paths. But there are
two reasons not to:
a. It's technically more strict than what we need, as
we really care only about breaking out of the
$GIT_DIR/modules/ hierarchy. E.g., having a
submodule named "foo/.git" isn't actually
dangerous, and it's possible that somebody has
manually given such a funny name.
b. Since we'll eventually use this checking logic in
fsck to prevent downstream repositories, it should
be consistent across platforms. Because
verify_path() relies on is_dir_sep(), it wouldn't
block "foo\..\bar" on a non-Windows machine.
2. Where should we enforce it? These days most of the
.gitmodules reads go through submodule-config.c, so
I've put it there in the reading step. That should
cover all of the C code.
We also construct the name for "git submodule add"
inside the git-submodule.sh script. This is probably
not a big deal for security since the name is coming
from the user anyway, but it would be polite to remind
them if the name they pick is invalid (and we need to
expose the name-checker to the shell anyway for our
test scripts).
This patch issues a warning when reading .gitmodules
and just ignores the related config entry completely.
This will generally end up producing a sensible error,
as it works the same as a .gitmodules file which is
missing a submodule entry (so "submodule update" will
barf, but "git clone --recurse-submodules" will print
an error but not abort the clone.
There is one minor oddity, which is that we print the
warning once per malformed config key (since that's how
the config subsystem gives us the entries). So in the
new test, for example, the user would see three
warnings. That's OK, since the intent is that this case
should never come up outside of malicious repositories
(and then it might even benefit the user to see the
message multiple times).
Credit for finding this vulnerability and the proof of
concept from which the test script was adapted goes to
Etienne Stalmans.
Signed-off-by: Jeff King <peff@peff.net>
2018-04-30 10:25:25 +03:00
|
|
|
/*
|
|
|
|
* Returns 0 if the name is syntactically acceptable as a submodule "name"
|
|
|
|
* (e.g., that may be found in the subsection of a .gitmodules file) and -1
|
|
|
|
* otherwise.
|
|
|
|
*/
|
|
|
|
int check_submodule_name(const char *name);
|
|
|
|
|
2015-08-18 03:21:57 +03:00
|
|
|
#endif /* SUBMODULE_CONFIG_H */
|