716 lines
24 KiB
C++
716 lines
24 KiB
C++
/*
|
|
* Copyright (C) 2014 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#define LOG_TAG "nativebridge"
|
|
|
|
#include "nativebridge/native_bridge.h"
|
|
|
|
#include <dlfcn.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <stdio.h>
|
|
#include <sys/mount.h>
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
|
|
#include <cstring>
|
|
|
|
#include <android-base/macros.h>
|
|
#include <log/log.h>
|
|
|
|
#ifdef ART_TARGET_ANDROID
|
|
#include "nativeloader/dlext_namespaces.h"
|
|
#endif
|
|
|
|
namespace android {
|
|
|
|
#ifdef __APPLE__
|
|
template <typename T>
|
|
void UNUSED(const T&) {}
|
|
#endif
|
|
|
|
extern "C" {
|
|
|
|
void* OpenSystemLibrary(const char* path, int flags) {
|
|
#ifdef ART_TARGET_ANDROID
|
|
// The system namespace is called "default" for binaries in /system and
|
|
// "system" for those in the Runtime APEX. Try "system" first since
|
|
// "default" always exists.
|
|
// TODO(b/185587109): Get rid of this error prone logic.
|
|
android_namespace_t* system_ns = android_get_exported_namespace("system");
|
|
if (system_ns == nullptr) {
|
|
system_ns = android_get_exported_namespace("default");
|
|
LOG_ALWAYS_FATAL_IF(system_ns == nullptr,
|
|
"Failed to get system namespace for loading %s", path);
|
|
}
|
|
const android_dlextinfo dlextinfo = {
|
|
.flags = ANDROID_DLEXT_USE_NAMESPACE,
|
|
.library_namespace = system_ns,
|
|
};
|
|
return android_dlopen_ext(path, flags, &dlextinfo);
|
|
#else
|
|
return dlopen(path, flags);
|
|
#endif
|
|
}
|
|
|
|
// Environment values required by the apps running with native bridge.
|
|
struct NativeBridgeRuntimeValues {
|
|
const char* os_arch;
|
|
const char* cpu_abi;
|
|
const char* cpu_abi2;
|
|
const char* *supported_abis;
|
|
int32_t abi_count;
|
|
};
|
|
|
|
// The symbol name exposed by native-bridge with the type of NativeBridgeCallbacks.
|
|
static constexpr const char* kNativeBridgeInterfaceSymbol = "NativeBridgeItf";
|
|
|
|
enum class NativeBridgeState {
|
|
kNotSetup, // Initial state.
|
|
kOpened, // After successful dlopen.
|
|
kPreInitialized, // After successful pre-initialization.
|
|
kInitialized, // After successful initialization.
|
|
kClosed // Closed or errors.
|
|
};
|
|
|
|
static constexpr const char* kNotSetupString = "kNotSetup";
|
|
static constexpr const char* kOpenedString = "kOpened";
|
|
static constexpr const char* kPreInitializedString = "kPreInitialized";
|
|
static constexpr const char* kInitializedString = "kInitialized";
|
|
static constexpr const char* kClosedString = "kClosed";
|
|
|
|
static const char* GetNativeBridgeStateString(NativeBridgeState state) {
|
|
switch (state) {
|
|
case NativeBridgeState::kNotSetup:
|
|
return kNotSetupString;
|
|
|
|
case NativeBridgeState::kOpened:
|
|
return kOpenedString;
|
|
|
|
case NativeBridgeState::kPreInitialized:
|
|
return kPreInitializedString;
|
|
|
|
case NativeBridgeState::kInitialized:
|
|
return kInitializedString;
|
|
|
|
case NativeBridgeState::kClosed:
|
|
return kClosedString;
|
|
}
|
|
}
|
|
|
|
// Current state of the native bridge.
|
|
static NativeBridgeState state = NativeBridgeState::kNotSetup;
|
|
|
|
// The version of NativeBridge implementation.
|
|
// Different Nativebridge interface needs the service of different version of
|
|
// Nativebridge implementation.
|
|
// Used by isCompatibleWith() which is introduced in v2.
|
|
enum NativeBridgeImplementationVersion {
|
|
// first version, not used.
|
|
DEFAULT_VERSION = 1,
|
|
// The version which signal semantic is introduced.
|
|
SIGNAL_VERSION = 2,
|
|
// The version which namespace semantic is introduced.
|
|
NAMESPACE_VERSION = 3,
|
|
// The version with vendor namespaces
|
|
VENDOR_NAMESPACE_VERSION = 4,
|
|
// The version with runtime namespaces
|
|
RUNTIME_NAMESPACE_VERSION = 5,
|
|
// The version with pre-zygote-fork hook to support app-zygotes.
|
|
PRE_ZYGOTE_FORK_VERSION = 6,
|
|
};
|
|
|
|
// Whether we had an error at some point.
|
|
static bool had_error = false;
|
|
|
|
// Handle of the loaded library.
|
|
static void* native_bridge_handle = nullptr;
|
|
// Pointer to the callbacks. Available as soon as LoadNativeBridge succeeds, but only initialized
|
|
// later.
|
|
static const NativeBridgeCallbacks* callbacks = nullptr;
|
|
// Callbacks provided by the environment to the bridge. Passed to LoadNativeBridge.
|
|
static const NativeBridgeRuntimeCallbacks* runtime_callbacks = nullptr;
|
|
|
|
// The app's code cache directory.
|
|
static char* app_code_cache_dir = nullptr;
|
|
|
|
// Code cache directory (relative to the application private directory)
|
|
// Ideally we'd like to call into framework to retrieve this name. However that's considered an
|
|
// implementation detail and will require either hacks or consistent refactorings. We compromise
|
|
// and hard code the directory name again here.
|
|
static constexpr const char* kCodeCacheDir = "code_cache";
|
|
|
|
// Characters allowed in a native bridge filename. The first character must
|
|
// be in [a-zA-Z] (expected 'l' for "libx"). The rest must be in [a-zA-Z0-9._-].
|
|
static bool CharacterAllowed(char c, bool first) {
|
|
if (first) {
|
|
return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z');
|
|
} else {
|
|
return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || ('0' <= c && c <= '9') ||
|
|
(c == '.') || (c == '_') || (c == '-');
|
|
}
|
|
}
|
|
|
|
static void ReleaseAppCodeCacheDir() {
|
|
if (app_code_cache_dir != nullptr) {
|
|
delete[] app_code_cache_dir;
|
|
app_code_cache_dir = nullptr;
|
|
}
|
|
}
|
|
|
|
// We only allow simple names for the library. It is supposed to be a file in
|
|
// /system/lib or /vendor/lib. Only allow a small range of characters, that is
|
|
// names consisting of [a-zA-Z0-9._-] and starting with [a-zA-Z].
|
|
bool NativeBridgeNameAcceptable(const char* nb_library_filename) {
|
|
const char* ptr = nb_library_filename;
|
|
if (*ptr == 0) {
|
|
// Emptry string. Allowed, means no native bridge.
|
|
return true;
|
|
} else {
|
|
// First character must be [a-zA-Z].
|
|
if (!CharacterAllowed(*ptr, true)) {
|
|
// Found an invalid fist character, don't accept.
|
|
ALOGE("Native bridge library %s has been rejected for first character %c",
|
|
nb_library_filename,
|
|
*ptr);
|
|
return false;
|
|
} else {
|
|
// For the rest, be more liberal.
|
|
ptr++;
|
|
while (*ptr != 0) {
|
|
if (!CharacterAllowed(*ptr, false)) {
|
|
// Found an invalid character, don't accept.
|
|
ALOGE("Native bridge library %s has been rejected for %c", nb_library_filename, *ptr);
|
|
return false;
|
|
}
|
|
ptr++;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// The policy of invoking Nativebridge changed in v3 with/without namespace.
|
|
// Suggest Nativebridge implementation not maintain backward-compatible.
|
|
static bool isCompatibleWith(const uint32_t version) {
|
|
// Libnativebridge is now designed to be forward-compatible. So only "0" is an unsupported
|
|
// version.
|
|
if (callbacks == nullptr || callbacks->version == 0 || version == 0) {
|
|
return false;
|
|
}
|
|
|
|
// If this is a v2+ bridge, it may not be forwards- or backwards-compatible. Check.
|
|
if (callbacks->version >= SIGNAL_VERSION) {
|
|
return callbacks->isCompatibleWith(version);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static void CloseNativeBridge(bool with_error) {
|
|
state = NativeBridgeState::kClosed;
|
|
had_error |= with_error;
|
|
ReleaseAppCodeCacheDir();
|
|
}
|
|
|
|
bool LoadNativeBridge(const char* nb_library_filename,
|
|
const NativeBridgeRuntimeCallbacks* runtime_cbs) {
|
|
// We expect only one place that calls LoadNativeBridge: Runtime::Init. At that point we are not
|
|
// multi-threaded, so we do not need locking here.
|
|
|
|
if (state != NativeBridgeState::kNotSetup) {
|
|
// Setup has been called before. Ignore this call.
|
|
if (nb_library_filename != nullptr) { // Avoids some log-spam for dalvikvm.
|
|
ALOGW("Called LoadNativeBridge for an already set up native bridge. State is %s.",
|
|
GetNativeBridgeStateString(state));
|
|
}
|
|
// Note: counts as an error, even though the bridge may be functional.
|
|
had_error = true;
|
|
return false;
|
|
}
|
|
|
|
if (nb_library_filename == nullptr || *nb_library_filename == 0) {
|
|
CloseNativeBridge(false);
|
|
return false;
|
|
} else {
|
|
if (!NativeBridgeNameAcceptable(nb_library_filename)) {
|
|
CloseNativeBridge(true);
|
|
} else {
|
|
// Try to open the library. We assume this library is provided by the
|
|
// platform rather than the ART APEX itself, so use the system namespace
|
|
// to avoid requiring a static linker config link to it from the
|
|
// com_android_art namespace.
|
|
void* handle = OpenSystemLibrary(nb_library_filename, RTLD_LAZY);
|
|
|
|
if (handle != nullptr) {
|
|
callbacks = reinterpret_cast<NativeBridgeCallbacks*>(dlsym(handle,
|
|
kNativeBridgeInterfaceSymbol));
|
|
if (callbacks != nullptr) {
|
|
if (isCompatibleWith(NAMESPACE_VERSION)) {
|
|
// Store the handle for later.
|
|
native_bridge_handle = handle;
|
|
} else {
|
|
ALOGW("Unsupported native bridge API in %s (is version %d not compatible with %d)",
|
|
nb_library_filename, callbacks->version, NAMESPACE_VERSION);
|
|
callbacks = nullptr;
|
|
dlclose(handle);
|
|
}
|
|
} else {
|
|
dlclose(handle);
|
|
ALOGW("Unsupported native bridge API in %s: %s not found",
|
|
nb_library_filename, kNativeBridgeInterfaceSymbol);
|
|
}
|
|
} else {
|
|
ALOGW("Failed to load native bridge implementation: %s", dlerror());
|
|
}
|
|
|
|
// Two failure conditions: could not find library (dlopen failed), or could not find native
|
|
// bridge interface (dlsym failed). Both are an error and close the native bridge.
|
|
if (callbacks == nullptr) {
|
|
CloseNativeBridge(true);
|
|
} else {
|
|
runtime_callbacks = runtime_cbs;
|
|
state = NativeBridgeState::kOpened;
|
|
}
|
|
}
|
|
return state == NativeBridgeState::kOpened;
|
|
}
|
|
}
|
|
|
|
bool NeedsNativeBridge(const char* instruction_set) {
|
|
if (instruction_set == nullptr) {
|
|
ALOGE("Null instruction set in NeedsNativeBridge.");
|
|
return false;
|
|
}
|
|
return strncmp(instruction_set, ABI_STRING, strlen(ABI_STRING) + 1) != 0;
|
|
}
|
|
|
|
#ifndef __APPLE__
|
|
static bool MountCpuinfo(const char* cpuinfo_path) {
|
|
// If the file does not exist, the mount command will fail,
|
|
// so we save the extra file existence check.
|
|
if (TEMP_FAILURE_RETRY(mount(cpuinfo_path, // Source.
|
|
"/proc/cpuinfo", // Target.
|
|
nullptr, // FS type.
|
|
MS_BIND, // Mount flags: bind mount.
|
|
nullptr)) == -1) { // "Data."
|
|
ALOGW("Failed to bind-mount %s as /proc/cpuinfo: %s", cpuinfo_path, strerror(errno));
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
static void MountCpuinfoForInstructionSet(const char* instruction_set) {
|
|
if (instruction_set == nullptr) {
|
|
return;
|
|
}
|
|
|
|
size_t isa_len = strlen(instruction_set);
|
|
if (isa_len > 10) {
|
|
// 10 is a loose upper bound on the currently known instruction sets (a tight bound is 7 for
|
|
// x86_64 [including the trailing \0]). This is so we don't have to change here if there will
|
|
// be another instruction set in the future.
|
|
ALOGW("Instruction set %s is malformed, must be less than or equal to 10 characters.",
|
|
instruction_set);
|
|
return;
|
|
}
|
|
|
|
#if defined(__APPLE__)
|
|
ALOGW("Mac OS does not support bind-mounting. Host simulation of native bridge impossible.");
|
|
|
|
#elif !defined(__ANDROID__)
|
|
// To be able to test on the host, we hardwire a relative path.
|
|
MountCpuinfo("./cpuinfo");
|
|
|
|
#else // __ANDROID__
|
|
char cpuinfo_path[1024];
|
|
|
|
// Bind-mount /system/etc/cpuinfo.<isa>.txt to /proc/cpuinfo.
|
|
snprintf(cpuinfo_path, sizeof(cpuinfo_path), "/system/etc/cpuinfo.%s.txt", instruction_set);
|
|
if (MountCpuinfo(cpuinfo_path)) {
|
|
return;
|
|
}
|
|
|
|
// Bind-mount /system/lib{,64}/<isa>/cpuinfo to /proc/cpuinfo.
|
|
// TODO(b/179753190): remove when all implementations migrate to system/etc!
|
|
#ifdef __LP64__
|
|
snprintf(cpuinfo_path, sizeof(cpuinfo_path), "/system/lib64/%s/cpuinfo", instruction_set);
|
|
#else
|
|
snprintf(cpuinfo_path, sizeof(cpuinfo_path), "/system/lib/%s/cpuinfo", instruction_set);
|
|
#endif // __LP64__
|
|
MountCpuinfo(cpuinfo_path);
|
|
|
|
#endif
|
|
}
|
|
|
|
bool PreInitializeNativeBridge(const char* app_data_dir_in, const char* instruction_set) {
|
|
if (state != NativeBridgeState::kOpened) {
|
|
ALOGE("Invalid state: native bridge is expected to be opened.");
|
|
CloseNativeBridge(true);
|
|
return false;
|
|
}
|
|
|
|
if (app_data_dir_in != nullptr) {
|
|
// Create the path to the application code cache directory.
|
|
// The memory will be release after Initialization or when the native bridge is closed.
|
|
const size_t len = strlen(app_data_dir_in) + strlen(kCodeCacheDir) + 2; // '\0' + '/'
|
|
app_code_cache_dir = new char[len];
|
|
snprintf(app_code_cache_dir, len, "%s/%s", app_data_dir_in, kCodeCacheDir);
|
|
} else {
|
|
ALOGW("Application private directory isn't available.");
|
|
app_code_cache_dir = nullptr;
|
|
}
|
|
|
|
// Mount cpuinfo that corresponds to the instruction set.
|
|
// Failure is not fatal.
|
|
MountCpuinfoForInstructionSet(instruction_set);
|
|
|
|
state = NativeBridgeState::kPreInitialized;
|
|
return true;
|
|
}
|
|
|
|
void PreZygoteForkNativeBridge() {
|
|
if (NativeBridgeInitialized()) {
|
|
if (isCompatibleWith(PRE_ZYGOTE_FORK_VERSION)) {
|
|
return callbacks->preZygoteFork();
|
|
} else {
|
|
ALOGE("not compatible with version %d, preZygoteFork() isn't invoked",
|
|
PRE_ZYGOTE_FORK_VERSION);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void SetCpuAbi(JNIEnv* env, jclass build_class, const char* field, const char* value) {
|
|
if (value != nullptr) {
|
|
jfieldID field_id = env->GetStaticFieldID(build_class, field, "Ljava/lang/String;");
|
|
if (field_id == nullptr) {
|
|
env->ExceptionClear();
|
|
ALOGW("Could not find %s field.", field);
|
|
return;
|
|
}
|
|
|
|
jstring str = env->NewStringUTF(value);
|
|
if (str == nullptr) {
|
|
env->ExceptionClear();
|
|
ALOGW("Could not create string %s.", value);
|
|
return;
|
|
}
|
|
|
|
env->SetStaticObjectField(build_class, field_id, str);
|
|
}
|
|
}
|
|
|
|
// Set up the environment for the bridged app.
|
|
static void SetupEnvironment(const NativeBridgeCallbacks* cbs, JNIEnv* env, const char* isa) {
|
|
// Need a JNIEnv* to do anything.
|
|
if (env == nullptr) {
|
|
ALOGW("No JNIEnv* to set up app environment.");
|
|
return;
|
|
}
|
|
|
|
// Query the bridge for environment values.
|
|
const struct NativeBridgeRuntimeValues* env_values = cbs->getAppEnv(isa);
|
|
if (env_values == nullptr) {
|
|
return;
|
|
}
|
|
|
|
// Keep the JNIEnv clean.
|
|
jint success = env->PushLocalFrame(16); // That should be small and large enough.
|
|
if (success < 0) {
|
|
// Out of memory, really borked.
|
|
ALOGW("Out of memory while setting up app environment.");
|
|
env->ExceptionClear();
|
|
return;
|
|
}
|
|
|
|
// Reset CPU_ABI & CPU_ABI2 to values required by the apps running with native bridge.
|
|
if (env_values->cpu_abi != nullptr || env_values->cpu_abi2 != nullptr ||
|
|
env_values->abi_count >= 0) {
|
|
jclass bclass_id = env->FindClass("android/os/Build");
|
|
if (bclass_id != nullptr) {
|
|
SetCpuAbi(env, bclass_id, "CPU_ABI", env_values->cpu_abi);
|
|
SetCpuAbi(env, bclass_id, "CPU_ABI2", env_values->cpu_abi2);
|
|
} else {
|
|
// For example in a host test environment.
|
|
env->ExceptionClear();
|
|
ALOGW("Could not find Build class.");
|
|
}
|
|
}
|
|
|
|
if (env_values->os_arch != nullptr) {
|
|
jclass sclass_id = env->FindClass("java/lang/System");
|
|
if (sclass_id != nullptr) {
|
|
jmethodID set_prop_id = env->GetStaticMethodID(sclass_id, "setUnchangeableSystemProperty",
|
|
"(Ljava/lang/String;Ljava/lang/String;)V");
|
|
if (set_prop_id != nullptr) {
|
|
// Init os.arch to the value reqired by the apps running with native bridge.
|
|
env->CallStaticVoidMethod(sclass_id, set_prop_id, env->NewStringUTF("os.arch"),
|
|
env->NewStringUTF(env_values->os_arch));
|
|
} else {
|
|
env->ExceptionClear();
|
|
ALOGW("Could not find System#setUnchangeableSystemProperty.");
|
|
}
|
|
} else {
|
|
env->ExceptionClear();
|
|
ALOGW("Could not find System class.");
|
|
}
|
|
}
|
|
|
|
// Make it pristine again.
|
|
env->PopLocalFrame(nullptr);
|
|
}
|
|
|
|
bool InitializeNativeBridge(JNIEnv* env, const char* instruction_set) {
|
|
// We expect only one place that calls InitializeNativeBridge: Runtime::DidForkFromZygote. At that
|
|
// point we are not multi-threaded, so we do not need locking here.
|
|
|
|
if (state == NativeBridgeState::kPreInitialized) {
|
|
if (app_code_cache_dir != nullptr) {
|
|
// Check for code cache: if it doesn't exist try to create it.
|
|
struct stat st;
|
|
if (stat(app_code_cache_dir, &st) == -1) {
|
|
if (errno == ENOENT) {
|
|
if (mkdir(app_code_cache_dir, S_IRWXU | S_IRWXG | S_IXOTH) == -1) {
|
|
ALOGW("Cannot create code cache directory %s: %s.",
|
|
app_code_cache_dir, strerror(errno));
|
|
ReleaseAppCodeCacheDir();
|
|
}
|
|
} else {
|
|
ALOGW("Cannot stat code cache directory %s: %s.",
|
|
app_code_cache_dir, strerror(errno));
|
|
ReleaseAppCodeCacheDir();
|
|
}
|
|
} else if (!S_ISDIR(st.st_mode)) {
|
|
ALOGW("Code cache is not a directory %s.", app_code_cache_dir);
|
|
ReleaseAppCodeCacheDir();
|
|
}
|
|
}
|
|
|
|
// If we're still PreInitialized (didn't fail the code cache checks) try to initialize.
|
|
if (state == NativeBridgeState::kPreInitialized) {
|
|
if (callbacks->initialize(runtime_callbacks, app_code_cache_dir, instruction_set)) {
|
|
SetupEnvironment(callbacks, env, instruction_set);
|
|
state = NativeBridgeState::kInitialized;
|
|
// We no longer need the code cache path, release the memory.
|
|
ReleaseAppCodeCacheDir();
|
|
} else {
|
|
// Unload the library.
|
|
dlclose(native_bridge_handle);
|
|
CloseNativeBridge(true);
|
|
}
|
|
}
|
|
} else {
|
|
CloseNativeBridge(true);
|
|
}
|
|
|
|
return state == NativeBridgeState::kInitialized;
|
|
}
|
|
|
|
void UnloadNativeBridge() {
|
|
// We expect only one place that calls UnloadNativeBridge: Runtime::DidForkFromZygote. At that
|
|
// point we are not multi-threaded, so we do not need locking here.
|
|
|
|
switch (state) {
|
|
case NativeBridgeState::kOpened:
|
|
case NativeBridgeState::kPreInitialized:
|
|
case NativeBridgeState::kInitialized:
|
|
// Unload.
|
|
dlclose(native_bridge_handle);
|
|
CloseNativeBridge(false);
|
|
break;
|
|
|
|
case NativeBridgeState::kNotSetup:
|
|
// Not even set up. Error.
|
|
CloseNativeBridge(true);
|
|
break;
|
|
|
|
case NativeBridgeState::kClosed:
|
|
// Ignore.
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool NativeBridgeError() {
|
|
return had_error;
|
|
}
|
|
|
|
bool NativeBridgeAvailable() {
|
|
return state == NativeBridgeState::kOpened
|
|
|| state == NativeBridgeState::kPreInitialized
|
|
|| state == NativeBridgeState::kInitialized;
|
|
}
|
|
|
|
bool NativeBridgeInitialized() {
|
|
// Calls of this are supposed to happen in a state where the native bridge is stable, i.e., after
|
|
// Runtime::DidForkFromZygote. In that case we do not need a lock.
|
|
return state == NativeBridgeState::kInitialized;
|
|
}
|
|
|
|
void* NativeBridgeLoadLibrary(const char* libpath, int flag) {
|
|
if (NativeBridgeInitialized()) {
|
|
return callbacks->loadLibrary(libpath, flag);
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void* NativeBridgeGetTrampoline(void* handle, const char* name, const char* shorty,
|
|
uint32_t len) {
|
|
if (NativeBridgeInitialized()) {
|
|
return callbacks->getTrampoline(handle, name, shorty, len);
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
bool NativeBridgeIsSupported(const char* libpath) {
|
|
if (NativeBridgeInitialized()) {
|
|
return callbacks->isSupported(libpath);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
uint32_t NativeBridgeGetVersion() {
|
|
if (NativeBridgeAvailable()) {
|
|
return callbacks->version;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
NativeBridgeSignalHandlerFn NativeBridgeGetSignalHandler(int signal) {
|
|
if (NativeBridgeInitialized()) {
|
|
if (isCompatibleWith(SIGNAL_VERSION)) {
|
|
return callbacks->getSignalHandler(signal);
|
|
} else {
|
|
ALOGE("not compatible with version %d, cannot get signal handler", SIGNAL_VERSION);
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
int NativeBridgeUnloadLibrary(void* handle) {
|
|
if (NativeBridgeInitialized()) {
|
|
if (isCompatibleWith(NAMESPACE_VERSION)) {
|
|
return callbacks->unloadLibrary(handle);
|
|
} else {
|
|
ALOGE("not compatible with version %d, cannot unload library", NAMESPACE_VERSION);
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
const char* NativeBridgeGetError() {
|
|
if (NativeBridgeInitialized()) {
|
|
if (isCompatibleWith(NAMESPACE_VERSION)) {
|
|
return callbacks->getError();
|
|
} else {
|
|
return "native bridge implementation is not compatible with version 3, cannot get message";
|
|
}
|
|
}
|
|
return "native bridge is not initialized";
|
|
}
|
|
|
|
bool NativeBridgeIsPathSupported(const char* path) {
|
|
if (NativeBridgeInitialized()) {
|
|
if (isCompatibleWith(NAMESPACE_VERSION)) {
|
|
return callbacks->isPathSupported(path);
|
|
} else {
|
|
ALOGE("not compatible with version %d, cannot check via library path", NAMESPACE_VERSION);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool NativeBridgeInitAnonymousNamespace(const char* public_ns_sonames,
|
|
const char* anon_ns_library_path) {
|
|
if (NativeBridgeInitialized()) {
|
|
if (isCompatibleWith(NAMESPACE_VERSION)) {
|
|
return callbacks->initAnonymousNamespace(public_ns_sonames, anon_ns_library_path);
|
|
} else {
|
|
ALOGE("not compatible with version %d, cannot init namespace", NAMESPACE_VERSION);
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
native_bridge_namespace_t* NativeBridgeCreateNamespace(const char* name,
|
|
const char* ld_library_path,
|
|
const char* default_library_path,
|
|
uint64_t type,
|
|
const char* permitted_when_isolated_path,
|
|
native_bridge_namespace_t* parent_ns) {
|
|
if (NativeBridgeInitialized()) {
|
|
if (isCompatibleWith(NAMESPACE_VERSION)) {
|
|
return callbacks->createNamespace(name,
|
|
ld_library_path,
|
|
default_library_path,
|
|
type,
|
|
permitted_when_isolated_path,
|
|
parent_ns);
|
|
} else {
|
|
ALOGE("not compatible with version %d, cannot create namespace %s", NAMESPACE_VERSION, name);
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
bool NativeBridgeLinkNamespaces(native_bridge_namespace_t* from, native_bridge_namespace_t* to,
|
|
const char* shared_libs_sonames) {
|
|
if (NativeBridgeInitialized()) {
|
|
if (isCompatibleWith(NAMESPACE_VERSION)) {
|
|
return callbacks->linkNamespaces(from, to, shared_libs_sonames);
|
|
} else {
|
|
ALOGE("not compatible with version %d, cannot init namespace", NAMESPACE_VERSION);
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
native_bridge_namespace_t* NativeBridgeGetExportedNamespace(const char* name) {
|
|
if (!NativeBridgeInitialized()) {
|
|
return nullptr;
|
|
}
|
|
|
|
if (isCompatibleWith(RUNTIME_NAMESPACE_VERSION)) {
|
|
return callbacks->getExportedNamespace(name);
|
|
}
|
|
|
|
// sphal is vendor namespace name -> use v4 callback in the case NB callbacks
|
|
// are not compatible with v5
|
|
if (isCompatibleWith(VENDOR_NAMESPACE_VERSION) && name != nullptr && strcmp("sphal", name) == 0) {
|
|
return callbacks->getVendorNamespace();
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
void* NativeBridgeLoadLibraryExt(const char* libpath, int flag, native_bridge_namespace_t* ns) {
|
|
if (NativeBridgeInitialized()) {
|
|
if (isCompatibleWith(NAMESPACE_VERSION)) {
|
|
return callbacks->loadLibraryExt(libpath, flag, ns);
|
|
} else {
|
|
ALOGE("not compatible with version %d, cannot load library in namespace", NAMESPACE_VERSION);
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
} // extern "C"
|
|
|
|
} // namespace android
|