iodine 0.7.43 → 0.7.46

data/ext/iodine/fio.h

@@ -215,8 +215,15 @@ Version and helper macros
 
 #include <fcntl.h>
 #include <sys/stat.h>
+#ifndef __MINGW32__
 #include <sys/time.h>
+#endif
 #include <unistd.h>
+#ifdef __MINGW32__
+#include <winsock2.h>
+#include <winsock.h>
+#include <ws2tcpip.h>
+#endif
 
 #if !defined(__GNUC__) && !defined(__clang__) && !defined(FIO_GNUC_BYPASS)
 #define __attribute__(...)
@@ -243,6 +250,25 @@ Version and helper macros
 #include <sys/socket.h>
 #endif
 
+#ifdef __MINGW32__
+#define	__S_IFMT	              0170000
+#define __S_IFLNK               0120000
+#define	__S_ISTYPE(mode, mask)	(((mode) & __S_IFMT) == (mask))
+#define S_ISLNK(mode)	          __S_ISTYPE((mode), __S_IFLNK)
+
+#define SIGKILL 9
+#define SIGTERM 15
+#define SIGCONT 17
+
+#define pipe(fds) _pipe(fds, 65536, _O_BINARY)
+
+int fork(void);
+int kill(int, int);
+ssize_t pread(int, void*, size_t, off_t);
+ssize_t pwrite(int, const void *, size_t, off_t);
+int fio_osffd4fd(unsigned int);
+#endif
+
 /* *****************************************************************************
 Patch for OSX version < 10.12 from https://stackoverflow.com/a/9781275/4025095
 ***************************************************************************** */
@@ -2068,7 +2094,7 @@ FIO_FUNC inline int fio_trylock(fio_lock_i *lock);
 /**
  * Releases a spinlock. Releasing an unacquired lock will break it.
  *
- * Returns a non-zero value on success, or 0 if the lock was in an unloacked
+ * Returns a non-zero value on success, or 0 if the lock was in an unlocked
  * state.
  */
 FIO_FUNC inline int fio_unlock(fio_lock_i *lock);
@@ -2539,8 +2565,9 @@ FIO_FUNC inline uint64_t fio_risky_hash(const void *data_, size_t len,
   uint64_t result = fio_lrot64(v0, 17) + fio_lrot64(v1, 13) +
                     fio_lrot64(v2, 47) + fio_lrot64(v3, 57);
 
-  len ^= (len << 33);
-  result += len;
+  uint64_t len64 = len;
+  len64 ^= (len64 << 33);
+  result += len64;
 
   result += v0 * RISKY_PRIME_1;
   result ^= fio_lrot64(result, 13);
@@ -2931,9 +2958,9 @@ C++ extern end
 /**
  * The logarithmic value for a memory block, 15 == 32Kb, 16 == 64Kb, etc'
  *
- * By default, a block of memory is 32Kb silce from an 8Mb allocation.
+ * By default, a block of memory is a 32Kb slice from an 8Mb allocation.
  *
- * A value of 16 will make this a 64Kb silce from a 16Mb allocation.
+ * A value of 16 will make this a 64Kb slice from a 16Mb allocation.
  */
 #define FIO_MEMORY_BLOCK_SIZE_LOG (15)
 #endif
@@ -3000,7 +3027,7 @@ FIO_FUNC inline int fio_trylock(fio_lock_i *lock) {
 /**
  * Releases a spinlock. Releasing an unacquired lock will break it.
  *
- * Returns a non-zero value on success, or 0 if the lock was in an unloacked
+ * Returns a non-zero value on success, or 0 if the lock was in an unlocked
  * state.
  */
 FIO_FUNC inline int fio_unlock(fio_lock_i *lock) {
@@ -3864,6 +3891,7 @@ FIO_FUNC char *fio_str_detach(fio_str_s *s) {
     }
     /* make a copy */
     void *tmp = FIO_MALLOC(i.len + 1);
+    FIO_ASSERT_ALLOC(tmp);
     memcpy(tmp, i.data, i.len + 1);
     i.data = tmp;
   } else {
@@ -3874,6 +3902,7 @@ FIO_FUNC char *fio_str_detach(fio_str_s *s) {
     } else if (s->dealloc != FIO_FREE) {
       /* make a copy */
       void *tmp = FIO_MALLOC(i.len + 1);
+      FIO_ASSERT_ALLOC(tmp);
       memcpy(tmp, i.data, i.len + 1);
       i.data = tmp;
       if (s->dealloc)
@@ -4338,7 +4367,7 @@ inline FIO_FUNC fio_str_info_s fio_str_write_i(fio_str_s *s, int64_t num) {
   fio_str_info_s i;
   if (!num)
     goto zero;
-  char buf[22];
+  char buf[22] = {0};
   uint64_t l = 0;
   uint8_t neg;
   if ((neg = (num < 0))) {
@@ -4472,7 +4501,7 @@ FIO_FUNC fio_str_info_s fio_str_readfile(fio_str_s *s, const char *filename,
                                          intptr_t start_at, intptr_t limit) {
   fio_str_info_s state = {.data = NULL};
 #if defined(__unix__) || defined(__linux__) || defined(__APPLE__) ||           \
-    defined(__CYGWIN__)
+    defined(__CYGWIN__) || defined(__MINGW32__)
   /* POSIX implementations. */
   if (filename == NULL || !s)
     return state;
@@ -4502,7 +4531,7 @@ FIO_FUNC fio_str_info_s fio_str_readfile(fio_str_s *s, const char *filename,
     }
   }
 
-  if (stat(filename, &f_data)) {
+  if (stat(filename, &f_data) == -1) {
     goto finish;
   }
 
@@ -4510,9 +4539,12 @@ FIO_FUNC fio_str_info_s fio_str_readfile(fio_str_s *s, const char *filename,
     state = fio_str_info(s);
     goto finish;
   }
-
+#ifdef __MINGW32__
+  file = _open(filename, O_RDONLY);
+#else
   file = open(filename, O_RDONLY);
-  if (-1 == file)
+#endif
+  if (file == -1)
     goto finish;
 
   if (start_at < 0) {
@@ -4531,7 +4563,11 @@ FIO_FUNC fio_str_info_s fio_str_readfile(fio_str_s *s, const char *filename,
     state.data = NULL;
     state.len = state.capa = 0;
   }
+#ifdef __MINGW32__
+  _close(file);
+#else
   close(file);
+#endif
 finish:
   FIO_FREE(path);
   return state;
@@ -6012,7 +6048,7 @@ FIO_NAME(_insert_or_overwrite_)(FIO_NAME(s) * set, FIO_SET_HASH_TYPE hash_value,
   pos->hash = hash_value;
   pos->pos->hash = hash_value;
   FIO_SET_COPY(pos->pos->obj, obj);
-
+  
   return pos->pos->obj;
 }
 
@@ -6282,7 +6318,7 @@ restart:
     FIO_LOG_FATAL(
         "facil.io Set / Hash Map has too many collisions (%zu/%zu)."
         "\n\t\tthis is a fatal implementation error,"
-        "please report this issue at facio.io's open source project"
+        "please report this issue at facil.io's open source project"
         "\n\t\tNote: hash maps and sets should never reach this point."
         "\n\t\tThey should be guarded against collision attacks.",
         set->pos, set->capa);

data/ext/iodine/fio_cli.c

@@ -50,7 +50,7 @@ typedef struct {
 #define AVOID_MACRO
 
 #define FIO_CLI_HASH_VAL(s)                                                    \
-  fio_risky_hash((s).data, (s).len, (uint64_t)fio_cli_start)
+  fio_risky_hash((s).data, (s).len, (uintptr_t)fio_cli_start)
 
 /* *****************************************************************************
 CLI Parsing

data/ext/iodine/fio_tls_missing.c

@@ -4,6 +4,13 @@ License: MIT
 
 Feel free to copy, use and enjoy according to the license provided.
 */
+#ifdef __MINGW32__
+// make pedantic compiler happy
+typedef struct {
+  int bogus;
+} bogus_s;
+
+#else
 #include <fio.h>
 
 /**
@@ -639,3 +646,4 @@ void FIO_TLS_WEAK fio_tls_destroy(fio_tls_s *tls) {
 }
 
 #endif /* Library compiler flags */
+#endif

data/ext/iodine/fio_tls_openssl.c

@@ -4,6 +4,13 @@ License: MIT
 
 Feel free to copy, use and enjoy according to the license provided.
 */
+#ifdef __MINGW32__
+// make pedantic compiler happy
+typedef struct {
+  int bogus;
+} bogus_s;
+
+#else
 #include <fio.h>
 
 /**
@@ -1046,3 +1053,4 @@ void FIO_TLS_WEAK fio_tls_destroy(fio_tls_s *tls) {
 }
 
 #endif /* Library compiler flags */
+#endif

data/ext/iodine/fio_tmpfile.h

@@ -18,10 +18,22 @@ License: MIT
 #include <sys/types.h>
 #include <unistd.h>
 
+#ifdef __MINGW32__
+#include <fileapi.h>
+#endif
+
 static inline int fio_tmpfile(void) {
   // create a temporary file to contain the data.
   int fd = 0;
-#ifdef P_tmpdir
+#ifdef __MINGW32__
+  char name_template[] = "fio";
+  TCHAR temp_path[(MAX_PATH-14)];
+  TCHAR temp_filename[MAX_PATH];
+  GetTempPath(MAX_PATH - 14, temp_path);
+  GetTempFileNameA(temp_path, name_template, 0, temp_filename);
+  fd = _open(temp_filename, _O_CREAT | _O_RDWR);
+  _chmod(temp_filename, _S_IREAD | _S_IWRITE);
+#elif defined(P_tmpdir)
   if (P_tmpdir[sizeof(P_tmpdir) - 1] == '/') {
     char name_template[] = P_tmpdir "facil_io_tmpfile_XXXXXXXX";
     fd = mkstemp(name_template);

data/ext/iodine/fiobj_data.c

@@ -1,5 +1,5 @@
 #if defined(__unix__) || defined(__APPLE__) || defined(__linux__) ||           \
-    defined(__CYGWIN__) /* require POSIX */
+    defined(__CYGWIN__) || defined(__MINGW32__) /* require POSIX */
 /*
 Copyright: Boaz Segev, 2017-2019
 License: MIT
@@ -78,6 +78,7 @@ static void fiobj_data_copy_parent(FIOBJ o) {
   switch (obj2io(obj2io(o)->source.parent)->fd) {
   case -1:
     obj2io(o)->buffer = fio_malloc(obj2io(o)->len + 1);
+    FIO_ASSERT_ALLOC(obj2io(o)->buffer);
     memcpy(obj2io(o)->buffer,
            obj2io(obj2io(o)->source.parent)->buffer + obj2io(o)->capa,
            obj2io(o)->len);
@@ -102,7 +103,11 @@ static void fiobj_data_copy_parent(FIOBJ o) {
       if (data.len + pos > obj2io(o)->len)
         data.len = obj2io(o)->len - pos;
     retry_int:
+#ifdef __MINGW32__
+      written = pwrite(obj2io(o)->fd, data.data, data.len, 0);
+#else
       written = write(obj2io(o)->fd, data.data, data.len);
+#endif
       if (written < 0) {
         if (errno == EINTR)
           goto retry_int;
@@ -958,7 +963,6 @@ intptr_t fiobj_data_write(FIOBJ io, void *buffer, uintptr_t length) {
   /* Unslice slices */
   if (obj2io(io)->fd == -2)
     fiobj_data_assert_dynamic(io);
-
   if (obj2io(io)->fd == -1) {
     /* String Code */
     fiobj_data_pre_write(io, length + 1);
@@ -967,7 +971,6 @@ intptr_t fiobj_data_write(FIOBJ io, void *buffer, uintptr_t length) {
     obj2io(io)->buffer[obj2io(io)->len] = 0;
     return length;
   }
-
   /* File Code */
   return pwrite(obj2io(io)->fd, buffer, length, fiobj_data_get_fd_size(io));
 }
@@ -1046,7 +1049,6 @@ void fiobj_data_test(void) {
     fprintf(stderr, "* `fiobj_data_read` operation overflow - FAILED!\n");
     exit(-1);
   }
-
   if (fiobj_obj2cstr(strio).len != fiobj_obj2cstr(text).len ||
       fiobj_obj2cstr(fdio).len != fiobj_obj2cstr(text).len) {
     fprintf(stderr, "* `write` operation FAILED!\n");

data/ext/iodine/fiobj_data.h

@@ -3,7 +3,8 @@ Copyright: Boaz Segev, 2017-2019
 License: MIT
 */
 #if !defined(H_FIOBJ_IO_H) && (defined(__unix__) || defined(__APPLE__) ||      \
-                               defined(__linux__) || defined(__CYGWIN__))
+                               defined(__linux__) || defined(__CYGWIN__) ||    \
+                               defined(__MINGW32__))
 
 /**
  * A dynamic type for reading / writing to a local file,  a temporary file or an

data/ext/iodine/fiobj_hash.c

@@ -36,6 +36,8 @@ License: MIT
 
 #include <errno.h>
 
+#include <pthread.h>
+
 /* *****************************************************************************
 Hash types
 ***************************************************************************** */
@@ -69,18 +71,34 @@ static void fiobj_hash_dealloc(FIOBJ o, void (*task)(FIOBJ, void *),
   fio_free(FIOBJ2PTR(o));
 }
 
-static __thread FIOBJ each_at_key = FIOBJ_INVALID;
+static pthread_key_t each_at_key;
+static pthread_once_t each_at_key_once = PTHREAD_ONCE_INIT;
+static void init_each_at_key(void) {
+  pthread_key_create(&each_at_key, free);
+}
+static void init_each_at_key_ptr(void) {
+  FIOBJ *eak = malloc(sizeof(FIOBJ));
+  FIO_ASSERT_ALLOC(eak);
+  *eak = FIOBJ_INVALID;
+  pthread_setspecific(each_at_key, eak);
+}
 
 static size_t fiobj_hash_each1(FIOBJ o, size_t start_at,
                                int (*task)(FIOBJ obj, void *arg), void *arg) {
   assert(o && FIOBJ_TYPE_IS(o, FIOBJ_T_HASH));
-  FIOBJ old_each_at_key = each_at_key;
+  pthread_once(&each_at_key_once, init_each_at_key);
+  FIOBJ *each_at_key_ptr = (FIOBJ *)pthread_getspecific(each_at_key);
+  if (!each_at_key_ptr) {
+    init_each_at_key_ptr();
+    each_at_key_ptr = (FIOBJ *)pthread_getspecific(each_at_key);
+  }
+  FIOBJ old_each_at_key = *each_at_key_ptr;
   fio_hash___s *hash = &obj2hash(o)->hash;
   size_t count = 0;
   if (hash->count == hash->pos) {
     /* no holes in the hash, we can work as we please. */
     for (count = start_at; count < hash->count; ++count) {
-      each_at_key = hash->ordered[count].obj.key;
+      *each_at_key_ptr = hash->ordered[count].obj.key;
       if (task((FIOBJ)hash->ordered[count].obj.obj, arg) == -1) {
         ++count;
         goto end;
@@ -100,17 +118,25 @@ static size_t fiobj_hash_each1(FIOBJ o, size_t start_at,
       if (hash->ordered[pos].obj.key == FIOBJ_INVALID)
         continue;
       ++count;
-      each_at_key = hash->ordered[pos].obj.key;
+      *each_at_key_ptr = hash->ordered[pos].obj.key;
       if (task((FIOBJ)hash->ordered[pos].obj.obj, arg) == -1)
         break;
     }
   }
 end:
-  each_at_key = old_each_at_key;
+  *each_at_key_ptr = old_each_at_key;
   return count;
 }
 
-FIOBJ fiobj_hash_key_in_loop(void) { return each_at_key; }
+FIOBJ fiobj_hash_key_in_loop(void) {
+  pthread_once(&each_at_key_once, init_each_at_key);
+  FIOBJ *each_at_key_ptr = (FIOBJ *)pthread_getspecific(each_at_key);
+  if (!each_at_key_ptr) {
+    init_each_at_key_ptr();
+    each_at_key_ptr = (FIOBJ *)pthread_getspecific(each_at_key);
+  }
+  return *each_at_key_ptr;
+}
 
 static size_t fiobj_hash_is_eq(const FIOBJ self, const FIOBJ other) {
   if (fio_hash___count(&obj2hash(self)->hash) !=

data/ext/iodine/fiobj_mustache.c

@@ -240,12 +240,20 @@ Testing
 #if DEBUG
 static inline void mustache_save2file(char const *filename, char const *data,
                                       size_t length) {
+#ifdef __MINGW32__
+  int fd = _open(filename, _O_CREAT | _O_RDWR);
+#else
   int fd = open(filename, O_CREAT | O_RDWR, 0);
+#endif
   if (fd == -1) {
     perror("Couldn't open / create file for template testing");
     exit(-1);
   }
+#ifdef __MINGW32__
+  _chmod(filename, _S_IREAD | _S_IWRITE);
+#else
   fchmod(fd, 0777);
+#endif
   if (pwrite(fd, data, length, 0) != (ssize_t)length) {
     perror("Mustache template write error");
     exit(-1);
@@ -265,6 +273,7 @@ void fiobj_mustache_test(void) {
       "{{=<< >>=}}* Users:\r\n<<#users>><<id>>. <<& name>> "
       "(<<name>>)\r\n<</users>>\r\nNested: <<& nested.item >>.";
   char const *template_name = "mustache_test_template.mustache";
+  fprintf(stderr, "mustache test saving template %s\n", template_name);
   mustache_save2file(template_name, template, strlen(template));
   mustache_s *m =
       fiobj_mustache_load((fio_str_info_s){.data = (char *)template_name});

data/ext/iodine/fiobj_numbers.c

@@ -12,6 +12,8 @@ License: MIT
 #include <errno.h>
 #include <math.h>
 
+#include <pthread.h>
+
 /* *****************************************************************************
 Numbers Type
 ***************************************************************************** */
@@ -33,7 +35,17 @@ typedef struct {
 Numbers VTable
 ***************************************************************************** */
 
-static __thread char num_buffer[512];
+static pthread_key_t num_vt_buffer_key;
+static pthread_once_t num_vt_buffer_once = PTHREAD_ONCE_INIT;
+static void init_num_vt_buffer_key(void) {
+  pthread_key_create(&num_vt_buffer_key, free);
+}
+static void init_num_vt_buffer_ptr(void) {
+  char *num_vt_buffer = malloc(sizeof(char)*512);
+  FIO_ASSERT_ALLOC(num_vt_buffer);
+  memset(num_vt_buffer, 0, sizeof(char)*512);
+  pthread_setspecific(num_vt_buffer_key, num_vt_buffer);
+}
 
 static intptr_t fio_i2i(const FIOBJ o) { return obj2num(o)->i; }
 static intptr_t fio_f2i(const FIOBJ o) {
@@ -46,6 +58,12 @@ static size_t fio_itrue(const FIOBJ o) { return (obj2num(o)->i != 0); }
 static size_t fio_ftrue(const FIOBJ o) { return (obj2float(o)->f != 0); }
 
 static fio_str_info_s fio_i2str(const FIOBJ o) {
+  pthread_once(&num_vt_buffer_once, init_num_vt_buffer_key);
+  char *num_buffer = pthread_getspecific(num_vt_buffer_key);
+  if (!num_buffer) {
+    init_num_vt_buffer_ptr();
+    num_buffer = pthread_getspecific(num_vt_buffer_key);
+  }
   return (fio_str_info_s){
       .data = num_buffer,
       .len = fio_ltoa(num_buffer, obj2num(o)->i, 10),
@@ -60,6 +78,12 @@ static fio_str_info_s fio_f2str(const FIOBJ o) {
     else
       return (fio_str_info_s){.data = (char *)"-Infinity", .len = 9};
   }
+  pthread_once(&num_vt_buffer_once, init_num_vt_buffer_key);
+  char *num_buffer = pthread_getspecific(num_vt_buffer_key);
+  if (!num_buffer) {
+    init_num_vt_buffer_ptr();
+    num_buffer = pthread_getspecific(num_vt_buffer_key);
+  }
   return (fio_str_info_s){
       .data = num_buffer,
       .len = fio_ftoa(num_buffer, obj2float(o)->f, 10),
@@ -126,14 +150,30 @@ FIOBJ fiobj_num_new_bignum(intptr_t num) {
 //   FIOBJ_IS_ALLOCATED(target)); obj2num(target)->i = num;
 // }
 
+static pthread_key_t num_ret_key;
+static pthread_once_t num_ret_once = PTHREAD_ONCE_INIT;
+static void init_num_ret_key(void) {
+  pthread_key_create(&num_ret_key, free);
+}
+static void init_num_ret_ptr(void) {
+  fiobj_num_s *ret = malloc(sizeof(fiobj_num_s));
+  FIO_ASSERT_ALLOC(ret);
+  memset(ret, 0, sizeof(fiobj_num_s));
+  pthread_setspecific(num_ret_key, ret);
+}
 /** Creates a temporary Number object. This ignores `fiobj_free`. */
 FIOBJ fiobj_num_tmp(intptr_t num) {
-  static __thread fiobj_num_s ret;
-  ret = (fiobj_num_s){
+  pthread_once(&num_ret_once, init_num_ret_key);
+  fiobj_num_s *ret = pthread_getspecific(num_ret_key);
+  if (!ret) {
+    init_num_ret_ptr();
+    ret = pthread_getspecific(num_ret_key);
+  }
+  *ret = (fiobj_num_s){
       .head = {.type = FIOBJ_T_NUMBER, .ref = ((~(uint32_t)0) >> 4)},
       .i = num,
   };
-  return (FIOBJ)&ret;
+  return (FIOBJ)ret;
 }
 
 /* *****************************************************************************
@@ -164,10 +204,26 @@ void fiobj_float_set(FIOBJ obj, double num) {
   obj2float(obj)->f = num;
 }
 
+static pthread_key_t float_ret_key;
+static pthread_once_t float_ret_once = PTHREAD_ONCE_INIT;
+static void init_float_ret_key(void) {
+  pthread_key_create(&float_ret_key, free);
+}
+static void init_float_ret_ptr(void) {
+  fiobj_float_s *ret = malloc(sizeof(fiobj_float_s));
+  FIO_ASSERT_ALLOC(ret);
+  memset(ret, 0, sizeof(fiobj_float_s));
+  pthread_setspecific(float_ret_key, ret);
+}
 /** Creates a temporary Number object. This ignores `fiobj_free`. */
 FIOBJ fiobj_float_tmp(double num) {
-  static __thread fiobj_float_s ret;
-  ret = (fiobj_float_s){
+  pthread_once(&float_ret_once, init_float_ret_key);
+  fiobj_float_s *ret = pthread_getspecific(float_ret_key);
+  if (!ret) {
+    init_float_ret_ptr();
+    ret = pthread_getspecific(float_ret_key);
+  }
+  *ret = (fiobj_float_s){
       .head =
           {
               .type = FIOBJ_T_FLOAT,
@@ -175,20 +231,42 @@ FIOBJ fiobj_float_tmp(double num) {
           },
       .f = num,
   };
-  return (FIOBJ)&ret;
+  return (FIOBJ)ret;
 }
 
 /* *****************************************************************************
 Numbers to Strings - Buffered
 ***************************************************************************** */
 
-static __thread char num_buffer[512];
+static pthread_key_t num_str_buffer_key;
+static pthread_once_t num_str_buffer_once = PTHREAD_ONCE_INIT;
+static void init_num_str_buffer_key(void) {
+  pthread_key_create(&num_str_buffer_key, free);
+}
+static void init_num_str_buffer_ptr(void) {
+  char *num_str_buffer = malloc(sizeof(char)*512);
+  FIO_ASSERT_ALLOC(num_str_buffer);
+  memset(num_str_buffer, 0, sizeof(char)*512);
+  pthread_setspecific(num_str_buffer_key, num_str_buffer);
+}
 
 fio_str_info_s fio_ltocstr(long i) {
+  pthread_once(&num_str_buffer_once, init_num_str_buffer_key);
+  char *num_buffer = pthread_getspecific(num_str_buffer_key);
+  if (!num_buffer) {
+    init_num_str_buffer_ptr();
+    num_buffer = pthread_getspecific(num_str_buffer_key);
+  }
   return (fio_str_info_s){.data = num_buffer,
                           .len = fio_ltoa(num_buffer, i, 10)};
 }
 fio_str_info_s fio_ftocstr(double f) {
+  pthread_once(&num_str_buffer_once, init_num_str_buffer_key);
+  char *num_buffer = pthread_getspecific(num_str_buffer_key);
+  if (!num_buffer) {
+    init_num_str_buffer_ptr();
+    num_buffer = pthread_getspecific(num_str_buffer_key);
+  }
   return (fio_str_info_s){.data = num_buffer,
                           .len = fio_ftoa(num_buffer, f, 10)};
 }

data/ext/iodine/fiobj_str.c

@@ -37,6 +37,8 @@ License: MIT
 #define PATH_MAX PAGE_SIZE
 #endif
 
+#include <pthread.h>
+
 /* *****************************************************************************
 String Type
 ***************************************************************************** */
@@ -176,22 +178,33 @@ FIOBJ fiobj_str_move(char *str, size_t len, size_t capacity) {
   return ((uintptr_t)s | FIOBJECT_STRING_FLAG);
 }
 
+static pthread_key_t str_tmp_key;
+static pthread_once_t str_tmp_once = PTHREAD_ONCE_INIT;
+static void init_str_tmp_key(void) {
+  pthread_key_create(&str_tmp_key, free);
+}
+static void init_str_tmp_key_ptr(void) {
+  fiobj_str_s *tmp = malloc(sizeof(fiobj_str_s));
+  FIO_ASSERT_ALLOC(tmp);
+  tmp->head.ref = ((~(uint32_t)0) >> 4);
+  tmp->head.type = FIOBJ_T_STRING;
+  tmp->str.small = 1;
+  pthread_setspecific(str_tmp_key, tmp);
+}
 /**
  * Returns a thread-static temporary string. Avoid calling `fiobj_dup` or
  * `fiobj_free`.
  */
 FIOBJ fiobj_str_tmp(void) {
-  static __thread fiobj_str_s tmp = {
-      .head =
-          {
-              .ref = ((~(uint32_t)0) >> 4),
-              .type = FIOBJ_T_STRING,
-          },
-      .str = {.small = 1},
-  };
-  tmp.str.frozen = 0;
-  fio_str_resize(&tmp.str, 0);
-  return ((uintptr_t)&tmp | FIOBJECT_STRING_FLAG);
+  pthread_once(&str_tmp_once, init_str_tmp_key);
+  fiobj_str_s *tmp = (fiobj_str_s *)pthread_getspecific(str_tmp_key);
+  if (!tmp) {
+    init_str_tmp_key_ptr();
+    tmp = (fiobj_str_s *)pthread_getspecific(str_tmp_key);
+  }
+  tmp->str.frozen = 0;
+  fio_str_resize(&tmp->str, 0);
+  return ((uintptr_t)tmp | FIOBJECT_STRING_FLAG);
 }
 
 /** Prevents the String object from being changed. */

data/ext/iodine/fiobject.c

@@ -102,7 +102,7 @@ size_t __attribute__((weak)) fio_ltoa(char *dest, int64_t num, uint8_t base) {
                            '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
 
   size_t len = 0;
-  char buf[48]; /* we only need up to 20 for base 10, but base 3 needs 41... */
+  char buf[48] = {0}; /* we only need up to 20 for base 10, but base 3 needs 41... */
 
   if (!num)
     goto zero;

data/ext/iodine/fiobject.h

@@ -502,7 +502,7 @@ fio_str_info_s fio_ftocstr(double);
 /**
  * Returns a C String (NUL terminated) using the `fio_str_info_s` data type.
  *
- * The Sting in binary safe and might contain NUL bytes in the middle as well as
+ * The String is binary safe and might contain NUL bytes in the middle as well as
  * a terminating NUL.
  *
  * If a a Number or a Float are passed to the function, they
@@ -554,11 +554,13 @@ FIO_INLINE uint64_t fiobj_obj2hash(const FIOBJ o) {
   if (!FIOBJ_IS_ALLOCATED(o))
     return (uint64_t)o;
   fio_str_info_s s = fiobj_obj2cstr(o);
-  return FIO_HASH_FN(s.data, s.len, &fiobj_each2, &fiobj_free_complex_object);
+  return FIO_HASH_FN(s.data, s.len, (uintptr_t)&fiobj_each2,
+                     (uintptr_t)&fiobj_free_complex_object);
 }
 
 FIO_INLINE uint64_t fiobj_hash_string(const void *data, size_t len) {
-  return FIO_HASH_FN(data, len, &fiobj_each2, &fiobj_free_complex_object);
+  return FIO_HASH_FN(data, len, (uintptr_t)&fiobj_each2,
+                     (uintptr_t)&fiobj_free_complex_object);
 }
 
 /**