koffi 2.6.2 → 2.6.4

package/CHANGELOG.md

@@ -4,10 +4,18 @@
 
 ### Koffi 2.6
 
-#### Koffi 2.6.2 (2023-10-13)
+#### Koffi 2.6.4 (2023-10-26)
+
+- Fix build issue with recent Visual Studio versions
+
+#### Koffi 2.6.3 (2023-10-17)
 
 - Add indirect loading script to help some bundlers
 
+```{warning}
+Pre-built binaries don't work correctly in Koffi 2.6.2, skip this version.
+```
+
 #### Koffi 2.6.1 (2023-09-18)
 
 - Support string direction qualifiers in classic function definitions

package/doc/contribute.md

@@ -139,7 +139,7 @@ Once this is done, you can publish a new release with the following commands:
 
 ```sh
 node tools/qemu.js test # If not done before
-node tools/qemu.js dist
+node tools/qemu.js build
 
 cd build/dist
 npm publish

package/doc/packaging.md

@@ -1,6 +1,8 @@
 # Bundlers and Koffi
 
-## Bundling and native modules
+## Bundling
+
+### Native modules
 
 *Simplified in Koffi 2.5.9*
 
@@ -36,13 +38,13 @@ resources/
 MyApp.exe
 ```
 
-## Indirect loader
+### Indirect loader
 
 *New in Koffi 2.6.2*
 
 Some bundlers (such as vite) don't like when require is used with native modules.
 
-In this case, you can use `js require('koffi/indirect')` but you will need to make sure that the native Koffi modules are packaged properly.
+In this case, you can use `require('koffi/indirect')` but you will need to make sure that the native Koffi modules are packaged properly.
 
 ## Packaging examples
 

package/index.js

@@ -378,8 +378,8 @@ var require_package = __commonJS({
   "build/dist/src/koffi/package.json"(exports2, module2) {
     module2.exports = {
       name: "koffi",
-      version: "2.6.2",
-      stable: "2.6.2",
+      version: "2.6.4",
+      stable: "2.6.4",
       description: "Fast and simple C FFI (foreign function interface) for Node.js",
       keywords: [
         "foreign",
@@ -424,7 +424,7 @@ var require_package = __commonJS({
       cnoke: {
         output: "build/koffi/{{ platform }}_{{ arch }}",
         napi: 8,
-        require: "./src/index.js"
+        require: "./index.js"
       }
     };
   }

package/indirect.js

@@ -378,8 +378,8 @@ var require_package = __commonJS({
   "build/dist/src/koffi/package.json"(exports2, module2) {
     module2.exports = {
       name: "koffi",
-      version: "2.6.2",
-      stable: "2.6.2",
+      version: "2.6.4",
+      stable: "2.6.4",
       description: "Fast and simple C FFI (foreign function interface) for Node.js",
       keywords: [
         "foreign",
@@ -424,7 +424,7 @@ var require_package = __commonJS({
       cnoke: {
         output: "build/koffi/{{ platform }}_{{ arch }}",
         napi: 8,
-        require: "./src/index.js"
+        require: "./index.js"
       }
     };
   }

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "koffi",
-    "version": "2.6.2",
-    "stable": "2.6.2",
+    "version": "2.6.4",
+    "stable": "2.6.4",
     "description": "Fast and simple C FFI (foreign function interface) for Node.js",
     "keywords": [
         "foreign",
@@ -31,6 +31,6 @@
     "cnoke": {
         "output": "build/koffi/{{ platform }}_{{ arch }}",
         "napi": 8,
-        "require": "./src/index.js"
+        "require": "./index.js"
     }
 }

package/src/core/libcc/libcc.cc

@@ -789,10 +789,12 @@ bool ParseBool(Span<const char> str, bool *out_value, unsigned int flags,
     TRY_MATCH("1", true);
     TRY_MATCH("On", true);
     TRY_MATCH("Y", true);
+    TRY_MATCH("Yes", true);
     TRY_MATCH("True", true);
     TRY_MATCH("0", false);
     TRY_MATCH("Off", false);
     TRY_MATCH("N", false);
+    TRY_MATCH("No", false);
     TRY_MATCH("False", false);
 
     if (flags & (int)ParseFlag::Log) {
@@ -1424,7 +1426,7 @@ static inline void ProcessArg(const FmtArg &arg, AppendFunc append)
                 RG_ASSERT(arg.u.random.len <= RG_SIZE(out_buf.data));
 
                 for (Size j = 0; j < arg.u.random.len; j++) {
-                    int rnd = GetRandomIntSafe(0, (int)chars.len);
+                    int rnd = GetRandomIntFast(0, (int)chars.len);
                     out_buf.Append(chars[rnd]);
                 }
 
@@ -2144,37 +2146,6 @@ fail:
     return str_buf;
 }
 
-void SetEnvironmentVar(const char *name, const char *value)
-{
-    RG_ASSERT(name && name[0] && !strchr(name, '='));
-    RG_ASSERT(value);
-
-    if (win32_utf8) {
-        RG_CRITICAL(SetEnvironmentVariableA(name, value), "Failed to set environment variable '%1' to '%2': %3", name, value, GetWin32ErrorString());
-    } else {
-        wchar_t name_w[256];
-        wchar_t value_w[4096];
-
-        RG_CRITICAL(ConvertUtf8ToWin32Wide(name, name_w) >= 0, "Failed to set environment variable '%1' to '%2'", name, value);
-        RG_CRITICAL(ConvertUtf8ToWin32Wide(value, value_w) >= 0, "Failed to set environment variable '%1' to '%2'", name, value);
-        RG_CRITICAL(SetEnvironmentVariableW(name_w, value_w), "Failed to set environment variable '%1' to '%2': %3", name, value, GetWin32ErrorString());
-    }
-}
-
-void DeleteEnvironmentVar(const char *name)
-{
-    RG_ASSERT(name && name[0] && !strchr(name, '='));
-
-    if (win32_utf8) {
-        RG_CRITICAL(SetEnvironmentVariableA(name, nullptr), "Failed to clear environment variable '%1': %2", name, GetWin32ErrorString());
-    } else {
-        wchar_t name_w[256];
-
-        RG_CRITICAL(ConvertUtf8ToWin32Wide(name, name_w) >= 0, "Failed to clear environment variable '%1'", name);
-        RG_CRITICAL(SetEnvironmentVariableW(name_w, nullptr), "Failed to clear environment variable '%1': %2", name, GetWin32ErrorString());
-    }
-}
-
 static FileType FileAttributesToType(uint32_t attr)
 {
     if (attr & FILE_ATTRIBUTE_DIRECTORY) {
@@ -2358,20 +2329,6 @@ EnumResult EnumerateDirectory(const char *dirname, const char *filter, Size max_
 
 #else
 
-void SetEnvironmentVar(const char *name, const char *value)
-{
-    RG_ASSERT(name && name[0] && !strchr(name, '='));
-    RG_ASSERT(value);
-
-    RG_CRITICAL(!setenv(name, value, 1), "Failed to set environment variable '%1' to '%2': %3", name, value, strerror(errno));
-}
-
-void DeleteEnvironmentVar(const char *name)
-{
-    RG_ASSERT(name && name[0] && !strchr(name, '='));
-    RG_CRITICAL(!unsetenv(name), "Failed to clear environment variable '%1': %2", name, strerror(errno));
-}
-
 static FileType FileModeToType(mode_t mode)
 {
     if (S_ISDIR(mode)) {
@@ -3917,7 +3874,7 @@ struct PendingIO {
     }
 };
 
-bool ExecuteCommandLine(const char *cmd_line, const char *work_dir,
+bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,
                         FunctionRef<Span<const uint8_t>()> in_func,
                         FunctionRef<void(Span<uint8_t> buf)> out_func, int *out_code)
 {
@@ -3932,9 +3889,9 @@ bool ExecuteCommandLine(const char *cmd_line, const char *work_dir,
 
     // Convert work directory
     Span<wchar_t> work_dir_w;
-    if (work_dir) {
-        work_dir_w = AllocateSpan<wchar_t>(&temp_alloc, 2 * strlen(work_dir) + 1);
-        if (ConvertUtf8ToWin32Wide(work_dir, work_dir_w) < 0)
+    if (info.work_dir) {
+        work_dir_w = AllocateSpan<wchar_t>(&temp_alloc, 2 * strlen(info.work_dir) + 1);
+        if (ConvertUtf8ToWin32Wide(info.work_dir, work_dir_w) < 0)
             return false;
     } else {
         work_dir_w = {};
@@ -3986,6 +3943,45 @@ bool ExecuteCommandLine(const char *cmd_line, const char *work_dir,
     if (out_func.IsValid() && !CreateOverlappedPipe(true, false, PipeMode::Byte, out_pipe))
         return false;
 
+    // Prepare environment (if needed)
+    HeapArray<wchar_t> new_env_w;
+    if (info.reset_env || info.env_variables.len) {
+        if (!info.reset_env) {
+            Span<wchar_t> current_env = MakeSpan(GetEnvironmentStringsW(), 0);
+
+            do {
+                Size len = (Size)wcslen(current_env.end());
+                current_env.len += len + 1;
+            } while (current_env.ptr[current_env.len]);
+
+            new_env_w.Append(current_env);
+        }
+
+        for (const ExecuteInfo::KeyValue &kv: info.env_variables) {
+            Span<const char> key = kv.key;
+            Span<const char> value = kv.value;
+
+            Size len = 2 * (key.len + value.len + 1) + 1;
+            new_env_w.Reserve(len);
+
+            len = ConvertUtf8ToWin32Wide(key, new_env_w.TakeAvailable());
+            if (len < 0) [[unlikely]]
+                return false;
+            new_env_w.len += len;
+
+            new_env_w.Append(L'=');
+
+            len = ConvertUtf8ToWin32Wide(value, new_env_w.TakeAvailable());
+            if (len < 0) [[unlikely]]
+                return false;
+            new_env_w.len += len;
+
+            new_env_w.Append(0);
+        }
+
+        new_env_w.Append(0);
+    }
+
     // Start process
     HANDLE process_handle;
     {
@@ -4010,9 +4006,11 @@ bool ExecuteCommandLine(const char *cmd_line, const char *work_dir,
             si.dwFlags |= STARTF_USESTDHANDLES;
         }
 
+        int flags = CREATE_NEW_PROCESS_GROUP | CREATE_UNICODE_ENVIRONMENT;
+
         PROCESS_INFORMATION pi = {};
-        if (!CreateProcessW(nullptr, cmd_line_w.ptr, nullptr, nullptr, TRUE, CREATE_NEW_PROCESS_GROUP,
-                            nullptr, work_dir_w.ptr, &si, &pi)) {
+        if (!CreateProcessW(nullptr, cmd_line_w.ptr, nullptr, nullptr, TRUE, flags,
+                            new_env_w.ptr, work_dir_w.ptr, &si, &pi)) {
             LogError("Failed to start process: %1", GetWin32ErrorString());
             return false;
         }
@@ -4221,10 +4219,12 @@ void CloseDescriptorSafe(int *fd_ptr)
     *fd_ptr = -1;
 }
 
-bool ExecuteCommandLine(const char *cmd_line, const char *work_dir,
+bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,
                         FunctionRef<Span<const uint8_t>()> in_func,
                         FunctionRef<void(Span<uint8_t> buf)> out_func, int *out_code)
 {
+    BlockAllocator temp_alloc;
+
     // Create read pipes
     int in_pfd[2] = {-1, -1};
     RG_DEFER {
@@ -4275,6 +4275,26 @@ bool ExecuteCommandLine(const char *cmd_line, const char *work_dir,
         }
     }
 
+    // Prepare new environment (if needed)
+    HeapArray<char *> new_env;
+    if (info.reset_env || info.env_variables.len) {
+        if (!info.reset_env) {
+            char **ptr = environ;
+
+            while (*ptr) {
+                new_env.Append(*ptr);
+                ptr++;
+            }
+        }
+
+        for (const ExecuteInfo::KeyValue &kv: info.env_variables) {
+            const char *var = Fmt(&temp_alloc, "%1=%2", kv.key, kv.value).ptr;
+            new_env.Append((char *)var);
+        }
+
+        new_env.Append(nullptr);
+    }
+
     // Start process
     pid_t pid;
     {
@@ -4295,12 +4315,12 @@ bool ExecuteCommandLine(const char *cmd_line, const char *work_dir,
             return false;
         }
 
-        if (work_dir) {
-            const char *argv[] = {"env", "-C", work_dir, "sh", "-c", cmd_line, nullptr };
-            errno = posix_spawn(&pid, "/bin/env", &file_actions, nullptr, const_cast<char **>(argv), environ);
+        if (info.work_dir) {
+            const char *argv[] = {"env", "-C", info.work_dir, "sh", "-c", cmd_line, nullptr };
+            errno = posix_spawn(&pid, "/bin/env", &file_actions, nullptr, const_cast<char **>(argv), new_env.ptr ? new_env.ptr : environ);
         } else {
             const char *argv[] = {"sh", "-c", cmd_line, nullptr};
-            errno = posix_spawn(&pid, "/bin/sh", &file_actions, nullptr, const_cast<char **>(argv), environ);
+            errno = posix_spawn(&pid, "/bin/sh", &file_actions, nullptr, const_cast<char **>(argv), new_env.ptr ? new_env.ptr : environ);
         }
         if (errno) {
             LogError("Failed to start process: %1", strerror(errno));
@@ -4442,7 +4462,7 @@ bool ExecuteCommandLine(const char *cmd_line, const char *work_dir,
 
 #endif
 
-bool ExecuteCommandLine(const char *cmd_line, const char *work_dir,
+bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,
                         Span<const uint8_t> in_buf, Size max_len,
                         HeapArray<uint8_t> *out_buf, int *out_code)
 {
@@ -4465,8 +4485,8 @@ bool ExecuteCommandLine(const char *cmd_line, const char *work_dir,
     // Don't f*ck up the log
     bool warned = false;
 
-    bool success = ExecuteCommandLine(cmd_line, work_dir, [&]() { return in_buf; },
-                                                          [&](Span<uint8_t> buf) {
+    bool success = ExecuteCommandLine(cmd_line, info, [&]() { return in_buf; },
+                                                      [&](Span<uint8_t> buf) {
         if (out_buf->len - start_len <= max_len - buf.len) {
             out_buf->Append(buf);
         } else if (!warned) {
@@ -4492,7 +4512,7 @@ Size ReadCommandOutput(const char *cmd_line, Span<char> out_output)
     };
 
     int exit_code;
-    if (!ExecuteCommandLine(cmd_line, nullptr, MakeSpan((const uint8_t *)nullptr, 0), write, &exit_code))
+    if (!ExecuteCommandLine(cmd_line, {}, MakeSpan((const uint8_t *)nullptr, 0), write, &exit_code))
         return -1;
     if (exit_code) {
         LogDebug("Command '%1 failed (exit code: %2)", cmd_line, exit_code);
@@ -4505,7 +4525,7 @@ Size ReadCommandOutput(const char *cmd_line, Span<char> out_output)
 bool ReadCommandOutput(const char *cmd_line, HeapArray<char> *out_output)
 {
     int exit_code;
-    if (!ExecuteCommandLine(cmd_line, nullptr, {}, Mebibytes(1), out_output, &exit_code))
+    if (!ExecuteCommandLine(cmd_line, {}, {}, Mebibytes(1), out_output, &exit_code))
         return false;
     if (exit_code) {
         LogDebug("Command '%1 failed (exit code: %2)", cmd_line, exit_code);
@@ -4757,7 +4777,7 @@ bool NotifySystemd()
         return false;
     }
 
-    DeleteEnvironmentVar("NOTIFY_SOCKET");
+    unsetenv("NOTIFY_SOCKET");
     return true;
 }
 #endif
@@ -5061,79 +5081,6 @@ const char *CreateUniqueDirectory(Span<const char> directory, const char *prefix
 // Random
 // ------------------------------------------------------------------------
 
-static inline uint32_t ROTL32(uint32_t v, int n)
-{
-    return (v << n) | (v >> (32 - n));
-}
-
-static inline uint64_t ROTL64(uint64_t v, int n) {
-    return (v << n) | (v >> (64 - n));
-}
-
-FastRandom::FastRandom()
-{
-    do {
-        FillRandomSafe(state, RG_SIZE(state));
-    } while (std::all_of(std::begin(state), std::end(state), [](uint64_t v) { return !v; }));
-}
-
-FastRandom::FastRandom(uint64_t seed)
-{
-    // splitmix64 generator to seed xoshiro256++, as recommended
-
-    seed += 0x9e3779b97f4a7c15;
-
-    for (int i = 0; i < 4; i++) {
-        seed = (seed ^ (seed >> 30)) * 0xbf58476d1ce4e5b9;
-        seed = (seed ^ (seed >> 27)) * 0x94d049bb133111eb;
-        state[i] = seed ^ (seed >> 31);
-    }
-}
-
-void FastRandom::Fill(void *out_buf, Size len)
-{
-    for (Size i = 0; i < len; i += 8) {
-        uint64_t rnd = Next();
-
-        Size copy_len = std::min(RG_SIZE(rnd), len - i);
-        memcpy((uint8_t *)out_buf + i, &rnd, copy_len);
-    }
-}
-
-int FastRandom::GetInt(int min, int max)
-{
-    int range = max - min;
-    RG_ASSERT(range >= 2);
-
-    unsigned int treshold = (UINT_MAX - UINT_MAX % range);
-
-    unsigned int x;
-    do {
-        Fill(&x, RG_SIZE(x));
-    } while (x >= treshold);
-    x %= range;
-
-    return min + (int)x;
-}
-
-uint64_t FastRandom::Next()
-{
-    // xoshiro256++ by David Blackman and Sebastiano Vigna (vigna@acm.org)
-    // Hopefully I did not screw it up :)
-
-    uint64_t result = ROTL64(state[0] + state[3], 23) + state[0];
-    uint64_t t = state[1] << 17;
-
-    state[2] ^= state[0];
-    state[3] ^= state[1];
-    state[1] ^= state[2];
-    state[0] ^= state[3];
-    state[2] ^= t;
-    state[3] = ROTL64(state[3], 45);
-
-    return result;
-}
-
 static RG_THREAD_LOCAL Size rnd_remain;
 static RG_THREAD_LOCAL int64_t rnd_time;
 #ifndef _WIN32
@@ -5143,6 +5090,17 @@ static RG_THREAD_LOCAL uint32_t rnd_state[16];
 static RG_THREAD_LOCAL uint8_t rnd_buf[64];
 static RG_THREAD_LOCAL Size rnd_offset;
 
+static thread_local FastRandom rng_fast;
+
+static inline uint32_t ROTL32(uint32_t v, int n)
+{
+    return (v << n) | (v >> (32 - n));
+}
+
+static inline uint64_t ROTL64(uint64_t v, int n) {
+    return (v << n) | (v >> (64 - n));
+}
+
 static void InitChaCha20(uint32_t state[16], uint32_t key[8], uint32_t iv[2])
 {
     alignas(uint32_t) static char str[] = "expand 32-byte k";
@@ -5249,18 +5207,18 @@ void FillRandomSafe(void *out_buf, Size len)
 
         memset(rnd_state, 0, RG_SIZE(rnd_state));
 #if defined(_WIN32)
-        RG_CRITICAL(RtlGenRandom(&buf, RG_SIZE(buf)), "RtlGenRandom() failed: %s", GetWin32ErrorString());
+        RG_CRITICAL(RtlGenRandom(&buf, RG_SIZE(buf)), "RtlGenRandom() failed: %1", GetWin32ErrorString());
 #elif defined(__linux__)
         {
 restart:
             int ret = syscall(SYS_getrandom, &buf, RG_SIZE(buf), 0);
-            RG_CRITICAL(ret >= 0, "getentropy() failed: %s", strerror(errno));
+            RG_CRITICAL(ret >= 0, "getentropy() failed: %1", strerror(errno));
 
             if (ret < RG_SIZE(buf))
                 goto restart;
         }
 #else
-        RG_CRITICAL(getentropy(&buf, RG_SIZE(buf)) == 0, "getentropy() failed: %s", strerror(errno));
+        RG_CRITICAL(getentropy(&buf, RG_SIZE(buf)) == 0, "getentropy() failed: %1", strerror(errno));
 #endif
 
         InitChaCha20(rnd_state, buf.key, buf.iv);
@@ -5310,6 +5268,75 @@ int GetRandomIntSafe(int min, int max)
     return min + (int)x;
 }
 
+FastRandom::FastRandom()
+{
+    do {
+        FillRandomSafe(state, RG_SIZE(state));
+    } while (std::all_of(std::begin(state), std::end(state), [](uint64_t v) { return !v; }));
+}
+
+FastRandom::FastRandom(uint64_t seed)
+{
+    // splitmix64 generator to seed xoshiro256++, as recommended
+
+    seed += 0x9e3779b97f4a7c15;
+
+    for (int i = 0; i < 4; i++) {
+        seed = (seed ^ (seed >> 30)) * 0xbf58476d1ce4e5b9;
+        seed = (seed ^ (seed >> 27)) * 0x94d049bb133111eb;
+        state[i] = seed ^ (seed >> 31);
+    }
+}
+
+void FastRandom::Fill(void *out_buf, Size len)
+{
+    for (Size i = 0; i < len; i += 8) {
+        uint64_t rnd = Next();
+
+        Size copy_len = std::min(RG_SIZE(rnd), len - i);
+        memcpy((uint8_t *)out_buf + i, &rnd, copy_len);
+    }
+}
+
+int FastRandom::GetInt(int min, int max)
+{
+    int range = max - min;
+    RG_ASSERT(range >= 2);
+
+    unsigned int treshold = (UINT_MAX - UINT_MAX % range);
+
+    unsigned int x;
+    do {
+        x = (unsigned int)Next();
+    } while (x >= treshold);
+    x %= range;
+
+    return min + (int)x;
+}
+
+uint64_t FastRandom::Next()
+{
+    // xoshiro256++ by David Blackman and Sebastiano Vigna (vigna@acm.org)
+    // Hopefully I did not screw it up :)
+
+    uint64_t result = ROTL64(state[0] + state[3], 23) + state[0];
+    uint64_t t = state[1] << 17;
+
+    state[2] ^= state[0];
+    state[3] ^= state[1];
+    state[1] ^= state[2];
+    state[0] ^= state[3];
+    state[2] ^= t;
+    state[3] = ROTL64(state[3], 45);
+
+    return result;
+}
+
+int GetRandomIntFast(int min, int max)
+{
+    return rng_fast.GetInt(min, max);
+}
+
 // ------------------------------------------------------------------------
 // Sockets
 // ------------------------------------------------------------------------
@@ -5515,7 +5542,10 @@ struct Task {
     std::function<bool()> func;
 };
 
-struct TaskQueue {
+struct WorkerData {
+    AsyncPool *pool = nullptr;
+    int idx;
+
     std::mutex queue_mutex;
     BucketArray<Task> tasks;
 };
@@ -5531,15 +5561,13 @@ class AsyncPool {
     int refcount = 0;
 
     int async_count = 0;
-    HeapArray<bool> workers_state;
-
-    HeapArray<TaskQueue> queues;
+    HeapArray<WorkerData> workers;
     std::atomic_int pending_tasks { 0 };
 
 public:
     AsyncPool(int threads, bool leak);
 
-    int GetWorkerCount() const { return (int)queues.len; }
+    int GetWorkerCount() const { return (int)workers.len; }
     int CountPendingTasks() const { return pending_tasks; }
 
     void RegisterAsync();
@@ -5550,7 +5578,7 @@ public:
     void RunWorker(int worker_idx);
     void SyncOn(Async *async);
 
-    void RunTasks(int queue_idx);
+    void RunTasks(int worker_idx);
     void RunTask(Task *task);
 };
 
@@ -5641,25 +5669,72 @@ AsyncPool::AsyncPool(int threads, bool leak)
         threads = RG_ASYNC_MAX_THREADS;
     }
 
-    // The first queue is for the main thread, whereas workers_state[0] is
-    // not used but it's easier to index it the same way.
-    workers_state.AppendDefault(threads);
-    queues.AppendDefault(threads);
+    // The first queue is for the main thread
+    workers.AppendDefault(threads);
 
     refcount = leak;
 }
 
+#ifdef _WIN32
+
+static DWORD WINAPI RunWorkerWin32(void *udata)
+{
+    WorkerData *worker = (WorkerData *)udata;
+    worker->pool->RunWorker(worker->idx);
+    return 0;
+}
+
+#else
+
+static void *RunWorkerPthread(void *udata)
+{
+    WorkerData *worker = (WorkerData *)udata;
+    worker->pool->RunWorker(worker->idx);
+    return nullptr;
+}
+
+#endif
+
 void AsyncPool::RegisterAsync()
 {
     std::lock_guard<std::mutex> lock_pool(pool_mutex);
 
     if (!async_count++) {
-        for (int i = 1; i < workers_state.len; i++) {
-            if (!workers_state[i]) {
-                std::thread(&AsyncPool::RunWorker, this, i).detach();
+        for (int i = 1; i < workers.len; i++) {
+            WorkerData *worker = &workers[i];
+
+            if (!worker->pool) {
+                worker->pool = this;
+                worker->idx = i;
+
+#ifdef _WIN32
+                // Our worker threads may exit after main() has returned (or exit has been called),
+                // which can trigger crashes in _Cnd_do_broadcast_at_thread_exit() because it
+                // tries to dereference destroyed stuff. It turns out that std::thread calls this
+                // function, and we don't want that, so avoid std::thread on Windows.
+                HANDLE h = CreateThread(nullptr, 0, RunWorkerWin32, worker, 0, nullptr);
+                if (!h) [[unlikely]] {
+                    LogError("Failed to create worker thread: %1", GetWin32ErrorString());
+
+                    worker->pool = nullptr;
+                    return;
+                }
+
+                CloseHandle(h);
+#else
+                pthread_t thread;
+                int ret = pthread_create(&thread, nullptr, RunWorkerPthread, worker);
+                if (ret) [[unlikely]] {
+                    LogError("Failed to create worker thread: %1", strerror(ret));
+
+                    worker->pool = nullptr;
+                    return;
+                }
+
+                pthread_detach(thread);
+#endif
 
                 refcount++;
-                workers_state[i] = true;
             }
         }
     }
@@ -5675,20 +5750,20 @@ void AsyncPool::AddTask(Async *async, const std::function<bool()> &func)
 {
     if (async_running_pool != async->pool) {
         for (;;) {
-            int idx = GetRandomIntSafe(0, queues.len);
-            TaskQueue *queue = &queues[idx];
+            int idx = GetRandomIntFast(0, (int)workers.len);
+            WorkerData *worker = &workers[idx];
 
-            std::unique_lock<std::mutex> lock_queue(queue->queue_mutex, std::try_to_lock);
+            std::unique_lock<std::mutex> lock_queue(worker->queue_mutex, std::try_to_lock);
             if (lock_queue.owns_lock()) {
-                queue->tasks.Append({ async, func });
+                worker->tasks.Append({ async, func });
                 break;
             }
         }
     } else {
-        TaskQueue *queue = &queues[async_running_worker_idx];
+        WorkerData *worker = &workers[async_running_worker_idx];
 
-        std::lock_guard<std::mutex> lock_queue(queue->queue_mutex);
-        queue->tasks.Append({ async, func });
+        std::lock_guard<std::mutex> lock_queue(worker->queue_mutex);
+        worker->tasks.Append({ async, func });
     }
 
     async->remaining_tasks++;
@@ -5718,7 +5793,8 @@ void AsyncPool::RunWorker(int worker_idx)
         pending_cv.wait_for(lock_pool, duration, [&]() { return !!pending_tasks; });
     }
 
-    workers_state[worker_idx] = false;
+    workers[worker_idx].pool = nullptr;
+
     if (!--refcount) {
         lock_pool.unlock();
         delete this;
@@ -5737,31 +5813,31 @@ void AsyncPool::SyncOn(Async *async)
     async_running_worker_idx = 0;
 
     while (async->remaining_tasks) {
-        RunTasks(async_running_worker_idx);
+        RunTasks(0);
 
         std::unique_lock<std::mutex> lock_sync(pool_mutex);
         sync_cv.wait(lock_sync, [&]() { return pending_tasks || !async->remaining_tasks; });
     }
 }
 
-void AsyncPool::RunTasks(int queue_idx)
+void AsyncPool::RunTasks(int worker_idx)
 {
     // The '12' factor is pretty arbitrary, don't try to find meaning there
-    for (int i = 0; i < workers_state.len * 12; i++) {
-        TaskQueue *queue = &queues[queue_idx];
-        std::unique_lock<std::mutex> lock_queue(queue->queue_mutex, std::try_to_lock);
+    for (int i = 0; i < workers.len * 12; i++) {
+        WorkerData *worker = &workers[worker_idx];
+        std::unique_lock<std::mutex> lock_queue(worker->queue_mutex, std::try_to_lock);
 
-        if (lock_queue.owns_lock() && queue->tasks.len) {
-            Task task = std::move(queue->tasks[0]);
+        if (lock_queue.owns_lock() && worker->tasks.len) {
+            Task task = std::move(worker->tasks[0]);
 
-            queue->tasks.RemoveFirst();
-            queue->tasks.Trim();
+            worker->tasks.RemoveFirst();
+            worker->tasks.Trim();
 
             lock_queue.unlock();
 
             RunTask(&task);
         } else {
-            queue_idx = (++queue_idx < queues.len) ? queue_idx : 0;
+            worker_idx = (++worker_idx < workers.len) ? worker_idx : 0;
         }
     }
 }
@@ -5980,10 +6056,16 @@ void Fiber::FiberCallback(unsigned int high, unsigned int low)
 static RG_THREAD_LOCAL std::unique_lock<std::mutex> *fib_lock;
 static RG_THREAD_LOCAL Fiber *fib_self;
 
-Fiber::Fiber(const std::function<bool()> &f, Size stack_size)
+Fiber::Fiber(const std::function<bool()> &f, Size)
     : f(f)
 {
-    thread = std::thread(ThreadCallback, this);
+    int ret = pthread_create(&thread, nullptr, ThreadCallback, this);
+    if (ret) {
+        LogError("Failed to create thread: %1", strerror(ret));
+        return;
+    }
+    joinable = true;
+
     done = false;
 
     while (toggle == 1) {
@@ -5996,8 +6078,8 @@ Fiber::~Fiber()
     // We are forced to execute it until the end
     Finalize();
 
-    if (thread.joinable()) {
-        thread.join();
+    if (joinable) {
+        pthread_join(thread, nullptr);
     }
 }
 
@@ -6028,7 +6110,7 @@ bool Fiber::SwitchBack()
     }
 }
 
-void Fiber::ThreadCallback(void *udata)
+void *Fiber::ThreadCallback(void *udata)
 {
     Fiber *self = (Fiber *)udata;
 
@@ -6045,6 +6127,8 @@ void Fiber::ThreadCallback(void *udata)
 
     self->toggle = 0;
     self->cv.notify_one();
+
+    return nullptr;
 }
 
 void Fiber::Toggle(int to, std::unique_lock<std::mutex> *lock)

package/src/core/libcc/libcc.hh

@@ -3853,9 +3853,6 @@ Size ConvertWin32WideToUtf8(const wchar_t *str_w, Span<char> out_str);
 char *GetWin32ErrorString(uint32_t error_code = UINT32_MAX);
 #endif
 
-void SetEnvironmentVar(const char *name, const char *value);
-void DeleteEnvironmentVar(const char *name);
-
 static inline bool IsPathSeparator(char c)
 {
 #ifdef _WIN32
@@ -4055,17 +4052,29 @@ bool CreatePipe(int pfd[2]);
 void CloseDescriptorSafe(int *fd_ptr);
 #endif
 
-bool ExecuteCommandLine(const char *cmd_line, const char *work_dir,
+struct ExecuteInfo {
+    struct KeyValue {
+        const char *key;
+        const char *value;
+    };
+
+    const char *work_dir = nullptr;
+
+    bool reset_env = false;
+    Span<const KeyValue> env_variables = {};
+};
+
+bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,
                         FunctionRef<Span<const uint8_t>()> in_func,
                         FunctionRef<void(Span<uint8_t> buf)> out_func, int *out_code);
-bool ExecuteCommandLine(const char *cmd_line, const char *work_dir,
+bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,
                         Span<const uint8_t> in_buf, Size max_len,
                         HeapArray<uint8_t> *out_buf, int *out_code);
 
 // Simple variants
-static inline bool ExecuteCommandLine(const char *cmd_line, const char *work_dir, int *out_code)
-    { return ExecuteCommandLine(cmd_line, work_dir, {}, {}, out_code); }
-static inline bool ExecuteCommandLine(const char *cmd_line, const char *work_dir,
+static inline bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,int *out_code)
+    { return ExecuteCommandLine(cmd_line, info, {}, {}, out_code); }
+static inline bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,
                                       Span<const uint8_t> in_buf,
                                       FunctionRef<void(Span<uint8_t> buf)> out_func, int *out_code)
 {
@@ -4075,22 +4084,22 @@ static inline bool ExecuteCommandLine(const char *cmd_line, const char *work_dir
         return buf;
     };
 
-    return ExecuteCommandLine(cmd_line, work_dir, read_once, out_func, out_code);
+    return ExecuteCommandLine(cmd_line, info, read_once, out_func, out_code);
 }
 
 // Char variants
-static inline bool ExecuteCommandLine(const char *cmd_line, const char *work_dir,
+static inline bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,
                                       Span<const char> in_buf,
                                       FunctionRef<void(Span<char> buf)> out_func, int *out_code)
 {
     const auto write = [&](Span<uint8_t> buf) { out_func(buf.As<char>()); };
-    return ExecuteCommandLine(cmd_line, work_dir, in_buf.As<const uint8_t>(), write, out_code);
+    return ExecuteCommandLine(cmd_line, info, in_buf.As<const uint8_t>(), write, out_code);
 }
-static inline bool ExecuteCommandLine(const char *cmd_line, const char *work_dir,
+static inline bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,
                                       Span<const char> in_buf, Size max_len,
                                       HeapArray<char> *out_buf, int *out_code)
 {
-    return ExecuteCommandLine(cmd_line, work_dir, in_buf.As<const uint8_t>(), max_len,
+    return ExecuteCommandLine(cmd_line, info, in_buf.As<const uint8_t>(), max_len,
                               (HeapArray<uint8_t> *)out_buf, out_code);
 }
 
@@ -4158,6 +4167,11 @@ const char *CreateUniqueDirectory(Span<const char> directory, const char *prefix
 // Random
 // ------------------------------------------------------------------------
 
+void ZeroMemorySafe(void *ptr, Size len);
+void FillRandomSafe(void *buf, Size len);
+static inline void FillRandomSafe(Span<uint8_t> buf) { FillRandomSafe(buf.ptr, buf.len); }
+int GetRandomIntSafe(int min, int max);
+
 class FastRandom {
     uint64_t state[4];
 
@@ -4190,10 +4204,7 @@ public:
     int operator()() { return rng.GetInt(Min, Max); }
 };
 
-void ZeroMemorySafe(void *ptr, Size len);
-void FillRandomSafe(void *buf, Size len);
-static inline void FillRandomSafe(Span<uint8_t> buf) { FillRandomSafe(buf.ptr, buf.len); }
-int GetRandomIntSafe(int min, int max);
+int GetRandomIntFast(int min, int max);
 
 // ------------------------------------------------------------------------
 // Sockets
@@ -4269,7 +4280,8 @@ class Fiber {
 #elif defined(RG_FIBER_USE_UCONTEXT)
     ucontext_t ucp = {};
 #else
-    std::thread thread;
+    pthread_t thread;
+    bool joinable = false;
 
     std::mutex mutex;
     std::condition_variable cv;
@@ -4297,7 +4309,7 @@ private:
 #elif defined(RG_FIBER_USE_UCONTEXT)
     static void FiberCallback(unsigned int high, unsigned int low);
 #else
-    static void ThreadCallback(void *udata);
+    static void *ThreadCallback(void *udata);
     void Toggle(int to, std::unique_lock<std::mutex> *lock);
 #endif
 };

package/src/koffi/CMakeLists.txt

@@ -31,17 +31,17 @@ find_package(CNoke)
 set(CMAKE_CXX_STANDARD 20)
 if(MSVC)
     set(CMAKE_MSVC_RUNTIME_LIBRARY MultiThreaded)
-
-    add_compile_options(/Zc:__cplusplus /W4 /wd4200 /wd4458 /wd4706 /wd4100 /wd4127 /wd4702 /wd4201 /wd4324)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Zc:__cplusplus /W4 /wd4200 /wd4201 /wd4127 /wd4458 /wd4706 /wd4702 /wd4324")
 
     # ASM_MASM does not (yet) work on Windows ARM64
     if(NOT CMAKE_GENERATOR_PLATFORM MATCHES "ARM64")
         enable_language(ASM_MASM)
     endif()
 else()
-    add_compile_options(-Wall -Wextra -Wno-missing-field-initializers -Wno-unused-parameter -Wswitch -Werror=switch)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wno-missing-field-initializers -Wno-unused-parameter -Wswitch -Werror=switch")
+
     if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-        add_compile_options(-Wno-unknown-warning-option)
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unknown-warning-option")
     endif()
 endif()
 
@@ -132,16 +132,16 @@ if(NOT MSVC OR CMAKE_C_COMPILER_ID MATCHES "[Cc]lang")
     # Restore C/C++ compiler sanity
 
     if(NOT MSVC)
-        target_compile_options(koffi PRIVATE -fno-exceptions -fno-strict-aliasing -fwrapv
-                                             -fno-delete-null-pointer-checks)
+        target_compile_options(koffi PRIVATE $<$<COMPILE_LANGUAGE:CXX>:-fno-exceptions -fno-strict-aliasing -fwrapv
+                                                                       -fno-delete-null-pointer-checks>)
     else()
-        target_compile_options(koffi PRIVATE -fno-strict-aliasing /clang:-fwrapv
-                                             -fno-delete-null-pointer-checks)
+        target_compile_options(koffi PRIVATE $<$<COMPILE_LANGUAGE:CXX>:-fno-strict-aliasing /clang:-fwrapv
+                                                                       -fno-delete-null-pointer-checks>)
     endif()
 
     check_cxx_compiler_flag(-fno-finite-loops use_no_finite_loops)
     if(use_no_finite_loops)
-        target_compile_options(koffi PRIVATE -fno-finite-loops)
+        target_compile_options(koffi PRIVATE $<$<COMPILE_LANGUAGE:CXX>:-fno-finite-loops>)
     endif()
 endif()
 enable_unity_build(koffi)

package/src/koffi/src/ffi.cc

@@ -2224,7 +2224,7 @@ static Napi::Value ResetKoffi(const Napi::CallbackInfo &info)
     return env.Undefined();
 }
 
-static InstanceData *CreateInstance(Napi::Env env)
+static InstanceData *CreateInstance()
 {
     InstanceData *instance = new InstanceData();
     RG_DEFER_N(err_guard) { delete instance; };
@@ -2247,7 +2247,7 @@ static InstanceData *CreateInstance(Napi::Env env)
 
 static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
 {
-    InstanceData *instance = CreateInstance(env);
+    InstanceData *instance = CreateInstance();
     RG_CRITICAL(instance, "Failed to initialize Koffi");
 
     env.SetInstanceData(instance);

package/src/koffi/src/win32.cc

@@ -79,7 +79,7 @@ static bool ReadAt(HANDLE h, int32_t offset, void *buf, int len)
         return false;
     if (!ReadFile(h, buf, (DWORD)len, &read, &ov))
         return false;
-    if (read != len)
+    if (read != (DWORD)len)
         return false;
 
     return true;