Dimitry Ivanov | ac1b191 | 2015-12-01 13:56:44 -0800 | [diff] [blame] | 1 | /* |
| 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" |
Jiyong Park | 6291da2 | 2019-04-26 18:55:48 +0900 | [diff] [blame^] | 18 | #define LOG_TAG "nativeloader" |
Dimitry Ivanov | ac1b191 | 2015-12-01 13:56:44 -0800 | [diff] [blame] | 19 | |
| 20 | #include <dlfcn.h> |
Jiyong Park | d1006fe | 2017-11-08 18:44:09 +0900 | [diff] [blame] | 21 | #include <sys/types.h> |
Dimitry Ivanov | ac1b191 | 2015-12-01 13:56:44 -0800 | [diff] [blame] | 22 | |
Jiyong Park | d1006fe | 2017-11-08 18:44:09 +0900 | [diff] [blame] | 23 | #include <memory> |
Dimitry Ivanov | ac1b191 | 2015-12-01 13:56:44 -0800 | [diff] [blame] | 24 | #include <mutex> |
Jiyong Park | d1006fe | 2017-11-08 18:44:09 +0900 | [diff] [blame] | 25 | #include <string> |
| 26 | #include <vector> |
Dimitry Ivanov | ac1b191 | 2015-12-01 13:56:44 -0800 | [diff] [blame] | 27 | |
Jiyong Park | 6291da2 | 2019-04-26 18:55:48 +0900 | [diff] [blame^] | 28 | #include "android-base/file.h" |
| 29 | #include "android-base/macros.h" |
| 30 | #include "android-base/strings.h" |
| 31 | #ifdef __ANDROID__ |
| 32 | #include "library_namespaces.h" |
| 33 | #include "log/log.h" |
| 34 | #include "nativeloader/dlext_namespaces.h" |
Justin Yun | 4a1d110 | 2017-11-27 17:04:14 +0900 | [diff] [blame] | 35 | #endif |
Jiyong Park | 6291da2 | 2019-04-26 18:55:48 +0900 | [diff] [blame^] | 36 | #include "nativebridge/native_bridge.h" |
| 37 | #include "nativehelper/ScopedUtfChars.h" |
Inseob Kim | 67cb056 | 2018-05-04 11:39:12 +0900 | [diff] [blame] | 38 | |
Dimitry Ivanov | ac1b191 | 2015-12-01 13:56:44 -0800 | [diff] [blame] | 39 | namespace android { |
| 40 | |
Jiyong Park | 6291da2 | 2019-04-26 18:55:48 +0900 | [diff] [blame^] | 41 | namespace { |
Dimitry Ivanov | 4b0e963 | 2016-03-15 13:51:26 -0700 | [diff] [blame] | 42 | #if defined(__ANDROID__) |
Jiyong Park | 6291da2 | 2019-04-26 18:55:48 +0900 | [diff] [blame^] | 43 | constexpr const char* kApexPath = "/apex/"; |
Zhenhua WANG | f2804e5 | 2016-05-30 11:16:08 +0800 | [diff] [blame] | 44 | |
Jiyong Park | 6291da2 | 2019-04-26 18:55:48 +0900 | [diff] [blame^] | 45 | std::mutex g_namespaces_mutex; |
| 46 | LibraryNamespaces* g_namespaces = new LibraryNamespaces; |
Zhenhua WANG | f2804e5 | 2016-05-30 11:16:08 +0800 | [diff] [blame] | 47 | |
Jiyong Park | 6291da2 | 2019-04-26 18:55:48 +0900 | [diff] [blame^] | 48 | android_namespace_t* FindExportedNamespace(const char* caller_location) { |
| 49 | std::string location = caller_location; |
| 50 | // Lots of implicit assumptions here: we expect `caller_location` to be of the form: |
| 51 | // /apex/com.android...modulename/... |
| 52 | // |
| 53 | // And we extract from it 'modulename', which is the name of the linker namespace. |
| 54 | if (android::base::StartsWith(location, kApexPath)) { |
| 55 | size_t slash_index = location.find_first_of('/', strlen(kApexPath)); |
| 56 | LOG_ALWAYS_FATAL_IF((slash_index == std::string::npos), |
| 57 | "Error finding namespace of apex: no slash in path %s", caller_location); |
| 58 | size_t dot_index = location.find_last_of('.', slash_index); |
| 59 | LOG_ALWAYS_FATAL_IF((dot_index == std::string::npos), |
| 60 | "Error finding namespace of apex: no dot in apex name %s", caller_location); |
| 61 | std::string name = location.substr(dot_index + 1, slash_index - dot_index - 1); |
| 62 | android_namespace_t* boot_namespace = android_get_exported_namespace(name.c_str()); |
| 63 | LOG_ALWAYS_FATAL_IF((boot_namespace == nullptr), |
| 64 | "Error finding namespace of apex: no namespace called %s", name.c_str()); |
| 65 | return boot_namespace; |
Zhenhua WANG | f2804e5 | 2016-05-30 11:16:08 +0800 | [diff] [blame] | 66 | } |
Jiyong Park | 6291da2 | 2019-04-26 18:55:48 +0900 | [diff] [blame^] | 67 | return nullptr; |
Dimitry Ivanov | 7d02829 | 2016-05-05 17:30:24 -0700 | [diff] [blame] | 68 | } |
Jiyong Park | 6291da2 | 2019-04-26 18:55:48 +0900 | [diff] [blame^] | 69 | #endif // #if defined(__ANDROID__) |
| 70 | } // namespace |
Dimitry Ivanov | ac1b191 | 2015-12-01 13:56:44 -0800 | [diff] [blame] | 71 | |
Dimitry Ivanov | 4b0e963 | 2016-03-15 13:51:26 -0700 | [diff] [blame] | 72 | void InitializeNativeLoader() { |
Dimitry Ivanov | 426799d | 2016-02-22 11:27:48 -0800 | [diff] [blame] | 73 | #if defined(__ANDROID__) |
Dimitry Ivanov | 34d5a20 | 2016-02-29 13:21:43 -0800 | [diff] [blame] | 74 | std::lock_guard<std::mutex> guard(g_namespaces_mutex); |
Dimitry Ivanov | 4b0e963 | 2016-03-15 13:51:26 -0700 | [diff] [blame] | 75 | g_namespaces->Initialize(); |
Dimitry Ivanov | 426799d | 2016-02-22 11:27:48 -0800 | [diff] [blame] | 76 | #endif |
| 77 | } |
| 78 | |
Dimitry Ivanov | be4ca3a | 2016-05-02 10:43:16 -0700 | [diff] [blame] | 79 | void ResetNativeLoader() { |
| 80 | #if defined(__ANDROID__) |
| 81 | std::lock_guard<std::mutex> guard(g_namespaces_mutex); |
| 82 | g_namespaces->Reset(); |
| 83 | #endif |
| 84 | } |
Dimitry Ivanov | ac1b191 | 2015-12-01 13:56:44 -0800 | [diff] [blame] | 85 | |
Kiyoung Kim | 4639f69 | 2019-02-20 18:04:39 +0900 | [diff] [blame] | 86 | jstring CreateClassLoaderNamespace(JNIEnv* env, int32_t target_sdk_version, jobject class_loader, |
| 87 | bool is_shared, jstring dex_path, jstring library_path, |
Dimitry Ivanov | d047c92 | 2016-02-23 14:23:51 -0800 | [diff] [blame] | 88 | jstring permitted_path) { |
Dimitry Ivanov | ac1b191 | 2015-12-01 13:56:44 -0800 | [diff] [blame] | 89 | #if defined(__ANDROID__) |
Dimitry Ivanov | 34d5a20 | 2016-02-29 13:21:43 -0800 | [diff] [blame] | 90 | std::lock_guard<std::mutex> guard(g_namespaces_mutex); |
Zhenhua WANG | f2804e5 | 2016-05-30 11:16:08 +0800 | [diff] [blame] | 91 | |
| 92 | std::string error_msg; |
Kiyoung Kim | 4639f69 | 2019-02-20 18:04:39 +0900 | [diff] [blame] | 93 | bool success = g_namespaces->Create(env, target_sdk_version, class_loader, is_shared, dex_path, |
| 94 | library_path, permitted_path, &error_msg) != nullptr; |
Zhenhua WANG | f2804e5 | 2016-05-30 11:16:08 +0800 | [diff] [blame] | 95 | if (!success) { |
| 96 | return env->NewStringUTF(error_msg.c_str()); |
Dimitry Ivanov | d047c92 | 2016-02-23 14:23:51 -0800 | [diff] [blame] | 97 | } |
| 98 | #else |
Kiyoung Kim | 4639f69 | 2019-02-20 18:04:39 +0900 | [diff] [blame] | 99 | UNUSED(env, target_sdk_version, class_loader, is_shared, dex_path, library_path, permitted_path); |
Dimitry Ivanov | d047c92 | 2016-02-23 14:23:51 -0800 | [diff] [blame] | 100 | #endif |
| 101 | return nullptr; |
| 102 | } |
| 103 | |
Nicolas Geoffray | c3a73dc | 2019-01-12 15:01:20 +0000 | [diff] [blame] | 104 | void* OpenNativeLibrary(JNIEnv* env, int32_t target_sdk_version, const char* path, |
Nicolas Geoffray | 5353502 | 2019-01-18 10:05:13 +0000 | [diff] [blame] | 105 | jobject class_loader, const char* caller_location, jstring library_path, |
| 106 | bool* needs_native_bridge, char** error_msg) { |
Dimitry Ivanov | d047c92 | 2016-02-23 14:23:51 -0800 | [diff] [blame] | 107 | #if defined(__ANDROID__) |
Dimitry Ivanov | 5539db0 | 2016-04-20 16:07:30 -0700 | [diff] [blame] | 108 | UNUSED(target_sdk_version); |
| 109 | if (class_loader == nullptr) { |
Zhenhua WANG | f2804e5 | 2016-05-30 11:16:08 +0800 | [diff] [blame] | 110 | *needs_native_bridge = false; |
Nicolas Geoffray | 890e3bf | 2019-01-22 09:11:57 +0000 | [diff] [blame] | 111 | if (caller_location != nullptr) { |
| 112 | android_namespace_t* boot_namespace = FindExportedNamespace(caller_location); |
| 113 | if (boot_namespace != nullptr) { |
| 114 | const android_dlextinfo dlextinfo = { |
| 115 | .flags = ANDROID_DLEXT_USE_NAMESPACE, |
| 116 | .library_namespace = boot_namespace, |
| 117 | }; |
| 118 | void* handle = android_dlopen_ext(path, RTLD_NOW, &dlextinfo); |
| 119 | if (handle == nullptr) { |
| 120 | *error_msg = strdup(dlerror()); |
| 121 | } |
| 122 | return handle; |
| 123 | } |
| 124 | } |
Pete Bentley | 632f142 | 2018-12-19 13:33:33 +0000 | [diff] [blame] | 125 | void* handle = dlopen(path, RTLD_NOW); |
| 126 | if (handle == nullptr) { |
Nicolas Geoffray | d06cb94 | 2019-01-16 20:20:27 +0000 | [diff] [blame] | 127 | *error_msg = strdup(dlerror()); |
Pete Bentley | 632f142 | 2018-12-19 13:33:33 +0000 | [diff] [blame] | 128 | } |
| 129 | return handle; |
Dimitry Ivanov | ac1b191 | 2015-12-01 13:56:44 -0800 | [diff] [blame] | 130 | } |
| 131 | |
Dimitry Ivanov | 34d5a20 | 2016-02-29 13:21:43 -0800 | [diff] [blame] | 132 | std::lock_guard<std::mutex> guard(g_namespaces_mutex); |
Victor Khimenko | 1443ec4 | 2018-07-09 17:01:22 +0200 | [diff] [blame] | 133 | NativeLoaderNamespace* ns; |
Dimitry Ivanov | ac1b191 | 2015-12-01 13:56:44 -0800 | [diff] [blame] | 134 | |
Victor Khimenko | 1443ec4 | 2018-07-09 17:01:22 +0200 | [diff] [blame] | 135 | if ((ns = g_namespaces->FindNamespaceByClassLoader(env, class_loader)) == nullptr) { |
Dimitry Ivanov | d047c92 | 2016-02-23 14:23:51 -0800 | [diff] [blame] | 136 | // This is the case where the classloader was not created by ApplicationLoaders |
| 137 | // In this case we create an isolated not-shared namespace for it. |
Nicolas Geoffray | c3a73dc | 2019-01-12 15:01:20 +0000 | [diff] [blame] | 138 | std::string create_error_msg; |
| 139 | if ((ns = g_namespaces->Create(env, target_sdk_version, class_loader, false /* is_shared */, |
Kiyoung Kim | 4639f69 | 2019-02-20 18:04:39 +0900 | [diff] [blame] | 140 | nullptr, library_path, nullptr, &create_error_msg)) == nullptr) { |
Nicolas Geoffray | c3a73dc | 2019-01-12 15:01:20 +0000 | [diff] [blame] | 141 | *error_msg = strdup(create_error_msg.c_str()); |
Dimitry Ivanov | d047c92 | 2016-02-23 14:23:51 -0800 | [diff] [blame] | 142 | return nullptr; |
| 143 | } |
Dimitry Ivanov | ac1b191 | 2015-12-01 13:56:44 -0800 | [diff] [blame] | 144 | } |
| 145 | |
Nicolas Geoffray | c3a73dc | 2019-01-12 15:01:20 +0000 | [diff] [blame] | 146 | return OpenNativeLibraryInNamespace(ns, path, needs_native_bridge, error_msg); |
Dimitry Ivanov | ac1b191 | 2015-12-01 13:56:44 -0800 | [diff] [blame] | 147 | #else |
Nicolas Geoffray | 5353502 | 2019-01-18 10:05:13 +0000 | [diff] [blame] | 148 | UNUSED(env, target_sdk_version, class_loader, caller_location); |
Andreas Gampe | 5c7d582 | 2017-12-28 19:08:13 -0800 | [diff] [blame] | 149 | |
| 150 | // Do some best effort to emulate library-path support. It will not |
| 151 | // work for dependencies. |
| 152 | // |
| 153 | // Note: null has a special meaning and must be preserved. |
| 154 | std::string c_library_path; // Empty string by default. |
| 155 | if (library_path != nullptr && path != nullptr && path[0] != '/') { |
| 156 | ScopedUtfChars library_path_utf_chars(env, library_path); |
| 157 | c_library_path = library_path_utf_chars.c_str(); |
| 158 | } |
| 159 | |
| 160 | std::vector<std::string> library_paths = base::Split(c_library_path, ":"); |
| 161 | |
| 162 | for (const std::string& lib_path : library_paths) { |
| 163 | *needs_native_bridge = false; |
| 164 | const char* path_arg; |
| 165 | std::string complete_path; |
| 166 | if (path == nullptr) { |
| 167 | // Preserve null. |
| 168 | path_arg = nullptr; |
Zhenhua WANG | f2804e5 | 2016-05-30 11:16:08 +0800 | [diff] [blame] | 169 | } else { |
Andreas Gampe | 5c7d582 | 2017-12-28 19:08:13 -0800 | [diff] [blame] | 170 | complete_path = lib_path; |
| 171 | if (!complete_path.empty()) { |
| 172 | complete_path.append("/"); |
| 173 | } |
| 174 | complete_path.append(path); |
| 175 | path_arg = complete_path.c_str(); |
| 176 | } |
| 177 | void* handle = dlopen(path_arg, RTLD_NOW); |
| 178 | if (handle != nullptr) { |
| 179 | return handle; |
| 180 | } |
| 181 | if (NativeBridgeIsSupported(path_arg)) { |
| 182 | *needs_native_bridge = true; |
| 183 | handle = NativeBridgeLoadLibrary(path_arg, RTLD_NOW); |
| 184 | if (handle != nullptr) { |
| 185 | return handle; |
| 186 | } |
Nicolas Geoffray | c3a73dc | 2019-01-12 15:01:20 +0000 | [diff] [blame] | 187 | *error_msg = strdup(NativeBridgeGetError()); |
Andreas Gampe | 5c7d582 | 2017-12-28 19:08:13 -0800 | [diff] [blame] | 188 | } else { |
Nicolas Geoffray | c3a73dc | 2019-01-12 15:01:20 +0000 | [diff] [blame] | 189 | *error_msg = strdup(dlerror()); |
Zhenhua WANG | f2804e5 | 2016-05-30 11:16:08 +0800 | [diff] [blame] | 190 | } |
| 191 | } |
Andreas Gampe | 5c7d582 | 2017-12-28 19:08:13 -0800 | [diff] [blame] | 192 | return nullptr; |
Dimitry Ivanov | ac1b191 | 2015-12-01 13:56:44 -0800 | [diff] [blame] | 193 | #endif |
| 194 | } |
| 195 | |
Nicolas Geoffray | c3a73dc | 2019-01-12 15:01:20 +0000 | [diff] [blame] | 196 | bool CloseNativeLibrary(void* handle, const bool needs_native_bridge, char** error_msg) { |
dimitry | 3150f7c | 2018-09-12 01:09:19 +0200 | [diff] [blame] | 197 | bool success; |
| 198 | if (needs_native_bridge) { |
| 199 | success = (NativeBridgeUnloadLibrary(handle) == 0); |
| 200 | if (!success) { |
Nicolas Geoffray | c3a73dc | 2019-01-12 15:01:20 +0000 | [diff] [blame] | 201 | *error_msg = strdup(NativeBridgeGetError()); |
dimitry | 3150f7c | 2018-09-12 01:09:19 +0200 | [diff] [blame] | 202 | } |
| 203 | } else { |
| 204 | success = (dlclose(handle) == 0); |
| 205 | if (!success) { |
Nicolas Geoffray | c3a73dc | 2019-01-12 15:01:20 +0000 | [diff] [blame] | 206 | *error_msg = strdup(dlerror()); |
dimitry | 3150f7c | 2018-09-12 01:09:19 +0200 | [diff] [blame] | 207 | } |
| 208 | } |
| 209 | |
| 210 | return success; |
Dimitry Ivanov | 09a516b | 2016-05-03 14:55:25 -0700 | [diff] [blame] | 211 | } |
| 212 | |
Nicolas Geoffray | c3a73dc | 2019-01-12 15:01:20 +0000 | [diff] [blame] | 213 | void NativeLoaderFreeErrorMessage(char* msg) { |
| 214 | // The error messages get allocated through strdup, so we must call free on them. |
| 215 | free(msg); |
| 216 | } |
| 217 | |
Dimitry Ivanov | f44ecde | 2016-02-22 13:48:22 -0800 | [diff] [blame] | 218 | #if defined(__ANDROID__) |
Nicolas Geoffray | c3a73dc | 2019-01-12 15:01:20 +0000 | [diff] [blame] | 219 | void* OpenNativeLibraryInNamespace(NativeLoaderNamespace* ns, const char* path, |
| 220 | bool* needs_native_bridge, char** error_msg) { |
Victor Khimenko | 1443ec4 | 2018-07-09 17:01:22 +0200 | [diff] [blame] | 221 | if (ns->is_android_namespace()) { |
| 222 | android_dlextinfo extinfo; |
| 223 | extinfo.flags = ANDROID_DLEXT_USE_NAMESPACE; |
| 224 | extinfo.library_namespace = ns->get_android_ns(); |
| 225 | |
| 226 | void* handle = android_dlopen_ext(path, RTLD_NOW, &extinfo); |
| 227 | if (handle == nullptr) { |
Nicolas Geoffray | c3a73dc | 2019-01-12 15:01:20 +0000 | [diff] [blame] | 228 | *error_msg = strdup(dlerror()); |
Victor Khimenko | 1443ec4 | 2018-07-09 17:01:22 +0200 | [diff] [blame] | 229 | } |
| 230 | *needs_native_bridge = false; |
| 231 | return handle; |
| 232 | } else { |
| 233 | void* handle = NativeBridgeLoadLibraryExt(path, RTLD_NOW, ns->get_native_bridge_ns()); |
| 234 | if (handle == nullptr) { |
Nicolas Geoffray | c3a73dc | 2019-01-12 15:01:20 +0000 | [diff] [blame] | 235 | *error_msg = strdup(NativeBridgeGetError()); |
Victor Khimenko | 1443ec4 | 2018-07-09 17:01:22 +0200 | [diff] [blame] | 236 | } |
| 237 | *needs_native_bridge = true; |
| 238 | return handle; |
| 239 | } |
| 240 | } |
| 241 | |
Dimitry Ivanov | 800083d | 2016-11-01 14:17:00 -0700 | [diff] [blame] | 242 | // native_bridge_namespaces are not supported for callers of this function. |
| 243 | // This function will return nullptr in the case when application is running |
| 244 | // on native bridge. |
Dimitry Ivanov | f44ecde | 2016-02-22 13:48:22 -0800 | [diff] [blame] | 245 | android_namespace_t* FindNamespaceByClassLoader(JNIEnv* env, jobject class_loader) { |
Dimitry Ivanov | 34d5a20 | 2016-02-29 13:21:43 -0800 | [diff] [blame] | 246 | std::lock_guard<std::mutex> guard(g_namespaces_mutex); |
Victor Khimenko | 1443ec4 | 2018-07-09 17:01:22 +0200 | [diff] [blame] | 247 | NativeLoaderNamespace* ns = g_namespaces->FindNamespaceByClassLoader(env, class_loader); |
| 248 | if (ns != nullptr) { |
| 249 | return ns->is_android_namespace() ? ns->get_android_ns() : nullptr; |
Zhenhua WANG | f2804e5 | 2016-05-30 11:16:08 +0800 | [diff] [blame] | 250 | } |
| 251 | |
| 252 | return nullptr; |
Dimitry Ivanov | f44ecde | 2016-02-22 13:48:22 -0800 | [diff] [blame] | 253 | } |
Jiyong Park | 6291da2 | 2019-04-26 18:55:48 +0900 | [diff] [blame^] | 254 | |
Victor Khimenko | 1443ec4 | 2018-07-09 17:01:22 +0200 | [diff] [blame] | 255 | NativeLoaderNamespace* FindNativeLoaderNamespaceByClassLoader(JNIEnv* env, jobject class_loader) { |
| 256 | std::lock_guard<std::mutex> guard(g_namespaces_mutex); |
| 257 | return g_namespaces->FindNamespaceByClassLoader(env, class_loader); |
| 258 | } |
Dimitry Ivanov | f44ecde | 2016-02-22 13:48:22 -0800 | [diff] [blame] | 259 | #endif |
| 260 | |
Jiyong Park | 6291da2 | 2019-04-26 18:55:48 +0900 | [diff] [blame^] | 261 | }; // namespace android |