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; }