loader.c

Go to the documentation of this file.

 
#include "common/infix_internals.h"
 
#if defined(INFIX_OS_WINDOWS)
#include <windows.h>
#else
#include <dlfcn.h>
#endif
 
c23_nodiscard infix_library_t * infix_library_open(const char * path) {
    if (path == nullptr)
        return nullptr;
 
    infix_library_t * lib = infix_calloc(1, sizeof(infix_library_t));
    if (lib == nullptr) {
        _infix_set_error(INFIX_CATEGORY_ALLOCATION, INFIX_CODE_OUT_OF_MEMORY, 0);
        return nullptr;
    }
 
#if defined(INFIX_OS_WINDOWS)
    lib->handle = LoadLibraryA(path);
#else
    // Use RTLD_LAZY for performance (resolve symbols only when they are first used).
    // Use RTLD_GLOBAL to make symbols from this library available for resolution
    // by other libraries that might be loaded later. This is important for complex
    // dependency chains.
    lib->handle = dlopen(path, RTLD_LAZY | RTLD_GLOBAL);
#endif
 
    if (lib->handle == nullptr) {
#if defined(INFIX_OS_WINDOWS)
        // On Windows, GetLastError() provides the specific error code.
        _infix_set_system_error(INFIX_CATEGORY_GENERAL, INFIX_CODE_LIBRARY_LOAD_FAILED, GetLastError(), nullptr);
#else
        // On POSIX, dlerror() returns a human-readable string.
        _infix_set_system_error(INFIX_CATEGORY_GENERAL, INFIX_CODE_LIBRARY_LOAD_FAILED, 0, dlerror());
#endif
        infix_free(lib);
        return nullptr;
    }
    return lib;
}
 
void infix_library_close(infix_library_t * lib) {
    if (lib == nullptr)
        return;
 
    if (lib->handle) {
#if defined(INFIX_OS_WINDOWS)
        FreeLibrary((HMODULE)lib->handle);
#else
        dlclose(lib->handle);
#endif
    }
    infix_free(lib);
}
 
c23_nodiscard void * infix_library_get_symbol(infix_library_t * lib, const char * symbol_name) {
    if (lib == nullptr || lib->handle == nullptr || symbol_name == nullptr)
        return nullptr;
 
#if defined(INFIX_OS_WINDOWS)
    return (void *)GetProcAddress((HMODULE)lib->handle, symbol_name);
#else
    return dlsym(lib->handle, symbol_name);
#endif
}
 
c23_nodiscard infix_status infix_read_global(infix_library_t * lib,
                                             const char * symbol_name,
                                             const char * type_signature,
                                             void * buffer,
                                             infix_registry_t * registry) {
    if (buffer == nullptr)
        return INFIX_ERROR_INVALID_ARGUMENT;
 
    void * symbol_addr = infix_library_get_symbol(lib, symbol_name);
    if (symbol_addr == nullptr) {
        _infix_set_error(INFIX_CATEGORY_GENERAL, INFIX_CODE_SYMBOL_NOT_FOUND, 0);
        return INFIX_ERROR_INVALID_ARGUMENT;
    }
 
    // Parse the signature to get the type's size.
    infix_type * type = nullptr;
    infix_arena_t * arena = nullptr;
    infix_status status = infix_type_from_signature(&type, &arena, type_signature, registry);
    if (status != INFIX_SUCCESS)
        return status;
 
    // Safely copy the data using the parsed size.
    infix_memcpy(buffer, symbol_addr, type->size);
 
    infix_arena_destroy(arena);
    return INFIX_SUCCESS;
}
 
c23_nodiscard infix_status infix_write_global(infix_library_t * lib,
                                              const char * symbol_name,
                                              const char * type_signature,
                                              void * buffer,
                                              infix_registry_t * registry) {
    if (buffer == nullptr)
        return INFIX_ERROR_INVALID_ARGUMENT;
 
    void * symbol_addr = infix_library_get_symbol(lib, symbol_name);
    if (symbol_addr == nullptr) {
        _infix_set_error(INFIX_CATEGORY_GENERAL, INFIX_CODE_SYMBOL_NOT_FOUND, 0);
        return INFIX_ERROR_INVALID_ARGUMENT;
    }
 
    infix_type * type = nullptr;
    infix_arena_t * arena = nullptr;
    infix_status status = infix_type_from_signature(&type, &arena, type_signature, registry);
    if (status != INFIX_SUCCESS)
        return status;
 
    // Note: This assumes the memory page containing the global is writable.
    // This is standard for data segments but could fail in unusual cases.
    infix_memcpy(symbol_addr, buffer, type->size);
 
    infix_arena_destroy(arena);
    return INFIX_SUCCESS;
}