fix emscripten, more windows security fixes, docs

Author: mbaetgen-wup

src/libprojectM/Renderer/PlatformGLResolver.cpp

@@ -16,8 +16,11 @@
 #include <cstring>
 #include <cstdint>
 #include <cstdio>
+
+#ifdef _WIN32
 #include <cstdlib>
 #include <limits>
+#endif
 
 #ifdef _WIN32
 #include <windows.h>
@@ -99,6 +102,8 @@ auto HasSpaceSeparatedToken(const char* list, const char* token) -> bool
     return false;
 }
 
+#ifndef __EMSCRIPTEN__
+
 /**
  * @brief Heuristically determines whether a name looks like an OpenGL-style extension symbol.
  *
@@ -140,17 +145,8 @@ auto IsLikelyExtensionName(const char* name) -> bool
     return false;
 }
 
-
-#ifndef __EMSCRIPTEN__
-
 /**
  * @brief Returns true if a GL/EGL symbol name is likely to be an extension entry point.
- *
- * Per EGL_KHR_get_all_proc_addresses (and its client variant), eglGetProcAddress
- * is not required to return addresses for non-extension EGL or client API functions
- * unless the extension is advertised. When the extension is not available, a
- * conservative policy is to query eglGetProcAddress only for extension-style
- * entry points (ARB/EXT/KHR/etc.), while resolving core symbols via direct exports.
  */
 auto ShouldUseEglGetProcAddressForName(const char* name) -> bool
 {
@@ -228,6 +224,7 @@ auto GLResolver::CheckGLRequirementsUnlocked() -> GLContextCheckResult
 
 auto GLResolver::Initialize(UserResolver resolver, void* userData) -> bool
 {
+
     // Prevent concurrent Initialize()
     std::unique_lock<std::mutex> lock(m_mutex);
 
@@ -382,11 +379,15 @@ auto GLResolver::GetProcAddress(const char* name) const -> void*
     // Only hold m_mutex while reading internal state.
     std::unique_lock<std::mutex> lock(m_mutex);
 
+    if (!m_loaded && !m_initializing)
+    {
+        LOG_ERROR(std::string("[GLResolver] GetProcAddress called without initialization."));
+        return nullptr;
+    }
+
     // Local state copy to use once the lock is released.
     const auto state = m_state;
 
-    const bool loaded = m_loaded;
-
     // Gate to detected backend.
     const auto currentContext = ProbeCurrentContext();
 
@@ -430,14 +431,7 @@ auto GLResolver::GetProcAddress(const char* name) const -> void*
             }
         break;
         default:
-            if (!loaded)
-            {
-                LOG_ERROR(std::string("[GLResolver] Backend is not initialized."));
-            }
-            else
-            {
-                LOG_ERROR(std::string("[GLResolver] Initialization did not choose a valid backend."));
-            }
+            LOG_ERROR(std::string("[GLResolver] Initialization did not choose a valid backend."));
         return nullptr;
     }
 
@@ -448,6 +442,8 @@ auto GLResolver::GetProcAddress(const char* name) const -> void*
         return resolved;
     }
 
+#ifndef __EMSCRIPTEN__
+
     lock.lock();
 
     // Global symbol table (works if the process already linked/loaded GL libs).
@@ -499,6 +495,7 @@ auto GLResolver::GetProcAddress(const char* name) const -> void*
             return FunctionToSymbol(proc);
         }
     }
+#endif
     return nullptr;
 }
 
@@ -671,7 +668,7 @@ void GLResolver::ResolveProviderFunctions()
         constexpr int kEglExtensions = 0x3055; // EGL_EXTENSIONS
         constexpr int kEglSuccess = 0x3000; // EGL_SUCCESS
         constexpr int kEglBadDisplay = 0x3008; // EGL_BAD_DISPLAY
-        constexpr EglDisplay kEglNoDisplay = nullptr; // EGL_NO_DISPLAY
+        EglDisplay kEglNoDisplay = nullptr; // EGL_NO_DISPLAY
 
         void* querySym = nullptr;
         if (m_eglLib.IsOpen())
@@ -1230,7 +1227,9 @@ auto GLResolver::ResolveUnlocked(const char* name, const ResolverState& state) -
             // wglGetProcAddress can return special sentinel values (1,2,3,-1) for core symbols.
             // Treat those as invalid and allow fallback to GetProcAddress/dlsym paths.
             const std::uintptr_t raw = FunctionToInteger(proc);
-            if (raw != 1u && raw != 2u && raw != 3u && raw != std::numeric_limits<std::uintptr_t>::max())
+            // FunctionToInteger returns 0 on non-representable conversions (e.g. function pointers wider than void*).
+            // Treat that as invalid and allow fallback to exported symbols.
+            if (raw != 0u && raw != 1u && raw != 2u && raw != 3u && raw != std::numeric_limits<std::uintptr_t>::max())
             {
                 // Prefer exports from opengl32.dll for core OpenGL 1.1 entry points.
                 // In the wild, wglGetProcAddress may return a non-null pointer for some core symbols

src/libprojectM/Renderer/PlatformGLResolver.hpp

@@ -8,6 +8,7 @@
 #include <memory>
 #include <mutex>
 #include <string>
+#include <thread>
 
 namespace libprojectM
 {
@@ -82,24 +83,36 @@ using UserResolver = void* (*)(const char* name, void* userData);
  *      - EGL: eglGetProcAddress
  *        - Queried for all symbols only when EGL_KHR_get_all_proc_addresses or
  *          EGL_KHR_client_get_all_proc_addresses is advertised.
- *        - Otherwise queried only for extension-style names.
+ *        - Otherwise queried only for extension-style names during the provider step.
+ *        - As a last resort (after exports/global lookups fail), a best-effort call
+ *          to eglGetProcAddress may be attempted even for non-extension names to support
+ *          stacks that expose core client API entry points only via eglGetProcAddress.
  *      - GLX: glXGetProcAddressARB / glXGetProcAddress
  *        - Queried only for glX* or extension-style names.
  *      - WGL: wglGetProcAddress
  *        - Filters sentinel values; prefers exported symbols for core OpenGL 1.1 entry points.
  *  3) Global symbol scope lookup (dlsym(RTLD_DEFAULT) / GetProcAddress on already-loaded modules)
  *  4) Direct exports from explicitly opened libraries (EGL/GL/GLX)
+ *  5) EGL only: Try to resolve function via eglGetProcAddress() as a fallback.
  *
  * Resolution order (Emscripten/WebGL):
  *  1) User resolver callback (if provided)
  *  2) emscripten_webgl2_get_proc_address / emscripten_webgl_get_proc_address
  *     (prefers the current context major version)
  *
+ * ## Loader Flow (Emscripten)
+ *
+* GLResolver::Initialize(userResolver?, userData?)
+ *   |
+ *   +-- Has userResolver
+ *         +-- yes: Store user resolver, will use user resolver + emscripten_webgl*_get_proc_address fallback.
+ *         +-- no: Do not initialize GLAD at all, rely on WebGL static linking.
+ *
  * ## Loader Flow (non-Emscripten)
  *
  * GLResolver::Initialize(userResolver?, userData?)
  *   |
- *   +-- OpenNativeLibraries()                        (best-effort)
+ *   +-- OpenNativeLibraries()
  *   |     +-- open EGL library
  *   |     |     Windows:  libEGL.dll | EGL.dll
  *   |     |     macOS:    libEGL.dylib | libEGL.1.dylib | EGL
@@ -131,7 +144,7 @@ using UserResolver = void* (*)(const char* name, void* userData);
  *   |
  *   +-- DetectBackend()                              (prefers EGL, then WGL/CGL/GLX depending on platform)
  *   |
- *   +-- gladLoadGL(...) / gladLoadGLES2(...)          (GLAD calls back into GLResolver::GetProcAddress)
+ *   +-- gladLoadGL(...) / gladLoadGLES2(...)         (GLAD calls back into GLResolver::GetProcAddress)
  *   |
  *   +-- CheckGLRequirementsUnlocked()
  *   |     Desktop GL: OpenGL >= 3.3
@@ -145,15 +158,17 @@ using UserResolver = void* (*)(const char* name, void* userData);
  *
  * GLResolver::GetProcAddress(name)
  *   |
- *   +-- validates the currently-bound context matches the detected backend
+ *   +-- Validates the currently-bound context matches the detected backend.
  *   |
- *   +-- ResolveUnlocked(name, state)
- *   |     +-- user resolver (if any)
- *   |     +-- provider getProcAddress (backend-aware)
- *   |           EGL  -> eglGetProcAddress (extension-only unless EGL_KHR_*_get_all_proc_addresses)
- *   |           GLX  -> glXGetProcAddress* (glX* and extension-style only)
- *   |           WGL  -> wglGetProcAddress (filters sentinels; may prefer exported symbols)
- *   |           WebGL-> emscripten_webgl*_get_proc_address (Emscripten only)
+ *   +-- User resolver (if any)
+ *   |
+ *   +-- Provider getProcAddress (backend-aware)
+ *   |     EGL  -> eglGetProcAddress (extension-only unless EGL_KHR_*_get_all_proc_addresses)
+ *   |     GLX  -> glXGetProcAddress* (glX* and extension-style only)
+ *   |     WGL  -> wglGetProcAddress (filters sentinels; may prefer exported symbols)
+ *   |     WebGL-> emscripten_webgl*_get_proc_address (Emscripten only)
+ *   |
+ *   +-- If Emscripten -> All available lookups have been tried, return nullptr.
  *   |
  *   +-- DynamicLibrary::FindGlobalSymbol(name)
  *   |
@@ -162,8 +177,10 @@ using UserResolver = void* (*)(const char* name, void* userData);
  *   |     m_glLib.GetSymbol(name)
  *   |     m_glxLib.GetSymbol(name)
  *   |
+ *   +-- Late best-effort eglGetProcAddress() fallback (EGL only).
+ *   |
  *   \/
- *   nullptr
+ *  nullptr
  */
 class GLResolver
 {
@@ -195,9 +212,7 @@ class GLResolver
      * This method must be called at least once before GetProcAddress() is used.
      *
      * Thread-safety: Initialize() is internally synchronized. Intended usage is to initialize
-     * once during startup before any resolution occurs. GetProcAddress() assumes
-     * initialization has completed successfully (per API contract) and does not wait
-     * for an in-flight Initialize() call.
+     * once during startup before any resolution occurs. GetProcAddress() should not be called until Initialize() has completed.
      *
      * May be called multiple times; initialization work is performed only when needed.
      *

src/libprojectM/Renderer/PlatformLoader.hpp

@@ -276,7 +276,7 @@ class DynamicLibrary
     DynamicLibrary(const DynamicLibrary&) = delete;
     DynamicLibrary& operator=(const DynamicLibrary&) = delete;
 
-    inline auto Open(const char* const*, std::string& reason) -> bool
+    inline auto Open(const char* const*, std::string&) -> bool
     {
         return false;
     }
@@ -300,7 +300,7 @@ class DynamicLibrary
         return nullptr;
     }
 
-    inline auto SetCloseOnDestruct(bool enabled) -> void
+    inline auto SetCloseOnDestruct(bool) -> void
     {
     }
 
@@ -328,7 +328,13 @@ class DynamicLibrary
 public:
     DynamicLibrary() = default;
 
-    ~DynamicLibrary() = default;
+    ~DynamicLibrary()
+    {
+        if (m_closeOnDestruct)
+        {
+            Close();
+        }
+    }
 
     DynamicLibrary(const DynamicLibrary&) = delete;
     auto operator=(const DynamicLibrary&) -> DynamicLibrary& = delete;
@@ -487,21 +493,36 @@ class DynamicLibrary
                 // explicit full path improves dependency resolution by allowing the loader to search
                 // the DLL's directory for its dependent DLLs (LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR).
                 // This keeps the search path restricted without changing process-wide state.
-                const std::string appFull = buildAppDirPath(name);
-                if (!appFull.empty())
+                const bool isSystemOpenGL32 = (_stricmp(name, "opengl32.dll") == 0);
+
+                // For system DLLs like opengl32.dll, never prefer the application directory.
+                // Loading system DLLs from app-local paths enables DLL preloading/hijacking.
+                std::string appFull;
+                if (!isSystemOpenGL32)
                 {
-                    handle = tryLoadEx(appFull.c_str(), LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR | LOAD_LIBRARY_SEARCH_DEFAULT_DIRS);
-                    if (handle == nullptr && ::GetLastError() == ERROR_INVALID_PARAMETER)
+                    appFull = buildAppDirPath(name);
+                    if (!appFull.empty())
                     {
-                        // Older OS loader: use altered search path for absolute paths to improve
-                        // dependent DLL resolution.
-                        handle = tryLoadExplicitPathFallback(appFull.c_str());
+                        handle = tryLoadEx(appFull.c_str(), LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR | LOAD_LIBRARY_SEARCH_DEFAULT_DIRS);
+                        if (handle == nullptr && ::GetLastError() == ERROR_INVALID_PARAMETER)
+                        {
+                            // Older OS loader: use altered search path for absolute paths to improve
+                            // dependent DLL resolution.
+                            handle = tryLoadExplicitPathFallback(appFull.c_str());
+                        }
                     }
                 }
 
                 if (handle == nullptr)
                 {
-                    handle = tryLoadEx(name, LOAD_LIBRARY_SEARCH_APPLICATION_DIR | LOAD_LIBRARY_SEARCH_SYSTEM32);
+                    if (isSystemOpenGL32)
+                    {
+                        handle = tryLoadEx(name, LOAD_LIBRARY_SEARCH_SYSTEM32);
+                    }
+                    else
+                    {
+                        handle = tryLoadEx(name, LOAD_LIBRARY_SEARCH_APPLICATION_DIR | LOAD_LIBRARY_SEARCH_SYSTEM32);
+                    }
                 }
 
                 if (handle == nullptr && ::GetLastError() == ERROR_INVALID_PARAMETER)
@@ -641,6 +662,17 @@ class DynamicLibrary
         return m_handle;
     }
 
+    /**
+     * @brief Controls whether the library is closed in the destructor.
+     *
+     * The default is false to avoid unloading GL/driver libraries during process teardown.
+     * Enable only for short-lived helper loads where unloading is safe and desired.
+     */
+    auto SetCloseOnDestruct(bool enabled) -> void
+    {
+        m_closeOnDestruct = enabled;
+    }
+
     /**
      * @brief Resolves a symbol from this library.
      * @param name The symbol name.
@@ -742,8 +774,9 @@ class DynamicLibrary
     }
 
 private:
-    LibHandle m_handle{};         //!< Library handle used to access the system library.
-    std::string m_loadedName;     //< Successfully opened library name.
+    LibHandle m_handle{};           //!< Library handle used to access the system library.
+    std::string m_loadedName;       //< Successfully opened library name.
+    bool m_closeOnDestruct{false};  //!< If true, Close() is called from the destructor.
 };
 
 #endif // #ifdef __EMSCRIPTEN__