Fixed string section name

.idea/SmokeAPI.iml

@@ -1,2 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module classpath="CIDR" type="CPP_MODULE" version="4" />

README.md

@@ -150,9 +150,6 @@ The following list features links in Arch Linux repositories, but if you are usi
 you should use the equivalent package for your distro.
 
 Required libraries:
-- [brotli](https://archlinux.org/packages/core/x86_64/brotli/)
-  [[32-bit](https://archlinux.org/packages/multilib/x86_64/lib32-brotli/)]
-
 - [gcc-libs](https://archlinux.org/packages/core/x86_64/gcc-libs/)
   [[32-bit](https://archlinux.org/packages/core/x86_64/lib32-gcc-libs/)]
 
@@ -165,12 +162,6 @@ Required libraries:
 - [libnghttp2](https://archlinux.org/packages/core/x86_64/libnghttp2/)
   [[32-bit](https://archlinux.org/packages/multilib/x86_64/lib32-libnghttp2/)]
 
-- [libssh2](https://archlinux.org/packages/core/x86_64/libssh2/)
-  [[32-bit](https://archlinux.org/packages/multilib/x86_64/lib32-libssh2/)]
-
-- [openssl](https://archlinux.org/packages/core/x86_64/openssl/)
-  [[32-bit](https://archlinux.org/packages/multilib/x86_64/lib32-openssl/)]
-
 - [zlib](https://archlinux.org/packages/core/x86_64/zlib/)
   [[32-bit](https://archlinux.org/packages/multilib/x86_64/lib32-zlib/)]
 
@@ -194,7 +185,6 @@ wrappers might cause issues in theory. However, in practice real tests show that
 chance of success compared to proxy mode. So, at the end of the day, try both modes to see which one works
 best for you.
 
-
 ### 🔀 Proxy mode (🐧 Linux)
 
 Same as on Windows:
@@ -214,10 +204,10 @@ For example:
 1. Extract and paste the `libsmoke_api32.so` or `libsmoke_api64.so` in the root of game's installation directory.
 2. In Steam _Library_ open game's _Properties_, switch to the _General_ tab, and set the following _LAUNCH OPTIONS_:
 
-| Bitness | Launch Options                                                                                                         |
-|---------|------------------------------------------------------------------------------------------------------------------------|
-| 32-bit  | `LD_PRELOAD="./libsmoke_api32.so $HOME/.local/share/Steam/ubuntu12_32/gameoverlayrenderer.so" ./<GameExe32> %command%` |
-| 64-bit  | `LD_PRELOAD="./libsmoke_api64.so $HOME/.local/share/Steam/ubuntu12_64/gameoverlayrenderer.so" ./<GameExe64> %command%` |
+| Bitness | Launch Options                                                                                                                  |
+|---------|---------------------------------------------------------------------------------------------------------------------------------|
+| 32-bit  | `LD_PRELOAD="./libsmoke_api32.so $HOME/.local/share/Steam/ubuntu12_32/gameoverlayrenderer.so" ./<GameExe32> ; exit ; %command%` |
+| 64-bit  | `LD_PRELOAD="./libsmoke_api64.so $HOME/.local/share/Steam/ubuntu12_64/gameoverlayrenderer.so" ./<GameExe64> ; exit ; %command%` |
 
 Where `<GameExe32>` and `<GameExe64>` correspond to the actual filename of the game executable. For example:
 - `TheEscapists2.x86` (32-bit)
@@ -234,6 +224,9 @@ If you have other environment variables, and you don't know how to correctly com
 then please make extensive use of search engines and LLMs for guidance and examples
 before seeking help the official forum topic.
 
+> [!NOTE]
+> The `; exit ; %command%` at the end of launch options
+> is a trick used to force Steam to directly run the game executable.
 
 ## ⚙ Configuration
 

src/generated/64/proxy_exports.cpp

@@ -7208,6 +7208,211 @@ EXPORT void VR_Shutdown() {
     asm volatile ("jmp *%rax");
 }
 
+EXPORT void __gcclibcxx_demangle_callback() {
+    asm volatile ("movabs $0xFeedBeefDeadC0de, %%rax":::"rax");
+    asm volatile ("jmp *%rax");
+}
+
+EXPORT void __gxx_personality_v0() {
+    asm volatile ("movabs $0xFeedBeefDeadC0de, %%rax":::"rax");
+    asm volatile ("jmp *%rax");
+}
+
+EXPORT void __new_handler() {
+    asm volatile ("movabs $0xFeedBeefDeadC0de, %%rax":::"rax");
+    asm volatile ("jmp *%rax");
+}
+
+EXPORT void __wrap___lxstat() {
+    asm volatile ("movabs $0xFeedBeefDeadC0de, %%rax":::"rax");
+    asm volatile ("jmp *%rax");
+}
+
+EXPORT void __wrap___lxstat64() {
+    asm volatile ("movabs $0xFeedBeefDeadC0de, %%rax":::"rax");
+    asm volatile ("jmp *%rax");
+}
+
+EXPORT void __wrap___xstat() {
+    asm volatile ("movabs $0xFeedBeefDeadC0de, %%rax":::"rax");
+    asm volatile ("jmp *%rax");
+}
+
+EXPORT void __wrap___xstat64() {
+    asm volatile ("movabs $0xFeedBeefDeadC0de, %%rax":::"rax");
+    asm volatile ("jmp *%rax");
+}
+
+EXPORT void __wrap_access() {
+    asm volatile ("movabs $0xFeedBeefDeadC0de, %%rax":::"rax");
+    asm volatile ("jmp *%rax");
+}
+
+EXPORT void __wrap_chdir() {
+    asm volatile ("movabs $0xFeedBeefDeadC0de, %%rax":::"rax");
+    asm volatile ("jmp *%rax");
+}
+
+EXPORT void __wrap_chmod() {
+    asm volatile ("movabs $0xFeedBeefDeadC0de, %%rax":::"rax");
+    asm volatile ("jmp *%rax");
+}
+
+EXPORT void __wrap_chown() {
+    asm volatile ("movabs $0xFeedBeefDeadC0de, %%rax":::"rax");
+    asm volatile ("jmp *%rax");
+}
+
+EXPORT void __wrap_dlmopen() {
+    asm volatile ("movabs $0xFeedBeefDeadC0de, %%rax":::"rax");
+    asm volatile ("jmp *%rax");
+}
+
+EXPORT void __wrap_dlopen() {
+    asm volatile ("movabs $0xFeedBeefDeadC0de, %%rax":::"rax");
+    asm volatile ("jmp *%rax");
+}
+
+EXPORT void __wrap_fopen() {
+    asm volatile ("movabs $0xFeedBeefDeadC0de, %%rax":::"rax");
+    asm volatile ("jmp *%rax");
+}
+
+EXPORT void __wrap_fopen64() {
+    asm volatile ("movabs $0xFeedBeefDeadC0de, %%rax":::"rax");
+    asm volatile ("jmp *%rax");
+}
+
+EXPORT void __wrap_freopen() {
+    asm volatile ("movabs $0xFeedBeefDeadC0de, %%rax":::"rax");
+    asm volatile ("jmp *%rax");
+}
+
+EXPORT void __wrap_lchown() {
+    asm volatile ("movabs $0xFeedBeefDeadC0de, %%rax":::"rax");
+    asm volatile ("jmp *%rax");
+}
+
+EXPORT void __wrap_link() {
+    asm volatile ("movabs $0xFeedBeefDeadC0de, %%rax":::"rax");
+    asm volatile ("jmp *%rax");
+}
+
+EXPORT void __wrap_lstat() {
+    asm volatile ("movabs $0xFeedBeefDeadC0de, %%rax":::"rax");
+    asm volatile ("jmp *%rax");
+}
+
+EXPORT void __wrap_lstat64() {
+    asm volatile ("movabs $0xFeedBeefDeadC0de, %%rax":::"rax");
+    asm volatile ("jmp *%rax");
+}
+
+EXPORT void __wrap_mkdir() {
+    asm volatile ("movabs $0xFeedBeefDeadC0de, %%rax":::"rax");
+    asm volatile ("jmp *%rax");
+}
+
+EXPORT void __wrap_mkfifo() {
+    asm volatile ("movabs $0xFeedBeefDeadC0de, %%rax":::"rax");
+    asm volatile ("jmp *%rax");
+}
+
+EXPORT void __wrap_mknod() {
+    asm volatile ("movabs $0xFeedBeefDeadC0de, %%rax":::"rax");
+    asm volatile ("jmp *%rax");
+}
+
+EXPORT void __wrap_mount() {
+    asm volatile ("movabs $0xFeedBeefDeadC0de, %%rax":::"rax");
+    asm volatile ("jmp *%rax");
+}
+
+EXPORT void __wrap_open() {
+    asm volatile ("movabs $0xFeedBeefDeadC0de, %%rax":::"rax");
+    asm volatile ("jmp *%rax");
+}
+
+EXPORT void __wrap_open64() {
+    asm volatile ("movabs $0xFeedBeefDeadC0de, %%rax":::"rax");
+    asm volatile ("jmp *%rax");
+}
+
+EXPORT void __wrap_opendir() {
+    asm volatile ("movabs $0xFeedBeefDeadC0de, %%rax":::"rax");
+    asm volatile ("jmp *%rax");
+}
+
+EXPORT void __wrap_rename() {
+    asm volatile ("movabs $0xFeedBeefDeadC0de, %%rax":::"rax");
+    asm volatile ("jmp *%rax");
+}
+
+EXPORT void __wrap_rmdir() {
+    asm volatile ("movabs $0xFeedBeefDeadC0de, %%rax":::"rax");
+    asm volatile ("jmp *%rax");
+}
+
+EXPORT void __wrap_scandir() {
+    asm volatile ("movabs $0xFeedBeefDeadC0de, %%rax":::"rax");
+    asm volatile ("jmp *%rax");
+}
+
+EXPORT void __wrap_scandir64() {
+    asm volatile ("movabs $0xFeedBeefDeadC0de, %%rax":::"rax");
+    asm volatile ("jmp *%rax");
+}
+
+EXPORT void __wrap_stat() {
+    asm volatile ("movabs $0xFeedBeefDeadC0de, %%rax":::"rax");
+    asm volatile ("jmp *%rax");
+}
+
+EXPORT void __wrap_stat64() {
+    asm volatile ("movabs $0xFeedBeefDeadC0de, %%rax":::"rax");
+    asm volatile ("jmp *%rax");
+}
+
+EXPORT void __wrap_statfs() {
+    asm volatile ("movabs $0xFeedBeefDeadC0de, %%rax":::"rax");
+    asm volatile ("jmp *%rax");
+}
+
+EXPORT void __wrap_statfs64() {
+    asm volatile ("movabs $0xFeedBeefDeadC0de, %%rax":::"rax");
+    asm volatile ("jmp *%rax");
+}
+
+EXPORT void __wrap_statvfs() {
+    asm volatile ("movabs $0xFeedBeefDeadC0de, %%rax":::"rax");
+    asm volatile ("jmp *%rax");
+}
+
+EXPORT void __wrap_statvfs64() {
+    asm volatile ("movabs $0xFeedBeefDeadC0de, %%rax":::"rax");
+    asm volatile ("jmp *%rax");
+}
+
+EXPORT void __wrap_symlink() {
+    asm volatile ("movabs $0xFeedBeefDeadC0de, %%rax":::"rax");
+    asm volatile ("jmp *%rax");
+}
+
+EXPORT void __wrap_unlink() {
+    asm volatile ("movabs $0xFeedBeefDeadC0de, %%rax":::"rax");
+    asm volatile ("jmp *%rax");
+}
+
+EXPORT void __wrap_utime() {
+    asm volatile ("movabs $0xFeedBeefDeadC0de, %%rax":::"rax");
+    asm volatile ("jmp *%rax");
+}
+
+EXPORT void __wrap_utimes() {
+    asm volatile ("movabs $0xFeedBeefDeadC0de, %%rax":::"rax");
+    asm volatile ("jmp *%rax");
+}
+
 EXPORT void g_pSteamClientGameServer() {
     asm volatile ("movabs $0xFeedBeefDeadC0de, %%rax":::"rax");
     asm volatile ("jmp *%rax");
@@ -14443,6 +14648,211 @@ namespace proxy_exports {
         if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
         std::memcpy(static_cast<uint8_t*>(dest_address) + 2, &src_address, sizeof(void*));
 
+        dest_address = dlsym(self_lib_handle, "__gcclibcxx_demangle_callback");
+        src_address = dlsym(original_lib_handle, "__gcclibcxx_demangle_callback");
+        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
+        std::memcpy(static_cast<uint8_t*>(dest_address) + 2, &src_address, sizeof(void*));
+
+        dest_address = dlsym(self_lib_handle, "__gxx_personality_v0");
+        src_address = dlsym(original_lib_handle, "__gxx_personality_v0");
+        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
+        std::memcpy(static_cast<uint8_t*>(dest_address) + 2, &src_address, sizeof(void*));
+
+        dest_address = dlsym(self_lib_handle, "__new_handler");
+        src_address = dlsym(original_lib_handle, "__new_handler");
+        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
+        std::memcpy(static_cast<uint8_t*>(dest_address) + 2, &src_address, sizeof(void*));
+
+        dest_address = dlsym(self_lib_handle, "__wrap___lxstat");
+        src_address = dlsym(original_lib_handle, "__wrap___lxstat");
+        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
+        std::memcpy(static_cast<uint8_t*>(dest_address) + 2, &src_address, sizeof(void*));
+
+        dest_address = dlsym(self_lib_handle, "__wrap___lxstat64");
+        src_address = dlsym(original_lib_handle, "__wrap___lxstat64");
+        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
+        std::memcpy(static_cast<uint8_t*>(dest_address) + 2, &src_address, sizeof(void*));
+
+        dest_address = dlsym(self_lib_handle, "__wrap___xstat");
+        src_address = dlsym(original_lib_handle, "__wrap___xstat");
+        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
+        std::memcpy(static_cast<uint8_t*>(dest_address) + 2, &src_address, sizeof(void*));
+
+        dest_address = dlsym(self_lib_handle, "__wrap___xstat64");
+        src_address = dlsym(original_lib_handle, "__wrap___xstat64");
+        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
+        std::memcpy(static_cast<uint8_t*>(dest_address) + 2, &src_address, sizeof(void*));
+
+        dest_address = dlsym(self_lib_handle, "__wrap_access");
+        src_address = dlsym(original_lib_handle, "__wrap_access");
+        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
+        std::memcpy(static_cast<uint8_t*>(dest_address) + 2, &src_address, sizeof(void*));
+
+        dest_address = dlsym(self_lib_handle, "__wrap_chdir");
+        src_address = dlsym(original_lib_handle, "__wrap_chdir");
+        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
+        std::memcpy(static_cast<uint8_t*>(dest_address) + 2, &src_address, sizeof(void*));
+
+        dest_address = dlsym(self_lib_handle, "__wrap_chmod");
+        src_address = dlsym(original_lib_handle, "__wrap_chmod");
+        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
+        std::memcpy(static_cast<uint8_t*>(dest_address) + 2, &src_address, sizeof(void*));
+
+        dest_address = dlsym(self_lib_handle, "__wrap_chown");
+        src_address = dlsym(original_lib_handle, "__wrap_chown");
+        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
+        std::memcpy(static_cast<uint8_t*>(dest_address) + 2, &src_address, sizeof(void*));
+
+        dest_address = dlsym(self_lib_handle, "__wrap_dlmopen");
+        src_address = dlsym(original_lib_handle, "__wrap_dlmopen");
+        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
+        std::memcpy(static_cast<uint8_t*>(dest_address) + 2, &src_address, sizeof(void*));
+
+        dest_address = dlsym(self_lib_handle, "__wrap_dlopen");
+        src_address = dlsym(original_lib_handle, "__wrap_dlopen");
+        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
+        std::memcpy(static_cast<uint8_t*>(dest_address) + 2, &src_address, sizeof(void*));
+
+        dest_address = dlsym(self_lib_handle, "__wrap_fopen");
+        src_address = dlsym(original_lib_handle, "__wrap_fopen");
+        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
+        std::memcpy(static_cast<uint8_t*>(dest_address) + 2, &src_address, sizeof(void*));
+
+        dest_address = dlsym(self_lib_handle, "__wrap_fopen64");
+        src_address = dlsym(original_lib_handle, "__wrap_fopen64");
+        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
+        std::memcpy(static_cast<uint8_t*>(dest_address) + 2, &src_address, sizeof(void*));
+
+        dest_address = dlsym(self_lib_handle, "__wrap_freopen");
+        src_address = dlsym(original_lib_handle, "__wrap_freopen");
+        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
+        std::memcpy(static_cast<uint8_t*>(dest_address) + 2, &src_address, sizeof(void*));
+
+        dest_address = dlsym(self_lib_handle, "__wrap_lchown");
+        src_address = dlsym(original_lib_handle, "__wrap_lchown");
+        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
+        std::memcpy(static_cast<uint8_t*>(dest_address) + 2, &src_address, sizeof(void*));
+
+        dest_address = dlsym(self_lib_handle, "__wrap_link");
+        src_address = dlsym(original_lib_handle, "__wrap_link");
+        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
+        std::memcpy(static_cast<uint8_t*>(dest_address) + 2, &src_address, sizeof(void*));
+
+        dest_address = dlsym(self_lib_handle, "__wrap_lstat");
+        src_address = dlsym(original_lib_handle, "__wrap_lstat");
+        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
+        std::memcpy(static_cast<uint8_t*>(dest_address) + 2, &src_address, sizeof(void*));
+
+        dest_address = dlsym(self_lib_handle, "__wrap_lstat64");
+        src_address = dlsym(original_lib_handle, "__wrap_lstat64");
+        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
+        std::memcpy(static_cast<uint8_t*>(dest_address) + 2, &src_address, sizeof(void*));
+
+        dest_address = dlsym(self_lib_handle, "__wrap_mkdir");
+        src_address = dlsym(original_lib_handle, "__wrap_mkdir");
+        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
+        std::memcpy(static_cast<uint8_t*>(dest_address) + 2, &src_address, sizeof(void*));
+
+        dest_address = dlsym(self_lib_handle, "__wrap_mkfifo");
+        src_address = dlsym(original_lib_handle, "__wrap_mkfifo");
+        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
+        std::memcpy(static_cast<uint8_t*>(dest_address) + 2, &src_address, sizeof(void*));
+
+        dest_address = dlsym(self_lib_handle, "__wrap_mknod");
+        src_address = dlsym(original_lib_handle, "__wrap_mknod");
+        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
+        std::memcpy(static_cast<uint8_t*>(dest_address) + 2, &src_address, sizeof(void*));
+
+        dest_address = dlsym(self_lib_handle, "__wrap_mount");
+        src_address = dlsym(original_lib_handle, "__wrap_mount");
+        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
+        std::memcpy(static_cast<uint8_t*>(dest_address) + 2, &src_address, sizeof(void*));
+
+        dest_address = dlsym(self_lib_handle, "__wrap_open");
+        src_address = dlsym(original_lib_handle, "__wrap_open");
+        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
+        std::memcpy(static_cast<uint8_t*>(dest_address) + 2, &src_address, sizeof(void*));
+
+        dest_address = dlsym(self_lib_handle, "__wrap_open64");
+        src_address = dlsym(original_lib_handle, "__wrap_open64");
+        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
+        std::memcpy(static_cast<uint8_t*>(dest_address) + 2, &src_address, sizeof(void*));
+
+        dest_address = dlsym(self_lib_handle, "__wrap_opendir");
+        src_address = dlsym(original_lib_handle, "__wrap_opendir");
+        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
+        std::memcpy(static_cast<uint8_t*>(dest_address) + 2, &src_address, sizeof(void*));
+
+        dest_address = dlsym(self_lib_handle, "__wrap_rename");
+        src_address = dlsym(original_lib_handle, "__wrap_rename");
+        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
+        std::memcpy(static_cast<uint8_t*>(dest_address) + 2, &src_address, sizeof(void*));
+
+        dest_address = dlsym(self_lib_handle, "__wrap_rmdir");
+        src_address = dlsym(original_lib_handle, "__wrap_rmdir");
+        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
+        std::memcpy(static_cast<uint8_t*>(dest_address) + 2, &src_address, sizeof(void*));
+
+        dest_address = dlsym(self_lib_handle, "__wrap_scandir");
+        src_address = dlsym(original_lib_handle, "__wrap_scandir");
+        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
+        std::memcpy(static_cast<uint8_t*>(dest_address) + 2, &src_address, sizeof(void*));
+
+        dest_address = dlsym(self_lib_handle, "__wrap_scandir64");
+        src_address = dlsym(original_lib_handle, "__wrap_scandir64");
+        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
+        std::memcpy(static_cast<uint8_t*>(dest_address) + 2, &src_address, sizeof(void*));
+
+        dest_address = dlsym(self_lib_handle, "__wrap_stat");
+        src_address = dlsym(original_lib_handle, "__wrap_stat");
+        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
+        std::memcpy(static_cast<uint8_t*>(dest_address) + 2, &src_address, sizeof(void*));
+
+        dest_address = dlsym(self_lib_handle, "__wrap_stat64");
+        src_address = dlsym(original_lib_handle, "__wrap_stat64");
+        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
+        std::memcpy(static_cast<uint8_t*>(dest_address) + 2, &src_address, sizeof(void*));
+
+        dest_address = dlsym(self_lib_handle, "__wrap_statfs");
+        src_address = dlsym(original_lib_handle, "__wrap_statfs");
+        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
+        std::memcpy(static_cast<uint8_t*>(dest_address) + 2, &src_address, sizeof(void*));
+
+        dest_address = dlsym(self_lib_handle, "__wrap_statfs64");
+        src_address = dlsym(original_lib_handle, "__wrap_statfs64");
+        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
+        std::memcpy(static_cast<uint8_t*>(dest_address) + 2, &src_address, sizeof(void*));
+
+        dest_address = dlsym(self_lib_handle, "__wrap_statvfs");
+        src_address = dlsym(original_lib_handle, "__wrap_statvfs");
+        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
+        std::memcpy(static_cast<uint8_t*>(dest_address) + 2, &src_address, sizeof(void*));
+
+        dest_address = dlsym(self_lib_handle, "__wrap_statvfs64");
+        src_address = dlsym(original_lib_handle, "__wrap_statvfs64");
+        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
+        std::memcpy(static_cast<uint8_t*>(dest_address) + 2, &src_address, sizeof(void*));
+
+        dest_address = dlsym(self_lib_handle, "__wrap_symlink");
+        src_address = dlsym(original_lib_handle, "__wrap_symlink");
+        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
+        std::memcpy(static_cast<uint8_t*>(dest_address) + 2, &src_address, sizeof(void*));
+
+        dest_address = dlsym(self_lib_handle, "__wrap_unlink");
+        src_address = dlsym(original_lib_handle, "__wrap_unlink");
+        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
+        std::memcpy(static_cast<uint8_t*>(dest_address) + 2, &src_address, sizeof(void*));
+
+        dest_address = dlsym(self_lib_handle, "__wrap_utime");
+        src_address = dlsym(original_lib_handle, "__wrap_utime");
+        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
+        std::memcpy(static_cast<uint8_t*>(dest_address) + 2, &src_address, sizeof(void*));
+
+        dest_address = dlsym(self_lib_handle, "__wrap_utimes");
+        src_address = dlsym(original_lib_handle, "__wrap_utimes");
+        if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);
+        std::memcpy(static_cast<uint8_t*>(dest_address) + 2, &src_address, sizeof(void*));
+
         dest_address = dlsym(self_lib_handle, "g_pSteamClientGameServer");
         src_address = dlsym(original_lib_handle, "g_pSteamClientGameServer");
         if(!src_address) src_address = reinterpret_cast<void*>(panic_exit);

src/smoke_api/smoke_api.cpp

@@ -65,12 +65,13 @@ namespace {
         std::set<std::string> versions;
 
         // On Linux the section name depends on individual lib file, so we can't use generic constants
-        const std::string str_section_name = kb::platform::is_windows ? ".text" : ".rodata.str";
-        const auto rdata_section = kb::lib::get_section_or_throw(steamapi_handle, str_section_name);
-        const auto rdata = rdata_section.to_string();
+        // ReSharper disable once CppDFAUnreachableCode
+        const std::string str_section_name = kb::platform::is_windows ? ".rdata" : ".rodata";
+        const auto str_section = kb::lib::get_section_or_throw(steamapi_handle, str_section_name);
+        const auto str_section_str = str_section.to_string();
 
         const std::regex pattern(R"(SteamClient\d{3})");
-        const auto matches_begin = std::sregex_iterator(rdata.begin(), rdata.end(), pattern);
+        const auto matches_begin = std::sregex_iterator(str_section_str.begin(), str_section_str.end(), pattern);
         const auto matches_end = std::sregex_iterator();
 
         for(std::sregex_iterator i = matches_begin; i != matches_end; ++i) {
@@ -110,10 +111,10 @@ namespace {
 
         static const auto CreateInterface$ = KB_LIB_GET_FUNC(steamclient_handle, CreateInterface);
 
-        if(auto* steamapi_handle = kb::lib::get_lib_handle(STEAM_API_MODULE)) {
+        if(original_steamapi_handle) {
             // SteamAPI might have been initialized.
             // Hence, we need to query SteamClient interfaces and hook them if needed.
-            const auto steamclient_versions = find_steamclient_versions(steamapi_handle);
+            const auto steamclient_versions = find_steamclient_versions(original_steamapi_handle);
             for(const auto& steamclient_version : steamclient_versions) {
                 if(CreateInterface$(steamclient_version.c_str(), nullptr)) {
 #ifdef KB_WIN
@@ -125,6 +126,8 @@ namespace {
                     LOG_INFO("'{}' has not been initialized. Waiting for initialization.", steamclient_version);
                 }
             }
+        } else {
+            LOG_ERROR("{} -> original_steamapi_handle is null", __func__);
         }
 
         return true;