@velox0/cerver 0.6.2 → 0.6.3

package/runtime/tests/runtime_tests.c

@@ -8,10 +8,49 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <sys/mman.h>
 #include <sys/stat.h>
 #include <time.h>
+
+#if CERVER_PLATFORM_WINDOWS
+#include <direct.h>
+#include <io.h>
+#ifndef PATH_MAX
+#define PATH_MAX _MAX_PATH
+#endif  // PATH_MAX
+#define cerver_test_open              _open
+#define cerver_test_close             _close
+#define cerver_test_read              _read
+#define cerver_test_write             _write
+#define cerver_test_pipe(fds)         _pipe((fds), 4096, _O_BINARY)
+#define cerver_test_unlink            _unlink
+#define cerver_test_rmdir             _rmdir
+#define cerver_test_mkdir(path, mode) _mkdir(path)
+#else
+#include <sys/mman.h>
 #include <unistd.h>
+#define cerver_test_open              open
+#define cerver_test_close             close
+#define cerver_test_read              read
+#define cerver_test_write             write
+#define cerver_test_pipe(fds)         pipe((fds))
+#define cerver_test_unlink            unlink
+#define cerver_test_rmdir             rmdir
+#define cerver_test_mkdir(path, mode) mkdir((path), (mode))
+#endif  // CERVER_PLATFORM_WINDOWS
+
+#if !CERVER_PLATFORM_WINDOWS
+char* mkdtemp(char* tmpl);
+#endif  // !CERVER_PLATFORM_WINDOWS
+
+static char* cerver_test_mkdtemp(char* tmpl) {
+#if CERVER_PLATFORM_WINDOWS
+  if (_mktemp(tmpl) == NULL) return NULL;
+  if (_mkdir(tmpl) != 0) return NULL;
+  return tmpl;
+#else
+  return mkdtemp(tmpl);
+#endif  // CERVER_PLATFORM_WINDOWS
+}
 
 static const char* res_header(const cerver_response_t* res, const char* key) {
   for (int i = 0; i < res->header_count; i++) {
@@ -29,28 +68,28 @@ static void req_add_header(cerver_request_t* req, const char* key, const char* v
 }
 
 static int write_file(const char* path, const void* data, size_t len) {
-  int fd = open(path, O_CREAT | O_WRONLY | O_TRUNC, 0600);
+  int fd = cerver_test_open(path, O_CREAT | O_WRONLY | O_TRUNC, 0600);
   if (fd < 0) {
     return -1;
   }
   const unsigned char* p   = (const unsigned char*)data;
   size_t               off = 0;
   while (off < len) {
-    ssize_t n = write(fd, p + off, len - off);
+    ssize_t n = cerver_test_write(fd, p + off, len - off);
     if (n <= 0) {
-      close(fd);
+      cerver_test_close(fd);
       return -1;
     }
     off += (size_t)n;
   }
-  close(fd);
+  cerver_test_close(fd);
   return 0;
 }
 
 static ssize_t read_all(int fd, char* buf, size_t cap) {
   size_t off = 0;
   while (off + 1 < cap) {
-    ssize_t n = read(fd, buf + off, cap - off - 1);
+    ssize_t n = cerver_test_read(fd, buf + off, cap - off - 1);
     if (n < 0) {
       return -1;
     }
@@ -114,7 +153,7 @@ static void test_parse_request_trailing_slash(void) {
 
 static void test_write_response_keepalive(void) {
   int fds[2];
-  MU_ASSERT(pipe(fds) == 0);
+  MU_ASSERT(cerver_test_pipe(fds) == 0);
 
   cerver_response_t res;
   memset(&res, 0, sizeof(res));
@@ -122,11 +161,11 @@ static void test_write_response_keepalive(void) {
   cerver_res_header(&res, "X-Test", "1");
 
   MU_ASSERT_EQ_INT(0, cerver_write_response(fds[1], &res, 1));
-  close(fds[1]);
+  cerver_test_close(fds[1]);
 
   char out[1024];
   MU_ASSERT(read_all(fds[0], out, sizeof(out)) > 0);
-  close(fds[0]);
+  cerver_test_close(fds[0]);
 
   MU_ASSERT(strstr(out, "HTTP/1.1 200 OK\r\n") != NULL);
   MU_ASSERT(strstr(out, "Content-Type: text/plain; charset=utf-8\r\n") != NULL);
@@ -139,7 +178,7 @@ static void test_write_response_keepalive(void) {
 
 static void test_write_response_force_close(void) {
   int fds[2];
-  MU_ASSERT(pipe(fds) == 0);
+  MU_ASSERT(cerver_test_pipe(fds) == 0);
 
   cerver_response_t res;
   memset(&res, 0, sizeof(res));
@@ -147,11 +186,11 @@ static void test_write_response_force_close(void) {
   res._force_close = 1;
 
   MU_ASSERT_EQ_INT(0, cerver_write_response(fds[1], &res, 1));
-  close(fds[1]);
+  cerver_test_close(fds[1]);
 
   char out[512];
   MU_ASSERT(read_all(fds[0], out, sizeof(out)) > 0);
-  close(fds[0]);
+  cerver_test_close(fds[0]);
 
   MU_ASSERT(strstr(out, "Connection: close\r\n") != NULL);
 }
@@ -314,7 +353,7 @@ static void test_static_embedded_index_fallback(void) {
 
 static void test_static_filesystem_directory_fallback(void) {
   char  dir_template[] = "/tmp/cerver-test-XXXXXX";
-  char* dir            = mkdtemp(dir_template);
+  char* dir            = cerver_test_mkdtemp(dir_template);
   MU_ASSERT(dir != NULL);
 
   /* Create public/index.html (maps to /) */
@@ -325,7 +364,7 @@ static void test_static_filesystem_directory_fallback(void) {
   /* Create public/about/about.html (maps to /about or /about/) */
   char sub_dir[PATH_MAX];
   snprintf(sub_dir, sizeof(sub_dir), "%s/about", dir);
-  MU_ASSERT_EQ_INT(0, mkdir(sub_dir, 0700));
+  MU_ASSERT_EQ_INT(0, cerver_test_mkdir(sub_dir, 0700));
 
   char file_path2[PATH_MAX];
   snprintf(file_path2, sizeof(file_path2), "%s/about/about.html", dir);
@@ -352,7 +391,7 @@ static void test_static_filesystem_directory_fallback(void) {
 
     MU_ASSERT_EQ_INT(0, cerver_serve_static(&srv, &req, &res));
     MU_ASSERT_EQ_SIZE(10, res.body_len);
-    if (res._body_owned == 3 && res._file_fd >= 0) close(res._file_fd);
+    if (res._body_owned == 3 && res._file_fd >= 0) cerver_test_close(res._file_fd);
   }
 
   /* Test /about -> about/about.html fallback */
@@ -366,7 +405,7 @@ static void test_static_filesystem_directory_fallback(void) {
 
     MU_ASSERT_EQ_INT(0, cerver_serve_static(&srv, &req, &res));
     MU_ASSERT_EQ_SIZE(13, res.body_len);
-    if (res._body_owned == 3 && res._file_fd >= 0) close(res._file_fd);
+    if (res._body_owned == 3 && res._file_fd >= 0) cerver_test_close(res._file_fd);
   }
 
   /* Test /about/ -> about/about.html fallback */
@@ -380,19 +419,19 @@ static void test_static_filesystem_directory_fallback(void) {
 
     MU_ASSERT_EQ_INT(0, cerver_serve_static(&srv, &req, &res));
     MU_ASSERT_EQ_SIZE(13, res.body_len);
-    if (res._body_owned == 3 && res._file_fd >= 0) close(res._file_fd);
+    if (res._body_owned == 3 && res._file_fd >= 0) cerver_test_close(res._file_fd);
   }
 
-  unlink(file_path);
-  unlink(file_path2);
-  unlink(file_path3);
-  rmdir(sub_dir);
-  rmdir(dir);
+  cerver_test_unlink(file_path);
+  cerver_test_unlink(file_path2);
+  cerver_test_unlink(file_path3);
+  cerver_test_rmdir(sub_dir);
+  cerver_test_rmdir(dir);
 }
 
 static void test_static_filesystem_small(void) {
   char  dir_template[] = "/tmp/cerver-test-XXXXXX";
-  char* dir            = mkdtemp(dir_template);
+  char* dir            = cerver_test_mkdtemp(dir_template);
   MU_ASSERT(dir != NULL);
 
   char file_path[PATH_MAX];
@@ -417,29 +456,29 @@ static void test_static_filesystem_small(void) {
   MU_ASSERT(res._file_fd >= 0);
 
   int fds[2];
-  MU_ASSERT(pipe(fds) == 0);
+  MU_ASSERT(cerver_test_pipe(fds) == 0);
   MU_ASSERT_EQ_INT(0, cerver_write_response(fds[1], &res, 1));
-  close(fds[1]);
+  cerver_test_close(fds[1]);
 
   char    out[1024];
   ssize_t n = read_all(fds[0], out, sizeof(out));
   MU_ASSERT(n > 0);
-  close(fds[0]);
+  cerver_test_close(fds[0]);
 
   MU_ASSERT(strstr(out, "HTTP/1.1 200 OK\r\n") != NULL);
   MU_ASSERT(strstr(out, "Content-Length: 5\r\n") != NULL);
   MU_ASSERT(strstr(out, "\r\nsmall") != NULL);
 
   if (res._body_owned == 3 && res._file_fd >= 0) {
-    close(res._file_fd);
+    cerver_test_close(res._file_fd);
   }
-  unlink(file_path);
-  rmdir(dir);
+  cerver_test_unlink(file_path);
+  cerver_test_rmdir(dir);
 }
 
 static void test_static_filesystem_large(void) {
   char  dir_template[] = "/tmp/cerver-test-XXXXXX";
-  char* dir            = mkdtemp(dir_template);
+  char* dir            = cerver_test_mkdtemp(dir_template);
   MU_ASSERT(dir != NULL);
 
   char file_path[PATH_MAX];
@@ -469,23 +508,23 @@ static void test_static_filesystem_large(void) {
   MU_ASSERT(res._file_fd >= 0);
 
   int fds[2];
-  MU_ASSERT(pipe(fds) == 0);
+  MU_ASSERT(cerver_test_pipe(fds) == 0);
   MU_ASSERT_EQ_INT(0, cerver_write_response(fds[1], &res, 1));
-  close(fds[1]);
+  cerver_test_close(fds[1]);
 
   char    out[35000];
   ssize_t n = read_all(fds[0], out, sizeof(out));
   MU_ASSERT(n > 0);
-  close(fds[0]);
+  cerver_test_close(fds[0]);
 
   MU_ASSERT(strstr(out, "HTTP/1.1 200 OK\r\n") != NULL);
   MU_ASSERT(strstr(out, "Content-Length: 32000\r\n") != NULL);
 
   if (res._body_owned == 3 && res._file_fd >= 0) {
-    close(res._file_fd);
+    cerver_test_close(res._file_fd);
   }
-  unlink(file_path);
-  rmdir(dir);
+  cerver_test_unlink(file_path);
+  cerver_test_rmdir(dir);
 }
 
 static void test_static_rejects_unsafe_path(void) {
@@ -517,8 +556,8 @@ static void test_cerver_init_fields(void) {
   cerver_server_t srv;
   cerver_init(&srv, 9090, 3);
   MU_ASSERT_EQ_INT(9090, srv.port);
-  MU_ASSERT_EQ_INT(3, srv.worker_count);
-  MU_ASSERT_EQ_INT(-1, srv.sock_fd);
+  MU_ASSERT_EQ_INT(3, srv.connection_worker_count);
+  MU_ASSERT(srv.sock_fd == CERVER_INVALID_SOCK);
   MU_ASSERT_EQ_INT(0, srv.running);
 }
 

package/runtime/win_compat.h

@@ -2,7 +2,8 @@
  * win_compat.h — Windows (Winsock2 / MSVC / MinGW) compatibility shim.
  *
  * Include BEFORE any system headers in files that use sockets, threads,
- * or POSIX I/O.  On non-Windows platforms this header is a no-op.
+ * or POSIX I/O. On non-Windows platforms this exposes POSIX-backed
+ * runtime aliases.
  */
 
 #ifndef CERVER_WIN_COMPAT_H
@@ -21,16 +22,17 @@
 #include <winsock2.h>
 #include <ws2tcpip.h>
 #include <windows.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
 #include <io.h>
+#include <fcntl.h>
 #include <process.h>
 #include <time.h>
 
-/* ---- pthread shim via Windows threads --------------------------- */
-/* We bundle a minimal pthreads-win32 surface so the rest of the code
-   can stay unchanged.  Only the primitives actually used by cerver are
-   mapped; this is NOT a general replacement.                          */
-
-#include <pthread.h>
+/* ---- native thread primitives ------------------------------------ */
+/* Only the primitives actually used by cerver are exposed here. */
 
 /* ---- POSIX socket aliases --------------------------------------- */
 typedef SOCKET cerver_sock_t;
@@ -77,17 +79,23 @@ static inline void* cerver_memmem_win(const void* hay, size_t hlen, const void*
 #define memmem cerver_memmem_win
 #endif  // memmem
 
-/* clock_gettime is missing before MSVC 2019 / older MinGW */
-#if defined(_MSC_VER) && _MSC_VER < 1900
-#include <windows.h>
+/* POSIX case-insensitive string helpers are named differently by the Windows CRT. */
+#ifndef strcasecmp
+#define strcasecmp _stricmp
+#endif  // strcasecmp
+
+/* clock_gettime / CLOCK_REALTIME are missing from some Windows CRTs. */
 #ifndef CLOCK_REALTIME
 #define CLOCK_REALTIME 0
-typedef struct {
+typedef struct cerver_timespec_t {
   long tv_sec;
   long tv_nsec;
-} timespec_t;
-#define timespec timespec_t
-static inline int clock_gettime(int, struct timespec* ts) {
+} cerver_timespec_t;
+#ifndef timespec
+#define timespec cerver_timespec_t
+#endif  // timespec
+static inline int clock_gettime(int clk_id, cerver_timespec_t* ts) {
+  (void)clk_id;
   FILETIME ft;
   GetSystemTimeAsFileTime(&ft);
   ULONGLONG t = ((ULONGLONG)ft.dwHighDateTime << 32) | ft.dwLowDateTime;
@@ -97,7 +105,6 @@ static inline int clock_gettime(int, struct timespec* ts) {
   return 0;
 }
 #endif  // CLOCK_REALTIME
-#endif  // _MSC_VER && _MSC_VER < 1900
 
 /* Windows socket error → errno translation for the few codes we check */
 static inline int cerver_would_block_win(void) {
@@ -124,6 +131,170 @@ static inline long cerver_nproc_win(void) {
 #endif  // SIGPIPE
 /* SIG_IGN is defined in <signal.h> on Windows */
 
+/* ---- native Windows thread backend ------------------------------- */
+typedef SRWLOCK            cerver_mutex_t;
+typedef CONDITION_VARIABLE cerver_cond_t;
+typedef INIT_ONCE          cerver_fetch_global_init_guard_t;
+typedef HANDLE             cerver_connection_worker_thread_t;
+typedef HANDLE             cerver_acceptor_thread_t;
+typedef size_t             cerver_connection_worker_thread_attr_t;
+typedef size_t             cerver_acceptor_thread_attr_t;
+
+#define CERVER_MUTEX_INITIALIZER                   SRWLOCK_INIT
+#define CERVER_COND_INITIALIZER                    CONDITION_VARIABLE_INIT
+#define CERVER_FETCH_GLOBAL_INIT_GUARD_INITIALIZER INIT_ONCE_STATIC_INIT
+
+static inline int cerver_mutex_init(cerver_mutex_t* m, void* attr) {
+  (void)attr;
+  InitializeSRWLock(m);
+  return 0;
+}
+static inline int cerver_mutex_destroy(cerver_mutex_t* m) {
+  (void)m;
+  return 0;
+}
+static inline int cerver_mutex_lock(cerver_mutex_t* m) {
+  AcquireSRWLockExclusive(m);
+  return 0;
+}
+static inline int cerver_mutex_unlock(cerver_mutex_t* m) {
+  ReleaseSRWLockExclusive(m);
+  return 0;
+}
+
+static inline int cerver_cond_init(cerver_cond_t* c, void* attr) {
+  (void)attr;
+  InitializeConditionVariable(c);
+  return 0;
+}
+static inline int cerver_cond_destroy(cerver_cond_t* c) {
+  (void)c;
+  return 0;
+}
+static inline int cerver_cond_wait(cerver_cond_t* c, cerver_mutex_t* m) {
+  SleepConditionVariableSRW(c, m, INFINITE, 0);
+  return 0;
+}
+static inline int cerver_cond_timedwait(cerver_cond_t* c, cerver_mutex_t* m,
+                                        const struct timespec* ts) {
+  FILETIME ft;
+  GetSystemTimeAsFileTime(&ft);
+  ULONGLONG t = ((ULONGLONG)ft.dwHighDateTime << 32) | ft.dwLowDateTime;
+  t -= 116444736000000000ULL;
+  long long now_sec  = (long long)(t / 10000000ULL);
+  long long now_nsec = (long long)((t % 10000000ULL) * 100);
+
+  long long ms = (ts->tv_sec - now_sec) * 1000 + (ts->tv_nsec - now_nsec) / 1000000;
+  if (ms < 0) ms = 0;
+  if (SleepConditionVariableSRW(c, m, (DWORD)ms, 0)) return 0;
+  return 110; /* ETIMEDOUT */
+}
+static inline int cerver_cond_signal(cerver_cond_t* c) {
+  WakeConditionVariable(c);
+  return 0;
+}
+static inline int cerver_cond_broadcast(cerver_cond_t* c) {
+  WakeAllConditionVariable(c);
+  return 0;
+}
+
+static inline int cerver_connection_worker_thread_attr_init(
+    cerver_connection_worker_thread_attr_t* attr) {
+  *attr = 0;
+  return 0;
+}
+static inline int cerver_connection_worker_thread_attr_destroy(
+    cerver_connection_worker_thread_attr_t* attr) {
+  *attr = 0;
+  return 0;
+}
+static inline int cerver_connection_worker_thread_attr_setstacksize(
+    cerver_connection_worker_thread_attr_t* attr, size_t stacksize) {
+  *attr = stacksize;
+  return 0;
+}
+
+static inline int cerver_acceptor_thread_attr_init(cerver_acceptor_thread_attr_t* attr) {
+  *attr = 0;
+  return 0;
+}
+static inline int cerver_acceptor_thread_attr_destroy(cerver_acceptor_thread_attr_t* attr) {
+  *attr = 0;
+  return 0;
+}
+static inline int cerver_acceptor_thread_attr_setstacksize(cerver_acceptor_thread_attr_t* attr,
+                                                           size_t stacksize) {
+  *attr = stacksize;
+  return 0;
+}
+
+struct cerver_windows_thread_entry_args {
+  void* (*func)(void*);
+  void* arg;
+};
+static inline DWORD WINAPI cerver_windows_thread_entry(LPVOID lpParam) {
+  struct cerver_windows_thread_entry_args* args = (struct cerver_windows_thread_entry_args*)lpParam;
+  void* (*func)(void*)                          = args->func;
+  void* arg                                     = args->arg;
+  free(args);
+  func(arg);
+  return 0;
+}
+
+static inline int cerver_start_windows_native_thread(HANDLE* thread, size_t               stack,
+                                                     void* (*start_routine)(void*), void* arg) {
+  struct cerver_windows_thread_entry_args* args =
+      (struct cerver_windows_thread_entry_args*)malloc(sizeof(*args));
+  if (!args) return -1;
+  args->func = start_routine;
+  args->arg  = arg;
+  *thread    = CreateThread(NULL, stack, cerver_windows_thread_entry, args, 0, NULL);
+  if (!*thread) {
+    free(args);
+    return -1;
+  }
+  return 0;
+}
+
+static inline int cerver_connection_worker_thread_create(
+    cerver_connection_worker_thread_t* thread, const cerver_connection_worker_thread_attr_t* attr,
+    void* (*start_routine)(void*), void*                                                     arg) {
+  return cerver_start_windows_native_thread(thread, attr ? *attr : 0, start_routine, arg);
+}
+static inline int cerver_acceptor_thread_create(cerver_acceptor_thread_t*            thread,
+                                                const cerver_acceptor_thread_attr_t* attr,
+                                                void* (*start_routine)(void*), void* arg) {
+  return cerver_start_windows_native_thread(thread, attr ? *attr : 0, start_routine, arg);
+}
+
+static inline int cerver_connection_worker_thread_join(cerver_connection_worker_thread_t thread,
+                                                       void**                            retval) {
+  (void)retval;
+  WaitForSingleObject(thread, INFINITE);
+  CloseHandle(thread);
+  return 0;
+}
+static inline int cerver_acceptor_thread_join(cerver_acceptor_thread_t thread, void** retval) {
+  (void)retval;
+  WaitForSingleObject(thread, INFINITE);
+  CloseHandle(thread);
+  return 0;
+}
+
+static inline BOOL CALLBACK cerver_fetch_global_init_guard_stub(PINIT_ONCE InitOnce,
+                                                                PVOID Parameter, PVOID* Context) {
+  (void)InitOnce;
+  (void)Context;
+  void (*func)(void) = (void (*)(void))Parameter;
+  func();
+  return TRUE;
+}
+static inline int cerver_fetch_global_init_guard_run(cerver_fetch_global_init_guard_t* guard,
+                                                     void (*init_routine)(void)) {
+  InitOnceExecuteOnce(guard, cerver_fetch_global_init_guard_stub, init_routine, NULL);
+  return 0;
+}
+
 /* Winsock init/teardown helpers ----------------------------------- */
 static inline int cerver_wsa_startup(void) {
   WSADATA wd;
@@ -136,6 +307,8 @@ static inline void cerver_wsa_cleanup(void) { WSACleanup(); }
 
 #else /* !Windows */
 
+#include <errno.h>
+#include <pthread.h>
 #include <stddef.h>
 #include <sys/types.h>
 #include <unistd.h>
@@ -153,5 +326,86 @@ static inline ssize_t cerver_sock_write(int fd, const void* buf, size_t n) {
 static inline int  cerver_wsa_startup(void) { return 0; }
 static inline void cerver_wsa_cleanup(void) {}
 
+typedef pthread_mutex_t cerver_mutex_t;
+typedef pthread_cond_t  cerver_cond_t;
+typedef pthread_once_t  cerver_fetch_global_init_guard_t;
+typedef pthread_t       cerver_connection_worker_thread_t;
+typedef pthread_t       cerver_acceptor_thread_t;
+typedef pthread_attr_t  cerver_connection_worker_thread_attr_t;
+typedef pthread_attr_t  cerver_acceptor_thread_attr_t;
+
+#define CERVER_MUTEX_INITIALIZER                   PTHREAD_MUTEX_INITIALIZER
+#define CERVER_COND_INITIALIZER                    PTHREAD_COND_INITIALIZER
+#define CERVER_FETCH_GLOBAL_INIT_GUARD_INITIALIZER PTHREAD_ONCE_INIT
+
+static inline int cerver_mutex_init(cerver_mutex_t* m, void* attr) {
+  return pthread_mutex_init(m, (const pthread_mutexattr_t*)attr);
+}
+static inline int cerver_mutex_destroy(cerver_mutex_t* m) { return pthread_mutex_destroy(m); }
+static inline int cerver_mutex_lock(cerver_mutex_t* m) { return pthread_mutex_lock(m); }
+static inline int cerver_mutex_unlock(cerver_mutex_t* m) { return pthread_mutex_unlock(m); }
+
+static inline int cerver_cond_init(cerver_cond_t* c, void* attr) {
+  return pthread_cond_init(c, (const pthread_condattr_t*)attr);
+}
+static inline int cerver_cond_destroy(cerver_cond_t* c) { return pthread_cond_destroy(c); }
+static inline int cerver_cond_wait(cerver_cond_t* c, cerver_mutex_t* m) {
+  return pthread_cond_wait(c, m);
+}
+static inline int cerver_cond_timedwait(cerver_cond_t* c, cerver_mutex_t* m,
+                                        const struct timespec* ts) {
+  return pthread_cond_timedwait(c, m, ts);
+}
+static inline int cerver_cond_signal(cerver_cond_t* c) { return pthread_cond_signal(c); }
+static inline int cerver_cond_broadcast(cerver_cond_t* c) { return pthread_cond_broadcast(c); }
+
+static inline int cerver_connection_worker_thread_attr_init(
+    cerver_connection_worker_thread_attr_t* attr) {
+  return pthread_attr_init(attr);
+}
+static inline int cerver_connection_worker_thread_attr_destroy(
+    cerver_connection_worker_thread_attr_t* attr) {
+  return pthread_attr_destroy(attr);
+}
+static inline int cerver_connection_worker_thread_attr_setstacksize(
+    cerver_connection_worker_thread_attr_t* attr, size_t stacksize) {
+  return pthread_attr_setstacksize(attr, stacksize);
+}
+
+static inline int cerver_acceptor_thread_attr_init(cerver_acceptor_thread_attr_t* attr) {
+  return pthread_attr_init(attr);
+}
+static inline int cerver_acceptor_thread_attr_destroy(cerver_acceptor_thread_attr_t* attr) {
+  return pthread_attr_destroy(attr);
+}
+static inline int cerver_acceptor_thread_attr_setstacksize(cerver_acceptor_thread_attr_t* attr,
+                                                           size_t stacksize) {
+  return pthread_attr_setstacksize(attr, stacksize);
+}
+
+static inline int cerver_connection_worker_thread_create(
+    cerver_connection_worker_thread_t* thread, const cerver_connection_worker_thread_attr_t* attr,
+    void* (*start_routine)(void*), void*                                                     arg) {
+  return pthread_create(thread, attr, start_routine, arg);
+}
+static inline int cerver_acceptor_thread_create(cerver_acceptor_thread_t*            thread,
+                                                const cerver_acceptor_thread_attr_t* attr,
+                                                void* (*start_routine)(void*), void* arg) {
+  return pthread_create(thread, attr, start_routine, arg);
+}
+
+static inline int cerver_connection_worker_thread_join(cerver_connection_worker_thread_t thread,
+                                                       void**                            retval) {
+  return pthread_join(thread, retval);
+}
+static inline int cerver_acceptor_thread_join(cerver_acceptor_thread_t thread, void** retval) {
+  return pthread_join(thread, retval);
+}
+
+static inline int cerver_fetch_global_init_guard_run(cerver_fetch_global_init_guard_t* guard,
+                                                     void (*init_routine)(void)) {
+  return pthread_once(guard, init_routine);
+}
+
 #endif  // _WIN32 || _WIN64
 #endif  // CERVER_WIN_COMPAT_H