static gint
hashfs_fuse_open (const gchar *path, struct fuse_file_info *fi)
{
GList *entries, *item;
gint rval = 0;
const gchar *realpath;
hashfs_db_entry_t *entry;
printf("open: %s\n", path);
entries = resolve_paths(path);
if (!entries)
return -ENOENT;
if ((fi->flags & 3) != O_RDONLY)
return -EACCES;
item = g_list_last(entries);
entry = item->data;
if (hashfs_db_entry_lookup(entry, "path", &realpath)) {
fi->fh = open(realpath, fi->flags);
}
free_entry_list(entries);
return 0;
}
std::vector<std::string> get_paths(const std::string& name, bool resolve, size_t* lineno = nullptr) {
std::string paths_str = get_string(name, lineno);
std::vector<std::string> paths;
split_path(paths_str.c_str(), ":", &paths);
std::vector<std::pair<std::string, std::string>> params;
params.push_back({ "LIB", kLibParamValue });
if (target_sdk_version_ != 0) {
char buf[16];
async_safe_format_buffer(buf, sizeof(buf), "%d", target_sdk_version_);
params.push_back({ "SDK_VER", buf });
}
static std::string vndk = Config::get_vndk_version_string('-');
params.push_back({ "VNDK_VER", vndk });
for (auto&& path : paths) {
format_string(&path, params);
}
if (resolve) {
std::vector<std::string> resolved_paths;
// do not remove paths that do not exist
resolve_paths(paths, &resolved_paths);
return resolved_paths;
} else {
return paths;
}
}
static gint
hashfs_fuse_listattrs (const gchar *path, struct stat *stats)
{
GList *entries;
gint rval;
entries = resolve_paths(path);
if (entries) {
GList *item = g_list_last(entries);
hashfs_db_entry_t *entry = item->data;
const gchar *pkey;
pkey = hashfs_db_entry_pkey(entry);
if (g_strrstr(pkey, "set:")) {
stats->st_mode = S_IFDIR | 0755;
stats->st_nlink = 2;
} else {
struct stat realstats;
const gchar *realpath;
if (hashfs_db_entry_lookup(entry, "path", &realpath)) {
stat(realpath, &realstats);
stats->st_mode = S_IFREG | 0444;
stats->st_nlink = 1;
stats->st_size = realstats.st_size;
}
}
rval = 0;
free_entry_list(entries);
} else {
rval = -ENOENT;
}
return rval;
}
void resolve_path(const char *in, char **out)
{
resolve_paths(&in, out, 1);
}
static void parse_path(const char* path, const char* delimiters,
std::vector<std::string>* resolved_paths) {
std::vector<std::string> paths;
split_path(path, delimiters, &paths);
resolve_paths(paths, resolved_paths);
}
static void run_linker_config_smoke_test(bool is_asan) {
const std::vector<std::string> kExpectedDefaultSearchPath =
resolve_paths(is_asan ? std::vector<std::string>({ "/data", "/vendor/lib" ARCH_SUFFIX }) :
std::vector<std::string>({ "/vendor/lib" ARCH_SUFFIX }));
const std::vector<std::string> kExpectedDefaultPermittedPath =
resolve_paths(is_asan ? std::vector<std::string>({ "/data", "/vendor" }) :
std::vector<std::string>({ "/vendor/lib" ARCH_SUFFIX }));
const std::vector<std::string> kExpectedSystemSearchPath =
resolve_paths(is_asan ? std::vector<std::string>({ "/data", "/system/lib" ARCH_SUFFIX }) :
std::vector<std::string>({ "/system/lib" ARCH_SUFFIX }));
const std::vector<std::string> kExpectedSystemPermittedPath =
resolve_paths(is_asan ? std::vector<std::string>({ "/data", "/system" }) :
std::vector<std::string>({ "/system/lib" ARCH_SUFFIX }));
const std::vector<std::string> kExpectedVndkSearchPath =
resolve_paths(is_asan ? std::vector<std::string>({ "/data", "/system/lib" ARCH_SUFFIX "/vndk"}) :
std::vector<std::string>({ "/system/lib" ARCH_SUFFIX "/vndk"}));
TemporaryFile tmp_file;
close(tmp_file.fd);
tmp_file.fd = -1;
android::base::WriteStringToFile(config_str, tmp_file.path);
TemporaryDir tmp_dir;
std::string executable_path = std::string(tmp_dir.path) + "/some-binary";
std::string version_file = std::string(tmp_dir.path) + "/.version";
auto file_guard =
android::base::make_scope_guard([&version_file] { unlink(version_file.c_str()); });
ASSERT_TRUE(write_version(version_file, 113U)) << strerror(errno);
// read config
const Config* config = nullptr;
std::string error_msg;
ASSERT_TRUE(Config::read_binary_config(tmp_file.path,
executable_path.c_str(),
is_asan,
&config,
&error_msg)) << error_msg;
ASSERT_TRUE(config != nullptr);
ASSERT_TRUE(error_msg.empty());
ASSERT_EQ(113U, config->target_sdk_version());
const NamespaceConfig* default_ns_config = config->default_namespace_config();
ASSERT_TRUE(default_ns_config != nullptr);
ASSERT_TRUE(default_ns_config->isolated());
ASSERT_FALSE(default_ns_config->visible());
ASSERT_EQ(kExpectedDefaultSearchPath, default_ns_config->search_paths());
ASSERT_EQ(kExpectedDefaultPermittedPath, default_ns_config->permitted_paths());
const auto& default_ns_links = default_ns_config->links();
ASSERT_EQ(2U, default_ns_links.size());
ASSERT_EQ("system", default_ns_links[0].ns_name());
ASSERT_EQ("libc.so:libm.so:libdl.so:libstdc++.so", default_ns_links[0].shared_libs());
ASSERT_FALSE(default_ns_links[0].allow_all_shared_libs());
ASSERT_EQ("vndk", default_ns_links[1].ns_name());
ASSERT_EQ("libcutils.so:libbase.so", default_ns_links[1].shared_libs());
ASSERT_FALSE(default_ns_links[1].allow_all_shared_libs());
auto& ns_configs = config->namespace_configs();
ASSERT_EQ(3U, ns_configs.size());
// find second namespace
const NamespaceConfig* ns_system = nullptr;
const NamespaceConfig* ns_vndk = nullptr;
for (auto& ns : ns_configs) {
std::string ns_name = ns->name();
ASSERT_TRUE(ns_name == "system" || ns_name == "default" || ns_name == "vndk")
<< "unexpected ns name: " << ns->name();
if (ns_name == "system") {
ns_system = ns.get();
} else if (ns_name == "vndk") {
ns_vndk = ns.get();
}
}
ASSERT_TRUE(ns_system != nullptr) << "system namespace was not found";
ASSERT_TRUE(ns_system->isolated());
ASSERT_TRUE(ns_system->visible());
ASSERT_EQ(kExpectedSystemSearchPath, ns_system->search_paths());
ASSERT_EQ(kExpectedSystemPermittedPath, ns_system->permitted_paths());
ASSERT_TRUE(ns_vndk != nullptr) << "vndk namespace was not found";
ASSERT_FALSE(ns_vndk->isolated()); // malformed bool property
ASSERT_FALSE(ns_vndk->visible()); // undefined bool property
ASSERT_EQ(kExpectedVndkSearchPath, ns_vndk->search_paths());
const auto& ns_vndk_links = ns_vndk->links();
ASSERT_EQ(1U, ns_vndk_links.size());
ASSERT_EQ("default", ns_vndk_links[0].ns_name());
ASSERT_TRUE(ns_vndk_links[0].allow_all_shared_libs());
}
static std::vector<std::string> resolve_paths(std::vector<std::string> paths) {
std::vector<std::string> resolved_paths;
resolve_paths(paths, &resolved_paths);
return resolved_paths;
}
