blob: f3c70de6c1bb7653f9eb393049e4ffd7232bebd2 [file] [log] [blame]
Dimitry Ivanovac1b1912015-12-01 13:56:44 -08001/*
2 * Copyright (C) 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include "nativeloader/native_loader.h"
Steven Moreland00fe3ad2017-07-18 16:53:54 -070018#include <nativehelper/ScopedUtfChars.h>
Dimitry Ivanovac1b1912015-12-01 13:56:44 -080019
20#include <dlfcn.h>
21#ifdef __ANDROID__
Dimitry Ivanov7f9a1aa2016-03-22 13:59:59 -070022#define LOG_TAG "libnativeloader"
Jesse Hallb75d82b2017-01-09 16:04:28 -080023#include "nativeloader/dlext_namespaces.h"
Mark Salyzynff2dcd92016-09-28 15:54:45 -070024#include "cutils/properties.h"
Mark Salyzyn30f991f2017-01-10 13:19:54 -080025#include "log/log.h"
Dimitry Ivanovac1b1912015-12-01 13:56:44 -080026#endif
Zhenhua WANGf2804e52016-05-30 11:16:08 +080027#include "nativebridge/native_bridge.h"
Dimitry Ivanovac1b1912015-12-01 13:56:44 -080028
29#include <algorithm>
30#include <vector>
31#include <string>
32#include <mutex>
33
Mark Salyzynff2dcd92016-09-28 15:54:45 -070034#include <android-base/file.h>
35#include <android-base/macros.h>
36#include <android-base/strings.h>
Dimitry Ivanovac1b1912015-12-01 13:56:44 -080037
Justin Yun4a1d1102017-11-27 17:04:14 +090038#ifdef __BIONIC__
39#include <android-base/properties.h>
40#endif
41
Zhenhua WANGf2804e52016-05-30 11:16:08 +080042#define CHECK(predicate) LOG_ALWAYS_FATAL_IF(!(predicate),\
43 "%s:%d: %s CHECK '" #predicate "' failed.",\
44 __FILE__, __LINE__, __FUNCTION__)
45
Dimitry Ivanovac1b1912015-12-01 13:56:44 -080046namespace android {
47
Dimitry Ivanov4b0e9632016-03-15 13:51:26 -070048#if defined(__ANDROID__)
Zhenhua WANGf2804e52016-05-30 11:16:08 +080049class NativeLoaderNamespace {
50 public:
51 NativeLoaderNamespace()
52 : android_ns_(nullptr), native_bridge_ns_(nullptr) { }
53
54 explicit NativeLoaderNamespace(android_namespace_t* ns)
55 : android_ns_(ns), native_bridge_ns_(nullptr) { }
56
57 explicit NativeLoaderNamespace(native_bridge_namespace_t* ns)
58 : android_ns_(nullptr), native_bridge_ns_(ns) { }
59
60 NativeLoaderNamespace(NativeLoaderNamespace&& that) = default;
61 NativeLoaderNamespace(const NativeLoaderNamespace& that) = default;
62
63 NativeLoaderNamespace& operator=(const NativeLoaderNamespace& that) = default;
64
65 android_namespace_t* get_android_ns() const {
66 CHECK(native_bridge_ns_ == nullptr);
67 return android_ns_;
68 }
69
70 native_bridge_namespace_t* get_native_bridge_ns() const {
71 CHECK(android_ns_ == nullptr);
72 return native_bridge_ns_;
73 }
74
75 bool is_android_namespace() const {
76 return native_bridge_ns_ == nullptr;
77 }
78
79 private:
80 // Only one of them can be not null
81 android_namespace_t* android_ns_;
82 native_bridge_namespace_t* native_bridge_ns_;
83};
84
85static constexpr const char* kPublicNativeLibrariesSystemConfigPathFromRoot =
86 "/etc/public.libraries.txt";
87static constexpr const char* kPublicNativeLibrariesVendorConfig =
88 "/vendor/etc/public.libraries.txt";
Jiyong Parka07f3052017-08-22 10:26:10 +090089static constexpr const char* kLlndkNativeLibrariesSystemConfigPathFromRoot =
90 "/etc/llndk.libraries.txt";
91static constexpr const char* kVndkspNativeLibrariesSystemConfigPathFromRoot =
92 "/etc/vndksp.libraries.txt";
93
Dimitry Ivanovac1b1912015-12-01 13:56:44 -080094
Dimitry Ivanov882cad22017-05-01 15:12:49 -070095// The device may be configured to have the vendor libraries loaded to a separate namespace.
96// For historical reasons this namespace was named sphal but effectively it is intended
97// to use to load vendor libraries to separate namespace with controlled interface between
98// vendor and system namespaces.
99static constexpr const char* kVendorNamespaceName = "sphal";
100
Jiyong Parka07f3052017-08-22 10:26:10 +0900101static constexpr const char* kVndkNamespaceName = "vndk";
102
103static constexpr const char* kClassloaderNamespaceName = "classloader-namespace";
104static constexpr const char* kVendorClassloaderNamespaceName = "vendor-classloader-namespace";
105
Dimitry Ivanovf334cbf2016-05-10 10:39:48 -0700106// (http://b/27588281) This is a workaround for apps using custom classloaders and calling
107// System.load() with an absolute path which is outside of the classloader library search path.
108// This list includes all directories app is allowed to access this way.
109static constexpr const char* kWhitelistedDirectories = "/data:/mnt/expand";
110
Dimitry Ivanov7d028292016-05-05 17:30:24 -0700111static bool is_debuggable() {
112 char debuggable[PROP_VALUE_MAX];
113 property_get("ro.debuggable", debuggable, "0");
114 return std::string(debuggable) == "1";
115}
116
Justin Yun4a1d1102017-11-27 17:04:14 +0900117static std::string vndk_version_str() {
118#ifdef __BIONIC__
119 std::string version = android::base::GetProperty("ro.vndk.version", "");
120 if (version != "" && version != "current") {
121 return "." + version;
122 }
123#endif
124 return "";
125}
126
127static void insert_vndk_version_str(std::string* file_name) {
128 CHECK(file_name != nullptr);
129 size_t insert_pos = file_name->find_last_of(".");
130 if (insert_pos == std::string::npos) {
131 insert_pos = file_name->length();
132 }
133 file_name->insert(insert_pos, vndk_version_str());
134}
135
Dimitry Ivanovac1b1912015-12-01 13:56:44 -0800136class LibraryNamespaces {
137 public:
Dimitry Ivanov426799d2016-02-22 11:27:48 -0800138 LibraryNamespaces() : initialized_(false) { }
Dimitry Ivanovac1b1912015-12-01 13:56:44 -0800139
Zhenhua WANGf2804e52016-05-30 11:16:08 +0800140 bool Create(JNIEnv* env,
Dimitry Ivanov9e253ce2017-05-08 22:24:24 -0700141 uint32_t target_sdk_version,
Zhenhua WANGf2804e52016-05-30 11:16:08 +0800142 jobject class_loader,
143 bool is_shared,
Jiyong Parka07f3052017-08-22 10:26:10 +0900144 bool is_for_vendor,
Zhenhua WANGf2804e52016-05-30 11:16:08 +0800145 jstring java_library_path,
146 jstring java_permitted_path,
147 NativeLoaderNamespace* ns,
148 std::string* error_msg) {
Dimitry Ivanovcf9892b2016-05-09 10:55:50 -0700149 std::string library_path; // empty string by default.
150
151 if (java_library_path != nullptr) {
152 ScopedUtfChars library_path_utf_chars(env, java_library_path);
153 library_path = library_path_utf_chars.c_str();
154 }
Dimitry Ivanovac1b1912015-12-01 13:56:44 -0800155
Dimitry Ivanovf334cbf2016-05-10 10:39:48 -0700156 // (http://b/27588281) This is a workaround for apps using custom
157 // classloaders and calling System.load() with an absolute path which
158 // is outside of the classloader library search path.
159 //
160 // This part effectively allows such a classloader to access anything
161 // under /data and /mnt/expand
162 std::string permitted_path = kWhitelistedDirectories;
163
Dimitry Ivanov0d6e5942015-12-08 11:16:56 -0800164 if (java_permitted_path != nullptr) {
165 ScopedUtfChars path(env, java_permitted_path);
Dimitry Ivanovd0b15312016-05-10 16:21:25 -0700166 if (path.c_str() != nullptr && path.size() > 0) {
167 permitted_path = permitted_path + ":" + path.c_str();
168 }
Dimitry Ivanov0d6e5942015-12-08 11:16:56 -0800169 }
170
Zhenhua WANGf2804e52016-05-30 11:16:08 +0800171 if (!initialized_ && !InitPublicNamespace(library_path.c_str(), error_msg)) {
172 return false;
Dimitry Ivanovac1b1912015-12-01 13:56:44 -0800173 }
174
Zhenhua WANGf2804e52016-05-30 11:16:08 +0800175 bool found = FindNamespaceByClassLoader(env, class_loader, nullptr);
Dimitry Ivanovac1b1912015-12-01 13:56:44 -0800176
Zhenhua WANGf2804e52016-05-30 11:16:08 +0800177 LOG_ALWAYS_FATAL_IF(found,
Dimitry Ivanov4b0e9632016-03-15 13:51:26 -0700178 "There is already a namespace associated with this classloader");
Dimitry Ivanovac1b1912015-12-01 13:56:44 -0800179
Dimitry Ivanovd2a62202015-12-15 11:06:57 -0800180 uint64_t namespace_type = ANDROID_NAMESPACE_TYPE_ISOLATED;
181 if (is_shared) {
182 namespace_type |= ANDROID_NAMESPACE_TYPE_SHARED;
183 }
184
Dimitry Ivanov9e253ce2017-05-08 22:24:24 -0700185 if (target_sdk_version < 24) {
186 namespace_type |= ANDROID_NAMESPACE_TYPE_GREYLIST_ENABLED;
187 }
188
Zhenhua WANGf2804e52016-05-30 11:16:08 +0800189 NativeLoaderNamespace parent_ns;
190 bool found_parent_namespace = FindParentNamespaceByClassLoader(env, class_loader, &parent_ns);
Dimitry Ivanov24db75c2016-05-12 15:34:41 -0700191
Zhenhua WANGf2804e52016-05-30 11:16:08 +0800192 bool is_native_bridge = false;
Dimitry Ivanovac1b1912015-12-01 13:56:44 -0800193
Zhenhua WANGf2804e52016-05-30 11:16:08 +0800194 if (found_parent_namespace) {
195 is_native_bridge = !parent_ns.is_android_namespace();
196 } else if (!library_path.empty()) {
197 is_native_bridge = NativeBridgeIsPathSupported(library_path.c_str());
Dimitry Ivanovd047c922016-02-23 14:23:51 -0800198 }
Dimitry Ivanovac1b1912015-12-01 13:56:44 -0800199
Jiyong Parka07f3052017-08-22 10:26:10 +0900200 std::string system_exposed_libraries = system_public_libraries_;
201 const char* namespace_name = kClassloaderNamespaceName;
202 android_namespace_t* vndk_ns = nullptr;
203 if (is_for_vendor && !is_shared) {
204 LOG_FATAL_IF(is_native_bridge, "Unbundled vendor apk must not use translated architecture");
205
206 // For vendor apks, give access to the vendor lib even though
207 // they are treated as unbundled; the libs and apks are still bundled
208 // together in the vendor partition.
209#if defined(__LP64__)
210 std::string vendor_lib_path = "/vendor/lib64";
211#else
212 std::string vendor_lib_path = "/vendor/lib";
213#endif
214 library_path = library_path + ":" + vendor_lib_path.c_str();
215 permitted_path = permitted_path + ":" + vendor_lib_path.c_str();
216
217 // Also give access to LLNDK libraries since they are available to vendors
218 system_exposed_libraries = system_exposed_libraries + ":" + system_llndk_libraries_.c_str();
219
220 // Give access to VNDK-SP libraries from the 'vndk' namespace.
221 vndk_ns = android_get_exported_namespace(kVndkNamespaceName);
222 LOG_ALWAYS_FATAL_IF(vndk_ns == nullptr,
223 "Cannot find \"%s\" namespace for vendor apks", kVndkNamespaceName);
224
225 // Different name is useful for debugging
226 namespace_name = kVendorClassloaderNamespaceName;
227 ALOGD("classloader namespace configured for unbundled vendor apk. library_path=%s", library_path.c_str());
228 }
229
Zhenhua WANGf2804e52016-05-30 11:16:08 +0800230 NativeLoaderNamespace native_loader_ns;
231 if (!is_native_bridge) {
Jiyong Parka07f3052017-08-22 10:26:10 +0900232 android_namespace_t* ns = android_create_namespace(namespace_name,
Zhenhua WANGf2804e52016-05-30 11:16:08 +0800233 nullptr,
234 library_path.c_str(),
235 namespace_type,
236 permitted_path.c_str(),
237 parent_ns.get_android_ns());
238 if (ns == nullptr) {
239 *error_msg = dlerror();
240 return false;
241 }
242
Dimitry Ivanov882cad22017-05-01 15:12:49 -0700243 // Note that when vendor_ns is not configured this function will return nullptr
244 // and it will result in linking vendor_public_libraries_ to the default namespace
245 // which is expected behavior in this case.
246 android_namespace_t* vendor_ns = android_get_exported_namespace(kVendorNamespaceName);
247
Jiyong Parka07f3052017-08-22 10:26:10 +0900248 if (!android_link_namespaces(ns, nullptr, system_exposed_libraries.c_str())) {
Dimitry Ivanov26e1a842017-02-03 14:11:27 -0800249 *error_msg = dlerror();
250 return false;
251 }
252
Jiyong Parka07f3052017-08-22 10:26:10 +0900253 if (vndk_ns != nullptr && !system_vndksp_libraries_.empty()) {
254 // vendor apks are allowed to use VNDK-SP libraries.
255 if (!android_link_namespaces(ns, vndk_ns, system_vndksp_libraries_.c_str())) {
256 *error_msg = dlerror();
257 return false;
258 }
259 }
260
Dimitry Ivanov882cad22017-05-01 15:12:49 -0700261 if (!vendor_public_libraries_.empty()) {
262 if (!android_link_namespaces(ns, vendor_ns, vendor_public_libraries_.c_str())) {
263 *error_msg = dlerror();
264 return false;
265 }
266 }
267
Zhenhua WANGf2804e52016-05-30 11:16:08 +0800268 native_loader_ns = NativeLoaderNamespace(ns);
269 } else {
Jiyong Parka07f3052017-08-22 10:26:10 +0900270 native_bridge_namespace_t* ns = NativeBridgeCreateNamespace(namespace_name,
Zhenhua WANGf2804e52016-05-30 11:16:08 +0800271 nullptr,
272 library_path.c_str(),
273 namespace_type,
274 permitted_path.c_str(),
275 parent_ns.get_native_bridge_ns());
Dimitry Ivanov882cad22017-05-01 15:12:49 -0700276
Zhenhua WANGf2804e52016-05-30 11:16:08 +0800277 if (ns == nullptr) {
278 *error_msg = NativeBridgeGetError();
279 return false;
280 }
281
Dimitry Ivanov882cad22017-05-01 15:12:49 -0700282 native_bridge_namespace_t* vendor_ns = NativeBridgeGetVendorNamespace();
283
Jiyong Parka07f3052017-08-22 10:26:10 +0900284 if (!NativeBridgeLinkNamespaces(ns, nullptr, system_exposed_libraries.c_str())) {
Zhenhua WANGe8fb11d2017-02-27 10:14:45 +0800285 *error_msg = NativeBridgeGetError();
286 return false;
287 }
288
Dimitry Ivanov882cad22017-05-01 15:12:49 -0700289 if (!vendor_public_libraries_.empty()) {
290 if (!NativeBridgeLinkNamespaces(ns, vendor_ns, vendor_public_libraries_.c_str())) {
291 *error_msg = NativeBridgeGetError();
292 return false;
293 }
294 }
295
Zhenhua WANGf2804e52016-05-30 11:16:08 +0800296 native_loader_ns = NativeLoaderNamespace(ns);
297 }
298
299 namespaces_.push_back(std::make_pair(env->NewWeakGlobalRef(class_loader), native_loader_ns));
300
301 *ns = native_loader_ns;
302 return true;
Dimitry Ivanovac1b1912015-12-01 13:56:44 -0800303 }
304
Zhenhua WANGf2804e52016-05-30 11:16:08 +0800305 bool FindNamespaceByClassLoader(JNIEnv* env, jobject class_loader, NativeLoaderNamespace* ns) {
Dimitry Ivanovf44ecde2016-02-22 13:48:22 -0800306 auto it = std::find_if(namespaces_.begin(), namespaces_.end(),
Zhenhua WANGf2804e52016-05-30 11:16:08 +0800307 [&](const std::pair<jweak, NativeLoaderNamespace>& value) {
Dimitry Ivanovf44ecde2016-02-22 13:48:22 -0800308 return env->IsSameObject(value.first, class_loader);
309 });
Zhenhua WANGf2804e52016-05-30 11:16:08 +0800310 if (it != namespaces_.end()) {
311 if (ns != nullptr) {
312 *ns = it->second;
313 }
314
315 return true;
316 }
317
318 return false;
Dimitry Ivanovf44ecde2016-02-22 13:48:22 -0800319 }
320
Dimitry Ivanov4b0e9632016-03-15 13:51:26 -0700321 void Initialize() {
Dimitry Ivanov80ddb8f2016-05-09 18:12:00 -0700322 // Once public namespace is initialized there is no
323 // point in running this code - it will have no effect
324 // on the current list of public libraries.
325 if (initialized_) {
326 return;
327 }
328
Dimitry Ivanovb6140452016-04-06 18:24:08 -0700329 std::vector<std::string> sonames;
Dimitry Ivanov0b5651e2016-04-21 16:42:48 -0700330 const char* android_root_env = getenv("ANDROID_ROOT");
331 std::string root_dir = android_root_env != nullptr ? android_root_env : "/system";
332 std::string public_native_libraries_system_config =
333 root_dir + kPublicNativeLibrariesSystemConfigPathFromRoot;
Jiyong Parka07f3052017-08-22 10:26:10 +0900334 std::string llndk_native_libraries_system_config =
335 root_dir + kLlndkNativeLibrariesSystemConfigPathFromRoot;
336 std::string vndksp_native_libraries_system_config =
337 root_dir + kVndkspNativeLibrariesSystemConfigPathFromRoot;
Dimitry Ivanovb6140452016-04-06 18:24:08 -0700338
Christopher Ferris39da84b2016-06-21 16:11:23 -0700339 std::string error_msg;
340 LOG_ALWAYS_FATAL_IF(!ReadConfig(public_native_libraries_system_config, &sonames, &error_msg),
Dimitry Ivanovb6140452016-04-06 18:24:08 -0700341 "Error reading public native library list from \"%s\": %s",
Christopher Ferris39da84b2016-06-21 16:11:23 -0700342 public_native_libraries_system_config.c_str(), error_msg.c_str());
Dimitry Ivanov7d028292016-05-05 17:30:24 -0700343
Justin Yun4a1d1102017-11-27 17:04:14 +0900344 // Insert VNDK version to llndk and vndksp config file names.
345 insert_vndk_version_str(&llndk_native_libraries_system_config);
346 insert_vndk_version_str(&vndksp_native_libraries_system_config);
347
Dimitry Ivanov7d028292016-05-05 17:30:24 -0700348 // For debuggable platform builds use ANDROID_ADDITIONAL_PUBLIC_LIBRARIES environment
349 // variable to add libraries to the list. This is intended for platform tests only.
350 if (is_debuggable()) {
351 const char* additional_libs = getenv("ANDROID_ADDITIONAL_PUBLIC_LIBRARIES");
352 if (additional_libs != nullptr && additional_libs[0] != '\0') {
353 std::vector<std::string> additional_libs_vector = base::Split(additional_libs, ":");
354 std::copy(additional_libs_vector.begin(),
355 additional_libs_vector.end(),
356 std::back_inserter(sonames));
357 }
358 }
359
Dimitry Ivanovb6140452016-04-06 18:24:08 -0700360 // android_init_namespaces() expects all the public libraries
361 // to be loaded so that they can be found by soname alone.
362 //
363 // TODO(dimitry): this is a bit misleading since we do not know
364 // if the vendor public library is going to be opened from /vendor/lib
365 // we might as well end up loading them from /system/lib
366 // For now we rely on CTS test to catch things like this but
367 // it should probably be addressed in the future.
368 for (const auto& soname : sonames) {
Evan Ralston15a264e2017-02-03 17:09:46 -0800369 LOG_ALWAYS_FATAL_IF(dlopen(soname.c_str(), RTLD_NOW | RTLD_NODELETE) == nullptr,
370 "Error preloading public library %s: %s",
371 soname.c_str(), dlerror());
Dimitry Ivanovb6140452016-04-06 18:24:08 -0700372 }
373
Dimitry Ivanov882cad22017-05-01 15:12:49 -0700374 system_public_libraries_ = base::Join(sonames, ':');
375
376 sonames.clear();
Justin Yun4a1d1102017-11-27 17:04:14 +0900377 ReadConfig(llndk_native_libraries_system_config, &sonames);
Jiyong Parka07f3052017-08-22 10:26:10 +0900378 system_llndk_libraries_ = base::Join(sonames, ':');
379
380 sonames.clear();
Justin Yun4a1d1102017-11-27 17:04:14 +0900381 ReadConfig(vndksp_native_libraries_system_config, &sonames);
Jiyong Parka07f3052017-08-22 10:26:10 +0900382 system_vndksp_libraries_ = base::Join(sonames, ':');
383
384 sonames.clear();
Dimitry Ivanov882cad22017-05-01 15:12:49 -0700385 // This file is optional, quietly ignore if the file does not exist.
386 ReadConfig(kPublicNativeLibrariesVendorConfig, &sonames);
387
388 vendor_public_libraries_ = base::Join(sonames, ':');
Dimitry Ivanovb6140452016-04-06 18:24:08 -0700389 }
390
Dimitry Ivanovbe4ca3a2016-05-02 10:43:16 -0700391 void Reset() {
392 namespaces_.clear();
393 }
394
Dimitry Ivanovb6140452016-04-06 18:24:08 -0700395 private:
Christopher Ferris39da84b2016-06-21 16:11:23 -0700396 bool ReadConfig(const std::string& configFile, std::vector<std::string>* sonames,
397 std::string* error_msg = nullptr) {
Dimitry Ivanov4b0e9632016-03-15 13:51:26 -0700398 // Read list of public native libraries from the config file.
399 std::string file_content;
Dimitry Ivanovb6140452016-04-06 18:24:08 -0700400 if(!base::ReadFileToString(configFile, &file_content)) {
Christopher Ferris39da84b2016-06-21 16:11:23 -0700401 if (error_msg) *error_msg = strerror(errno);
Dimitry Ivanovb6140452016-04-06 18:24:08 -0700402 return false;
403 }
Dimitry Ivanov4b0e9632016-03-15 13:51:26 -0700404
405 std::vector<std::string> lines = base::Split(file_content, "\n");
406
Christopher Ferris39da84b2016-06-21 16:11:23 -0700407 for (auto& line : lines) {
Dimitry Ivanov4b0e9632016-03-15 13:51:26 -0700408 auto trimmed_line = base::Trim(line);
409 if (trimmed_line[0] == '#' || trimmed_line.empty()) {
410 continue;
411 }
Christopher Ferris39da84b2016-06-21 16:11:23 -0700412 size_t space_pos = trimmed_line.rfind(' ');
413 if (space_pos != std::string::npos) {
414 std::string type = trimmed_line.substr(space_pos + 1);
415 if (type != "32" && type != "64") {
416 if (error_msg) *error_msg = "Malformed line: " + line;
417 return false;
418 }
419#if defined(__LP64__)
420 // Skip 32 bit public library.
421 if (type == "32") {
422 continue;
423 }
424#else
425 // Skip 64 bit public library.
426 if (type == "64") {
427 continue;
428 }
429#endif
430 trimmed_line.resize(space_pos);
431 }
Dimitry Ivanov4b0e9632016-03-15 13:51:26 -0700432
Dimitry Ivanovb6140452016-04-06 18:24:08 -0700433 sonames->push_back(trimmed_line);
Dimitry Ivanov4b0e9632016-03-15 13:51:26 -0700434 }
435
Dimitry Ivanovb6140452016-04-06 18:24:08 -0700436 return true;
Dimitry Ivanovd68c8e92016-02-10 14:09:22 -0800437 }
Dimitry Ivanovac1b1912015-12-01 13:56:44 -0800438
Zhenhua WANGf2804e52016-05-30 11:16:08 +0800439 bool InitPublicNamespace(const char* library_path, std::string* error_msg) {
440 // Ask native bride if this apps library path should be handled by it
441 bool is_native_bridge = NativeBridgeIsPathSupported(library_path);
442
Dimitry Ivanov4b0e9632016-03-15 13:51:26 -0700443 // (http://b/25844435) - Some apps call dlopen from generated code (mono jited
444 // code is one example) unknown to linker in which case linker uses anonymous
445 // namespace. The second argument specifies the search path for the anonymous
446 // namespace which is the library_path of the classloader.
Dimitry Ivanov882cad22017-05-01 15:12:49 -0700447 initialized_ = android_init_anonymous_namespace(system_public_libraries_.c_str(),
Dimitry Ivanov26e1a842017-02-03 14:11:27 -0800448 is_native_bridge ? nullptr : library_path);
Dimitry Ivanovd836ab02016-11-02 18:03:10 -0700449 if (!initialized_) {
450 *error_msg = dlerror();
451 return false;
452 }
453
454 // and now initialize native bridge namespaces if necessary.
455 if (NativeBridgeInitialized()) {
Dimitry Ivanov882cad22017-05-01 15:12:49 -0700456 initialized_ = NativeBridgeInitAnonymousNamespace(system_public_libraries_.c_str(),
Zhenhua WANGe8fb11d2017-02-27 10:14:45 +0800457 is_native_bridge ? library_path : nullptr);
Zhenhua WANGf2804e52016-05-30 11:16:08 +0800458 if (!initialized_) {
459 *error_msg = NativeBridgeGetError();
460 }
461 }
Dimitry Ivanovac1b1912015-12-01 13:56:44 -0800462
463 return initialized_;
464 }
465
Dimitry Ivanov24db75c2016-05-12 15:34:41 -0700466 jobject GetParentClassLoader(JNIEnv* env, jobject class_loader) {
467 jclass class_loader_class = env->FindClass("java/lang/ClassLoader");
468 jmethodID get_parent = env->GetMethodID(class_loader_class,
469 "getParent",
470 "()Ljava/lang/ClassLoader;");
471
472 return env->CallObjectMethod(class_loader, get_parent);
473 }
474
Zhenhua WANGf2804e52016-05-30 11:16:08 +0800475 bool FindParentNamespaceByClassLoader(JNIEnv* env,
476 jobject class_loader,
477 NativeLoaderNamespace* ns) {
Dimitry Ivanov24db75c2016-05-12 15:34:41 -0700478 jobject parent_class_loader = GetParentClassLoader(env, class_loader);
479
480 while (parent_class_loader != nullptr) {
Zhenhua WANGf2804e52016-05-30 11:16:08 +0800481 if (FindNamespaceByClassLoader(env, parent_class_loader, ns)) {
482 return true;
Dimitry Ivanov24db75c2016-05-12 15:34:41 -0700483 }
484
485 parent_class_loader = GetParentClassLoader(env, parent_class_loader);
486 }
Zhenhua WANGf2804e52016-05-30 11:16:08 +0800487
488 return false;
Dimitry Ivanov24db75c2016-05-12 15:34:41 -0700489 }
490
Dimitry Ivanovac1b1912015-12-01 13:56:44 -0800491 bool initialized_;
Zhenhua WANGf2804e52016-05-30 11:16:08 +0800492 std::vector<std::pair<jweak, NativeLoaderNamespace>> namespaces_;
Dimitry Ivanov882cad22017-05-01 15:12:49 -0700493 std::string system_public_libraries_;
494 std::string vendor_public_libraries_;
Jiyong Parka07f3052017-08-22 10:26:10 +0900495 std::string system_llndk_libraries_;
496 std::string system_vndksp_libraries_;
Dimitry Ivanovac1b1912015-12-01 13:56:44 -0800497
498 DISALLOW_COPY_AND_ASSIGN(LibraryNamespaces);
499};
500
Dimitry Ivanov34d5a202016-02-29 13:21:43 -0800501static std::mutex g_namespaces_mutex;
Dimitry Ivanovac1b1912015-12-01 13:56:44 -0800502static LibraryNamespaces* g_namespaces = new LibraryNamespaces;
503#endif
504
Dimitry Ivanov4b0e9632016-03-15 13:51:26 -0700505void InitializeNativeLoader() {
Dimitry Ivanov426799d2016-02-22 11:27:48 -0800506#if defined(__ANDROID__)
Dimitry Ivanov34d5a202016-02-29 13:21:43 -0800507 std::lock_guard<std::mutex> guard(g_namespaces_mutex);
Dimitry Ivanov4b0e9632016-03-15 13:51:26 -0700508 g_namespaces->Initialize();
Dimitry Ivanov426799d2016-02-22 11:27:48 -0800509#endif
510}
511
Dimitry Ivanovbe4ca3a2016-05-02 10:43:16 -0700512void ResetNativeLoader() {
513#if defined(__ANDROID__)
514 std::lock_guard<std::mutex> guard(g_namespaces_mutex);
515 g_namespaces->Reset();
516#endif
517}
Dimitry Ivanovac1b1912015-12-01 13:56:44 -0800518
Dimitry Ivanovd047c922016-02-23 14:23:51 -0800519jstring CreateClassLoaderNamespace(JNIEnv* env,
520 int32_t target_sdk_version,
521 jobject class_loader,
522 bool is_shared,
Jiyong Parka07f3052017-08-22 10:26:10 +0900523 bool is_for_vendor,
Dimitry Ivanovd047c922016-02-23 14:23:51 -0800524 jstring library_path,
525 jstring permitted_path) {
Dimitry Ivanovac1b1912015-12-01 13:56:44 -0800526#if defined(__ANDROID__)
Dimitry Ivanov34d5a202016-02-29 13:21:43 -0800527 std::lock_guard<std::mutex> guard(g_namespaces_mutex);
Zhenhua WANGf2804e52016-05-30 11:16:08 +0800528
529 std::string error_msg;
530 NativeLoaderNamespace ns;
531 bool success = g_namespaces->Create(env,
Dimitry Ivanov9e253ce2017-05-08 22:24:24 -0700532 target_sdk_version,
Zhenhua WANGf2804e52016-05-30 11:16:08 +0800533 class_loader,
534 is_shared,
Jiyong Parka07f3052017-08-22 10:26:10 +0900535 is_for_vendor,
Zhenhua WANGf2804e52016-05-30 11:16:08 +0800536 library_path,
537 permitted_path,
538 &ns,
539 &error_msg);
540 if (!success) {
541 return env->NewStringUTF(error_msg.c_str());
Dimitry Ivanovd047c922016-02-23 14:23:51 -0800542 }
543#else
Jiyong Parka07f3052017-08-22 10:26:10 +0900544 UNUSED(env, target_sdk_version, class_loader, is_shared, is_for_vendor,
Dimitry Ivanovd047c922016-02-23 14:23:51 -0800545 library_path, permitted_path);
546#endif
547 return nullptr;
548}
549
550void* OpenNativeLibrary(JNIEnv* env,
551 int32_t target_sdk_version,
552 const char* path,
553 jobject class_loader,
Zhenhua WANGf2804e52016-05-30 11:16:08 +0800554 jstring library_path,
555 bool* needs_native_bridge,
556 std::string* error_msg) {
Dimitry Ivanovd047c922016-02-23 14:23:51 -0800557#if defined(__ANDROID__)
Dimitry Ivanov5539db02016-04-20 16:07:30 -0700558 UNUSED(target_sdk_version);
559 if (class_loader == nullptr) {
Zhenhua WANGf2804e52016-05-30 11:16:08 +0800560 *needs_native_bridge = false;
Dimitry Ivanovac1b1912015-12-01 13:56:44 -0800561 return dlopen(path, RTLD_NOW);
562 }
563
Dimitry Ivanov34d5a202016-02-29 13:21:43 -0800564 std::lock_guard<std::mutex> guard(g_namespaces_mutex);
Zhenhua WANGf2804e52016-05-30 11:16:08 +0800565 NativeLoaderNamespace ns;
Dimitry Ivanovac1b1912015-12-01 13:56:44 -0800566
Zhenhua WANGf2804e52016-05-30 11:16:08 +0800567 if (!g_namespaces->FindNamespaceByClassLoader(env, class_loader, &ns)) {
Dimitry Ivanovd047c922016-02-23 14:23:51 -0800568 // This is the case where the classloader was not created by ApplicationLoaders
569 // In this case we create an isolated not-shared namespace for it.
Dimitry Ivanov9e253ce2017-05-08 22:24:24 -0700570 if (!g_namespaces->Create(env,
571 target_sdk_version,
572 class_loader,
Jiyong Parka07f3052017-08-22 10:26:10 +0900573 false /* is_shared */,
574 false /* is_for_vendor */,
Dimitry Ivanov9e253ce2017-05-08 22:24:24 -0700575 library_path,
576 nullptr,
577 &ns,
578 error_msg)) {
Dimitry Ivanovd047c922016-02-23 14:23:51 -0800579 return nullptr;
580 }
Dimitry Ivanovac1b1912015-12-01 13:56:44 -0800581 }
582
Zhenhua WANGf2804e52016-05-30 11:16:08 +0800583 if (ns.is_android_namespace()) {
584 android_dlextinfo extinfo;
585 extinfo.flags = ANDROID_DLEXT_USE_NAMESPACE;
586 extinfo.library_namespace = ns.get_android_ns();
Dimitry Ivanovac1b1912015-12-01 13:56:44 -0800587
Zhenhua WANGf2804e52016-05-30 11:16:08 +0800588 void* handle = android_dlopen_ext(path, RTLD_NOW, &extinfo);
589 if (handle == nullptr) {
590 *error_msg = dlerror();
591 }
592 *needs_native_bridge = false;
593 return handle;
594 } else {
595 void* handle = NativeBridgeLoadLibraryExt(path, RTLD_NOW, ns.get_native_bridge_ns());
596 if (handle == nullptr) {
597 *error_msg = NativeBridgeGetError();
598 }
599 *needs_native_bridge = true;
600 return handle;
601 }
Dimitry Ivanovac1b1912015-12-01 13:56:44 -0800602#else
Dimitry Ivanovd047c922016-02-23 14:23:51 -0800603 UNUSED(env, target_sdk_version, class_loader, library_path);
Zhenhua WANGf2804e52016-05-30 11:16:08 +0800604 *needs_native_bridge = false;
605 void* handle = dlopen(path, RTLD_NOW);
606 if (handle == nullptr) {
607 if (NativeBridgeIsSupported(path)) {
608 *needs_native_bridge = true;
609 handle = NativeBridgeLoadLibrary(path, RTLD_NOW);
610 if (handle == nullptr) {
611 *error_msg = NativeBridgeGetError();
612 }
613 } else {
614 *needs_native_bridge = false;
615 *error_msg = dlerror();
616 }
617 }
618 return handle;
Dimitry Ivanovac1b1912015-12-01 13:56:44 -0800619#endif
620}
621
Zhenhua WANGf2804e52016-05-30 11:16:08 +0800622bool CloseNativeLibrary(void* handle, const bool needs_native_bridge) {
623 return needs_native_bridge ? NativeBridgeUnloadLibrary(handle) :
624 dlclose(handle);
Dimitry Ivanov09a516b2016-05-03 14:55:25 -0700625}
626
Dimitry Ivanovf44ecde2016-02-22 13:48:22 -0800627#if defined(__ANDROID__)
Dimitry Ivanov800083d2016-11-01 14:17:00 -0700628// native_bridge_namespaces are not supported for callers of this function.
629// This function will return nullptr in the case when application is running
630// on native bridge.
Dimitry Ivanovf44ecde2016-02-22 13:48:22 -0800631android_namespace_t* FindNamespaceByClassLoader(JNIEnv* env, jobject class_loader) {
Dimitry Ivanov34d5a202016-02-29 13:21:43 -0800632 std::lock_guard<std::mutex> guard(g_namespaces_mutex);
Zhenhua WANGf2804e52016-05-30 11:16:08 +0800633 NativeLoaderNamespace ns;
634 if (g_namespaces->FindNamespaceByClassLoader(env, class_loader, &ns)) {
Dimitry Ivanov800083d2016-11-01 14:17:00 -0700635 return ns.is_android_namespace() ? ns.get_android_ns() : nullptr;
Zhenhua WANGf2804e52016-05-30 11:16:08 +0800636 }
637
638 return nullptr;
Dimitry Ivanovf44ecde2016-02-22 13:48:22 -0800639}
640#endif
641
Dimitry Ivanovac1b1912015-12-01 13:56:44 -0800642}; // android namespace