Home /Modules/os-level-support/native_loader.c

native_loader.c

os-level-support/loader/native_loader.c · 194 line(s) · c

#include "native_loader.h"

#include <string.h>

#ifdef _WIN32
#  define WIN32_LEAN_AND_MEAN
#  include <windows.h>
static const char *loader_error = "no Windows loader error";
#else
#  include <dlfcn.h>
#endif

static void *open_library(const char *path) {
#ifdef _WIN32
    HMODULE handle = LoadLibraryA(path);
    if (!handle) loader_error = "LoadLibraryA failed";
    return (void *)handle;
#else
    dlerror();
    return dlopen(path, RTLD_NOW | RTLD_LOCAL);
#endif
}

static void close_library(void *handle) {
    if (!handle) return;
#ifdef _WIN32
    FreeLibrary((HMODULE)handle);
#else
    dlclose(handle);
#endif
}

static void *find_symbol(void *handle, const char *name) {
#ifdef _WIN32
    return (void *)(uintptr_t)GetProcAddress((HMODULE)handle, name);
#else
    dlerror();
    return dlsym(handle, name);
#endif
}

static int value_valid(const SLNativeValue *value) {
    if (!value || value->reserved != 0) return 0;
    switch ((SLNativeValueTag)value->tag) {
    case SL_NATIVE_VALUE_NULL: return 1;
    case SL_NATIVE_VALUE_BOOL: return value->as.boolean == 0 || value->as.boolean == 1;
    case SL_NATIVE_VALUE_I64: return 1;
    case SL_NATIVE_VALUE_F64: return 1;
    case SL_NATIVE_VALUE_UTF8:
        return value->as.utf8.length == 0 || value->as.utf8.data != NULL;
    default: return 0;
    }
}

const char *sl_native_loader_error(void) {
#ifdef _WIN32
    return loader_error;
#else
    const char *error = dlerror();
    return error ? error : "no dynamic-loader error";
#endif
}

const char *sl_native_status_string(SLNativeStatus status) {
    switch (status) {
    case SL_NATIVE_OK: return "ok";
    case SL_NATIVE_INVALID_ARGUMENT: return "invalid argument or module state";
    case SL_NATIVE_LOAD_ERROR: return "could not load shared library";
    case SL_NATIVE_ABI_MISMATCH: return "native module ABI version mismatch";
    case SL_NATIVE_ENTRY_NOT_FOUND: return "required module entry point not found";
    case SL_NATIVE_AUTHORIZATION_DENIED: return "native module path was not authorized by host policy";
    case SL_NATIVE_TABLE_FULL: return "native module handle table is full";
    case SL_NATIVE_STALE_HANDLE: return "native module handle is stale or invalid";
    case SL_NATIVE_TYPED_ENTRY_NOT_FOUND: return "native module does not export the typed-call entry";
    case SL_NATIVE_PLUGIN_ERROR: return "native plugin method returned an error or invalid value";
    case SL_NATIVE_METHOD_NOT_HANDLED: return "native plugin does not implement the requested method";
    case SL_NATIVE_HOST_CALLBACK_NOT_FOUND: return "native plugin does not accept host callbacks";
    case SL_NATIVE_REENTRANT_CALL: return "native-module API re-entry from a host callback is not allowed";
    case SL_NATIVE_JAVA_INDEX_OUT_OF_BOUNDS: return "java.lang.StringIndexOutOfBoundsException";
    case SL_NATIVE_JAVA_MALFORMED_TEXT: return "java.lang.IllegalArgumentException: malformed UTF-8 at the SLeeLa String boundary";
    case SL_NATIVE_JAVA_INVALID_ARGUMENT: return "java.lang.IllegalArgumentException: invalid String operation arguments";
    default: return "unknown native-loader status";
    }
}

SLNativeStatus sl_native_open(SLNativeModule *module, const char *path) {
    SLNativeAbiVersion abi;
    SLNativeEntry entry;
    void *symbol;
    void *handle;

    if (!module || !path || !*path || module->handle || module->run)
        return SL_NATIVE_INVALID_ARGUMENT;

    handle = open_library(path);
    if (!handle) return SL_NATIVE_LOAD_ERROR;

    symbol = find_symbol(handle, "sl_native_abi_version");
    if (!symbol) {
        close_library(handle);
        return SL_NATIVE_ENTRY_NOT_FOUND;
    }
    memcpy(&abi, &symbol, sizeof(abi));

    symbol = find_symbol(handle, "sl_native_run");
    if (!symbol) {
        close_library(handle);
        return SL_NATIVE_ENTRY_NOT_FOUND;
    }
    memcpy(&entry, &symbol, sizeof(entry));

    if (abi() != SL_NATIVE_ABI_VERSION) {
        close_library(handle);
        return SL_NATIVE_ABI_MISMATCH;
    }

    module->handle = handle;
    module->run = entry;
    return SL_NATIVE_OK;
}

SLNativeStatus sl_native_run_module(SLNativeModule *module, int argc,
                                    const char *const argv[], int *out_result) {
    int i;
    if (!module || !module->handle || !module->run || argc < 0 ||
        (argc > 0 && !argv) || !out_result)
        return SL_NATIVE_INVALID_ARGUMENT;
    for (i = 0; i < argc; ++i) {
        if (!argv[i]) return SL_NATIVE_INVALID_ARGUMENT;
    }
    *out_result = module->run(argc, argv);
    return SL_NATIVE_OK;
}

SLNativeStatus sl_native_call_module(SLNativeModule *module, const char *method,
                                     uint32_t argc, const SLNativeValue *argv,
                                     SLNativeValue *out_result) {
    uint32_t i;
    int plugin_status;
    SLNativeValue result;
    SLNativeTypedCall typed_call;
    SLNativeTypedAbiVersion typed_abi;
    void *symbol;
    if (!module || !module->handle || !method || !*method ||
        (argc > 0 && !argv) || !out_result)
        return SL_NATIVE_INVALID_ARGUMENT;
    symbol = find_symbol(module->handle, "sl_native_call");
    if (!symbol) return SL_NATIVE_TYPED_ENTRY_NOT_FOUND;
    memcpy(&typed_call, &symbol, sizeof(typed_call));
    symbol = find_symbol(module->handle, "sl_native_typed_abi_version");
    if (!symbol) return SL_NATIVE_ABI_MISMATCH;
    memcpy(&typed_abi, &symbol, sizeof(typed_abi));
    if (typed_abi() != SL_NATIVE_TYPED_ABI_VERSION)
        return SL_NATIVE_ABI_MISMATCH;
    for (i = 0; i < argc; ++i)
        if (!value_valid(&argv[i])) return SL_NATIVE_INVALID_ARGUMENT;
    memset(&result, 0, sizeof(result));
    result.tag = SL_NATIVE_VALUE_NULL;
    plugin_status = typed_call(method, argc, argv, &result);
    if (plugin_status == SL_NATIVE_CALL_NOT_HANDLED)
        return SL_NATIVE_METHOD_NOT_HANDLED;
    if (plugin_status == SL_NATIVE_CALL_INDEX_OUT_OF_BOUNDS)
        return SL_NATIVE_JAVA_INDEX_OUT_OF_BOUNDS;
    if (plugin_status == SL_NATIVE_CALL_MALFORMED_TEXT)
        return SL_NATIVE_JAVA_MALFORMED_TEXT;
    if (plugin_status == SL_NATIVE_CALL_INVALID_ARGUMENT)
        return SL_NATIVE_JAVA_INVALID_ARGUMENT;
    if (plugin_status != SL_NATIVE_CALL_OK) return SL_NATIVE_PLUGIN_ERROR;
    if (!value_valid(&result)) return SL_NATIVE_PLUGIN_ERROR;
    *out_result = result;
    return SL_NATIVE_OK;
}

SLNativeStatus sl_native_bind_host_api(SLNativeModule *module,
                                       const SLNativeHostAPI *host_api) {
    SLNativeBindHost bind_host;
    void *symbol;
    if (!module || !module->handle || !host_api ||
        host_api->abi_version != SL_NATIVE_HOST_CALLBACK_ABI_VERSION ||
        host_api->struct_size < sizeof(SLNativeHostAPI) || !host_api->invoke)
        return SL_NATIVE_INVALID_ARGUMENT;
    symbol = find_symbol(module->handle, "sl_native_bind_host");
    if (!symbol) return SL_NATIVE_HOST_CALLBACK_NOT_FOUND;
    memcpy(&bind_host, &symbol, sizeof(bind_host));
    return bind_host(host_api) == 0 ? SL_NATIVE_OK : SL_NATIVE_PLUGIN_ERROR;
}

SLNativeStatus sl_native_close(SLNativeModule *module) {
    if (!module) return SL_NATIVE_INVALID_ARGUMENT;
    if (module->handle) close_library(module->handle);
    memset(module, 0, sizeof(*module));
    return SL_NATIVE_OK;
}