urll.cpp

#include "urll.h"
#include <cstdio>

#ifdef _WIN32

// On Unix ::dlerror() only reports failures raised by the loader API itself and clears the error
// when it's read. GetLastError() is process-wide state that any unrelated Win32 call can
// overwrite, so instead of reading it directly in dlerror() we record it here, at the point where
// an URLL operation actually fails. Both are thread_local, matching glibc's thread-local
// ::dlerror() and making the buffer returned by dlerror() free of data races.
thread_local static DWORD urllLastError = 0;
thread_local static char urllErrorBuffer[512];

// Win32 functions only guarantee a meaningful last-error value after a failure, hence the
// fallback for the rare case where a function fails without setting one
static void recordLastError(const DWORD fallback) noexcept
{
    const DWORD id = GetLastError();
    urllLastError = (id == 0 ? fallback : id);
}

#endif

void* URLL::dlopen(const char* location) noexcept
{
    // Due to restrictions from Windows libraries are always loaded in lazy mode!
#ifdef _WIN32
    // Emulates the Unix behaviour of dlopen(nullptr), which returns a handle to the main program.
    // Unlike LoadLibrary, GetModuleHandle doesn't increment the module's reference count, which is
    // why dlclose has to skip it
    if (location == nullptr)
    {
        void* handle = (void*)GetModuleHandleA(nullptr);
        if (handle == nullptr)
            recordLastError(ERROR_MOD_NOT_FOUND);
        return handle;
    }

    // LoadLibraryA instead of LoadLibrary, since the TCHAR-generic macro resolves to the wide
    // version in UNICODE builds, which doesn't accept our char* argument
    SetLastError(0);
    void* handle = (void*)LoadLibraryA(location);
    if (handle == nullptr)
        recordLastError(ERROR_MOD_NOT_FOUND);
    return handle;
#else
    return ::dlopen(location, RTLD_LAZY);
#endif
}

void* URLL::dlsym(void* handle, const char* name) noexcept
{
#ifdef _WIN32
    SetLastError(0);
    // The cast is required because GetProcAddress returns a function pointer, which doesn't
    // implicitly convert to void* outside of Microsoft's extensions
    void* ret = (void*)GetProcAddress((HMODULE)handle, name);
    if (ret == nullptr)
        recordLastError(ERROR_PROC_NOT_FOUND);
    return ret;
#else
    return ::dlsym(handle, name);
#endif
}

int URLL::dlclose(void* handle) noexcept
{
#ifdef _WIN32
    // The main program handle handed out by dlopen(nullptr) was never reference counted, so
    // releasing it would decrement a count we never incremented. A caller that instead loaded the
    // executable by path gets that same handle back with its count incremented, and leaks the one
    // reference here, which costs nothing given the main image is never unloaded anyway
    if (handle == (void*)GetModuleHandleA(nullptr))
        return 0;

    SetLastError(0);
    if (FreeLibrary((HMODULE)handle) == 0)
    {
        recordLastError(ERROR_INVALID_HANDLE);
        return -1;
    }
    return 0;
#else
    return ::dlclose(handle);
#endif
}

char* URLL::dlerror() noexcept
{
#ifdef _WIN32
    const DWORD id = urllLastError;
    if (id == 0)
        return nullptr;
    // Unix clears the error once it has been read
    urllLastError = 0;

    // FormatMessageA instead of FormatMessage, since the TCHAR-generic macro resolves to the wide
    // version in UNICODE builds and would fill our char* buffer with UTF-16 data. The language is
    // left at 0 so the system walks its own fallback order, instead of failing outright whenever
    // the message table happens to lack one specific language
    DWORD len = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, nullptr, id, 0, urllErrorBuffer, sizeof(urllErrorBuffer), nullptr);

    // System messages come terminated with a CRLF, which would break the line of every log
    // message that embeds the error
    while (len > 0 && (urllErrorBuffer[len - 1] == '\r' || urllErrorBuffer[len - 1] == '\n'))
        --len;
    urllErrorBuffer[len] = '\0';

    // Losing the error entirely because the system has no message for it is worse than an
    // ugly message
    if (len == 0)
        std::snprintf(urllErrorBuffer, sizeof(urllErrorBuffer), "Unknown error %lu", static_cast<unsigned long>(id));

    return urllErrorBuffer;
#else
    return ::dlerror();
#endif
}