loader.c

Go to the documentation of this file.

 
#include "common/infix_internals.h"
 
// Platform-specific headers for dynamic library handling.
#if defined(INFIX_OS_WINDOWS)
#include <windows.h>
#else
#include <dlfcn.h>
#endif
 
struct infix_library_t {
    void * handle;
};
 
c23_nodiscard infix_library_t * infix_library_open(const char * path) {
    if (path == nullptr)
        return nullptr;
 
    // Allocate memory for our opaque wrapper struct.
    infix_library_t * lib = infix_malloc(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)
    // On Windows, use LoadLibraryA to load the DLL.
    // 'A' specifies the ANSI version, which matches the `const char*` input.
    lib->handle = LoadLibraryA(path);
#else
    // On POSIX systems, use dlopen.
    // - RTLD_LAZY: Resolves symbols only when they are first used (lazy binding),
    //   which can improve startup performance.
    // - RTLD_GLOBAL: Makes symbols from this library available for resolution
    //   by subsequently loaded libraries. This is important for handling
    //   complex dependencies between shared objects.
    lib->handle = dlopen(path, RTLD_LAZY | RTLD_GLOBAL);
#endif
 
    // Both LoadLibraryA and dlopen return NULL on failure.
    if (lib->handle == nullptr) {
#if defined(INFIX_OS_WINDOWS)
        _infix_set_system_error(INFIX_CATEGORY_GENERAL, INFIX_CODE_LIBRARY_LOAD_FAILED, GetLastError(), nullptr);
#else
        _infix_set_system_error(INFIX_CATEGORY_GENERAL, INFIX_CODE_LIBRARY_LOAD_FAILED, 0, dlerror());
#endif
        // If the OS call failed, we must free the wrapper struct we allocated
        // to prevent a memory leak.
        infix_free(lib);
        return nullptr;
    }
    return lib;
}
 
void infix_library_close(infix_library_t * lib) {
    if (lib == nullptr)
        return;
 
    // Only attempt to unload if the native handle is valid.
    if (lib->handle) {
#if defined(INFIX_OS_WINDOWS)
        // On Windows, FreeLibrary decrements the library's reference count.
        // The DLL is unloaded when its reference count reaches zero.
        FreeLibrary((HMODULE)lib->handle);
#else
        // On POSIX, dlclose does the same.
        dlclose(lib->handle);
#endif
    }
    // Finally, free our wrapper struct.
    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)
    // On Windows, use GetProcAddress. The return type is technically FARPROC,
    // which must be cast to a generic `void*` for our cross-platform API.
    return (void *)GetProcAddress((HMODULE)lib->handle, symbol_name);
#else
    // On POSIX, use dlsym. It directly returns a `void*`.
    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) {
    if (buffer == nullptr)
        return INFIX_ERROR_INVALID_ARGUMENT;
 
    // Find the address of the global variable in the library.
    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 type signature to determine the size of the variable.
    // This creates a temporary arena to hold the type information.
    infix_type * type = nullptr;
    infix_arena_t * arena = nullptr;
    infix_status status = infix_type_from_signature(&type, &arena, type_signature, nullptr);
 
    if (status != INFIX_SUCCESS)
        return status;
 
    // Perform a memory copy of the correct size.
    infix_memcpy(buffer, symbol_addr, type->size);
 
    // Clean up the temporary arena used for parsing.
    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) {
    if (buffer == nullptr)
        return INFIX_ERROR_INVALID_ARGUMENT;
 
    // Find the address of the global variable in the library.
    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 type signature to determine the size of the variable.
    infix_type * type = nullptr;
    infix_arena_t * arena = nullptr;
    infix_status status = infix_type_from_signature(&type, &arena, type_signature, nullptr);
 
    if (status != INFIX_SUCCESS)
        return status;
 
    // Perform a memory copy of the correct size.
    infix_memcpy(symbol_addr, buffer, type->size);
 
    // Clean up the temporary arena used for parsing.
    infix_arena_destroy(arena);
    return INFIX_SUCCESS;
}