iodine 0.7.2 → 0.7.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9304bf27335fe19b9c7d7ca9442fe994772c5489a70aa598cc045bda313c755
-  data.tar.gz: 8acee18f9da3f77a763fb7c93ac2c4328788c79298c5b792597e6b40ee1b14c5
+  metadata.gz: bf89fce9c0e4b457fb88d8871bc61e81517fdb9bfe227627394f8c06753829c1
+  data.tar.gz: 20f66f4a8fe102b9c9e59ee2eda6ed27e0f65e880a42c953554df8b3ead6ca11
 SHA512:
-  metadata.gz: aef5181c233342793d2c74a8d4ca6c398a357c36bc399dd133f796aa0c2e67ed881d99514b45c2e85da880e0a2b49844fa869afc28be696dc63675558b7dba2c
-  data.tar.gz: 6e6f11fd287cafbcc9eae4ef3df92fe4b4c543e9d930344745725c59cc4be587d24e8c226416ae65208516bd995afa90c210847f0e8faf9873dfe3913c4ef7dc
+  metadata.gz: 4967888c32c01259d933576876d07d66612ac71689dfb93ae8dad8e08675a4908e654d76ebb9e44cf4f9fb87b657a068fb97520648b89df6daae2bfe4a191f55
+  data.tar.gz: 11170c43eece7c6a6627408e40c5f5751abde9b5e330ba97c8f19c6643e0cf842d70c7a3dfaaf2b18b6fb30894cf48563d2d56ffc9cc70fa58809eb5e30c2983

data/CHANGELOG.md

@@ -6,6 +6,12 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ## Changes:
 
+#### Change log v.0.7.3
+
+**Fix**: (facil.io) updating facil.io fixes a channel name memory leak fixed in facil.io's edge version.
+
+**Updated**: Improved logging for server data, allowing for log silencing.
+
 #### Change log v.0.7.2
 
 **Updated**: updated the logging for HTTP services startup, to minimize log clutter.

data/exe/iodine

@@ -32,6 +32,7 @@ Available options:
  -maxbd      Maximum Mb per HTTP message (max body size). Default: 50Mb.
  -maxms      Maximum Bytes per Websocket message. Default: 250Kb.
  -ping       WebSocket / SSE ping interval in seconds. Default: 40 seconds.
+ -logging    Server level logging (not HTTP), values between 0..5. Defaults to 4.
  <filename>  Defaults to: config.ru
 
 Example:

data/ext/iodine/extconf.rb

@@ -29,7 +29,7 @@ else
   puts 'using an unknown (old?) compiler... who knows if this will work out... we hope.'
 end
 
-$CFLAGS = "-std=c11 -O2 -Wall #{ENV['CFLAGS']}"
+$CFLAGS = "-std=c11 -O2 -Wall -DFIO_PRINT_STATE=0 #{ENV['CFLAGS']}"
 RbConfig::MAKEFILE_CONFIG['CC'] = $CC = ENV['CC'] if ENV['CC']
 RbConfig::MAKEFILE_CONFIG['CPP'] = $CPP = ENV['CPP'] if ENV['CPP']
 

data/ext/iodine/fio.c

@@ -467,7 +467,8 @@ void fio_uuid_link(intptr_t uuid, void *obj, void (*on_close)(void *obj)) {
   fio_lock(&uuid_data(uuid).sock_lock);
   if (!uuid_is_valid(uuid))
     goto locked_invalid;
-  fio_uuid_links_overwrite(&uuid_data(uuid).links, (uintptr_t)obj, on_close);
+  fio_uuid_links_overwrite(&uuid_data(uuid).links, (uintptr_t)obj, on_close,
+                           NULL);
   fio_unlock(&uuid_data(uuid).sock_lock);
   return;
 locked_invalid:
@@ -485,7 +486,8 @@ int fio_uuid_unlink(intptr_t uuid, void *obj) {
   if (!uuid_is_valid(uuid))
     goto locked_invalid;
   /* default object comparison is always true */
-  int ret = fio_uuid_links_remove(&uuid_data(uuid).links, (uintptr_t)obj, NULL);
+  int ret =
+      fio_uuid_links_remove(&uuid_data(uuid).links, (uintptr_t)obj, NULL, NULL);
   if (ret)
     errno = ENOTCONN;
   fio_unlock(&uuid_data(uuid).sock_lock);
@@ -3071,6 +3073,7 @@ static void fio_pubsub_on_fork(void);
 
 static void fio_mem_destroy(void);
 static void __attribute__((destructor)) fio_lib_destroy(void) {
+  uint8_t add_eol = fio_is_master();
   fio_data->active = 0;
   fio_state_callback_force(FIO_CALL_AT_EXIT);
   fio_state_callback_clear_all();
@@ -3081,7 +3084,8 @@ static void __attribute__((destructor)) fio_lib_destroy(void) {
   /* memory library destruction must be last */
   fio_mem_destroy();
   FIO_LOG_DEBUG("(%d) facil.io resources released, exit complete.", getpid());
-  fprintf(stderr, "\n"); /* add EOL to logs (logging adds EOL before text */
+  if (add_eol)
+    fprintf(stderr, "\n"); /* add EOL to logs (logging adds EOL before text */
 }
 
 /* Called within a child process after it starts. */
@@ -3477,6 +3481,7 @@ void fio_start FIO_IGNORE_MACRO(struct fio_start_args args) {
   fio_data->workers = (uint16_t)args.workers;
   fio_data->threads = (uint16_t)args.threads;
   fio_data->active = 1;
+  fio_data->is_worker = 0;
 
   fio_state_callback_force(FIO_CALL_PRE_START);
 
@@ -3899,10 +3904,10 @@ static void fio_listen_on_startup(void *pr_) {
   fio_listen_protocol_s *pr = pr_;
   fio_attach(pr->uuid, &pr->pr);
   if (pr->port_len)
-    FIO_LOG_INFO("(%d) started listening on port %s", getpid(), pr->port);
+    FIO_LOG_DEBUG("(%d) started listening on port %s", getpid(), pr->port);
   else
-    FIO_LOG_INFO("(%d) started listening on Unix Socket at %s", getpid(),
-                 pr->addr);
+    FIO_LOG_DEBUG("(%d) started listening on Unix Socket at %s", getpid(),
+                  pr->addr);
 }
 
 static void fio_listen_on_close(intptr_t uuid, fio_protocol_s *pr_) {
@@ -4303,7 +4308,7 @@ static inline channel_s *fio_filter_dup_lock_internal(channel_s *ch,
                                                       uint64_t hashed,
                                                       fio_collection_s *c) {
   fio_lock(&c->lock);
-  ch = *fio_ch_set_insert(&c->channels, hashed, ch);
+  ch = fio_ch_set_insert(&c->channels, hashed, ch);
   fio_str_dup(&ch->id);
   fio_lock(&ch->lock);
   fio_unlock(&c->lock);
@@ -4440,7 +4445,7 @@ void fio_unsubscribe(subscription_s *s) {
     fio_lock(&c->lock);
     /* test again within lock */
     if (fio_ls_embd_is_empty(&ch->subscriptions)) {
-      fio_ch_set_remove(&c->channels, hashed, ch);
+      fio_ch_set_remove(&c->channels, hashed, ch, NULL);
       removed = 1;
     }
     fio_unlock(&c->lock);
@@ -4520,13 +4525,14 @@ void fio_pubsub_attach(fio_pubsub_engine_s *engine) {
 /** Detaches an engine, so it could be safely destroyed. */
 void fio_pubsub_detach(fio_pubsub_engine_s *engine) {
   fio_lock(&fio_postoffice.engines.lock);
-  fio_engine_set_remove(&fio_postoffice.engines.set, (uintptr_t)engine, engine);
+  fio_engine_set_remove(&fio_postoffice.engines.set, (uintptr_t)engine, engine,
+                        NULL);
   fio_unlock(&fio_postoffice.engines.lock);
 }
 
 /** Returns true (1) if the engine is attached to the system. */
 int fio_pubsub_is_attached(fio_pubsub_engine_s *engine) {
-  fio_pubsub_engine_s **addr;
+  fio_pubsub_engine_s *addr;
   fio_lock(&fio_postoffice.engines.lock);
   addr = fio_engine_set_find(&fio_postoffice.engines.set, (uintptr_t)engine,
                              engine);
@@ -4612,8 +4618,8 @@ void fio_message_metadata_callback_set(fio_msg_metadata_fn callback,
     fio_meta_set_insert(&fio_postoffice.meta.set, (uintptr_t)callback,
                         callback);
   else
-    fio_meta_set_remove(&fio_postoffice.meta.set, (uintptr_t)callback,
-                        callback);
+    fio_meta_set_remove(&fio_postoffice.meta.set, (uintptr_t)callback, callback,
+                        NULL);
   fio_unlock(&fio_postoffice.meta.lock);
 }
 
@@ -4637,12 +4643,11 @@ void *fio_message_metadata(fio_msg_s *msg, intptr_t type_id) {
 static channel_s *fio_channel_find_dup_internal(fio_str_s *s, uint64_t hashed,
                                                 fio_collection_s *c) {
   fio_lock(&c->lock);
-  channel_s **pch = fio_ch_set_find(&c->channels, hashed, (channel_s *)s);
-  if (!pch) {
+  channel_s *ch = fio_ch_set_find(&c->channels, hashed, (channel_s *)s);
+  if (!ch) {
     fio_unlock(&c->lock);
     return NULL;
   }
-  channel_s *ch = *pch;
   fio_str_dup((fio_str_s *)ch);
   fio_unlock(&c->lock);
   return ch;
@@ -4778,8 +4783,7 @@ static void fio_publish2process(fio_msg_internal_s *m) {
   }
   /* exact match */
   if (ch) {
-    fio_defer(fio_publish2channel_task, fio_str_dup(&ch->id),
-              fio_msg_internal_dup(m));
+    fio_defer(fio_publish2channel_task, &ch->id, fio_msg_internal_dup(m));
   }
   if (m->filter == 0) {
     /* pattern matching match */
@@ -5128,7 +5132,7 @@ static void fio_cluster_server_handler(struct cluster_pr_s *pr) {
     fio_str_s tmp = FIO_STR_INIT_EXISTING(
         pr->msg->channel.data, pr->msg->channel.len, 0); // don't free
     fio_lock(&pr->lock);
-    fio_sub_hash_insert(&pr->pubsub, fio_str_hash(&tmp), tmp, s);
+    fio_sub_hash_insert(&pr->pubsub, fio_str_hash(&tmp), tmp, s, NULL);
     fio_unlock(&pr->lock);
     break;
   }
@@ -5136,7 +5140,7 @@ static void fio_cluster_server_handler(struct cluster_pr_s *pr) {
     fio_str_s tmp = FIO_STR_INIT_EXISTING(
         pr->msg->channel.data, pr->msg->channel.len, 0); // don't free
     fio_lock(&pr->lock);
-    fio_sub_hash_remove(&pr->pubsub, fio_str_hash(&tmp), tmp);
+    fio_sub_hash_remove(&pr->pubsub, fio_str_hash(&tmp), tmp, NULL);
     fio_unlock(&pr->lock);
     break;
   }
@@ -5149,7 +5153,7 @@ static void fio_cluster_server_handler(struct cluster_pr_s *pr) {
     fio_str_s tmp = FIO_STR_INIT_EXISTING(
         pr->msg->channel.data, pr->msg->channel.len, 0); // don't free
     fio_lock(&pr->lock);
-    fio_sub_hash_insert(&pr->patterns, fio_str_hash(&tmp), tmp, s);
+    fio_sub_hash_insert(&pr->patterns, fio_str_hash(&tmp), tmp, s, NULL);
     fio_unlock(&pr->lock);
     break;
   }
@@ -5158,7 +5162,7 @@ static void fio_cluster_server_handler(struct cluster_pr_s *pr) {
     fio_str_s tmp = FIO_STR_INIT_EXISTING(
         pr->msg->channel.data, pr->msg->channel.len, 0); // don't free
     fio_lock(&pr->lock);
-    fio_sub_hash_remove(&pr->patterns, fio_str_hash(&tmp), tmp);
+    fio_sub_hash_remove(&pr->patterns, fio_str_hash(&tmp), tmp, NULL);
     fio_unlock(&pr->lock);
     break;
   }
@@ -5412,7 +5416,7 @@ static void fio_cluster_at_exit(void *ignore) {
   fio_pubsub_on_fork();
   /* clear subscriptions of all types */
   while (fio_ch_set_count(&fio_postoffice.patterns.channels)) {
-    channel_s *ch = *fio_ch_set_last(&fio_postoffice.patterns.channels);
+    channel_s *ch = fio_ch_set_last(&fio_postoffice.patterns.channels);
     while (fio_ls_embd_any(&ch->subscriptions)) {
       subscription_s *sub =
           FIO_LS_EMBD_OBJ(subscription_s, node, ch->subscriptions.next);
@@ -5422,7 +5426,7 @@ static void fio_cluster_at_exit(void *ignore) {
   }
 
   while (fio_ch_set_count(&fio_postoffice.pubsub.channels)) {
-    channel_s *ch = *fio_ch_set_last(&fio_postoffice.pubsub.channels);
+    channel_s *ch = fio_ch_set_last(&fio_postoffice.pubsub.channels);
     while (fio_ls_embd_any(&ch->subscriptions)) {
       subscription_s *sub =
           FIO_LS_EMBD_OBJ(subscription_s, node, ch->subscriptions.next);
@@ -5432,7 +5436,7 @@ static void fio_cluster_at_exit(void *ignore) {
   }
 
   while (fio_ch_set_count(&fio_postoffice.filters.channels)) {
-    channel_s *ch = *fio_ch_set_last(&fio_postoffice.filters.channels);
+    channel_s *ch = fio_ch_set_last(&fio_postoffice.filters.channels);
     while (fio_ls_embd_any(&ch->subscriptions)) {
       subscription_s *sub =
           FIO_LS_EMBD_OBJ(subscription_s, node, ch->subscriptions.next);
@@ -5447,7 +5451,7 @@ static void fio_cluster_at_exit(void *ignore) {
   /* clear engines */
   FIO_PUBSUB_DEFAULT = FIO_PUBSUB_CLUSTER;
   while (fio_engine_set_count(&fio_postoffice.engines.set)) {
-    fio_pubsub_detach(*fio_engine_set_last(&fio_postoffice.engines.set));
+    fio_pubsub_detach(fio_engine_set_last(&fio_postoffice.engines.set));
     fio_engine_set_last(&fio_postoffice.engines.set);
   }
   fio_engine_set_free(&fio_postoffice.engines.set);
@@ -8434,23 +8438,22 @@ FIO_FUNC void fio_set_test(void) {
   FIO_ASSERT(!fio_hash_test_is_fragmented(&h),
              "empty hash shouldn't be considered fragmented");
   FIO_ASSERT(!fio_set_test_last(&s), "empty set shouldn't have a last object");
-  FIO_ASSERT(!fio_hash_test_last(&h),
+  FIO_ASSERT(!fio_hash_test_last(&h).key && !fio_hash_test_last(&h).obj,
              "empty hash shouldn't have a last object");
 
   for (uintptr_t i = 1; i < FIO_SET_TEXT_COUNT; ++i) {
     fio_set_test_insert(&s, i, i);
-    fio_hash_test_insert(&h, i, i, i + 1);
+    fio_hash_test_insert(&h, i, i, i + 1, NULL);
     FIO_ASSERT(fio_set_test_find(&s, i, i), "set find failed after insert");
     FIO_ASSERT(fio_hash_test_find(&h, i, i), "hash find failed after insert");
-    FIO_ASSERT(i == *fio_set_test_find(&s, i, i), "set insertion != find");
-    FIO_ASSERT(i + 1 == *fio_hash_test_find(&h, i, i),
-               "hash insertion != find");
+    FIO_ASSERT(i == fio_set_test_find(&s, i, i), "set insertion != find");
+    FIO_ASSERT(i + 1 == fio_hash_test_find(&h, i, i), "hash insertion != find");
   }
   fprintf(stderr, "* Seeking %lu items\n", FIO_SET_TEXT_COUNT);
   for (unsigned long i = 1; i < FIO_SET_TEXT_COUNT; ++i) {
-    FIO_ASSERT((i == *fio_set_test_find(&s, i, i)),
+    FIO_ASSERT((i == fio_set_test_find(&s, i, i)),
                "set insertion != find (seek)");
-    FIO_ASSERT((i + 1 == *fio_hash_test_find(&h, i, i)),
+    FIO_ASSERT((i + 1 == fio_hash_test_find(&h, i, i)),
                "hash insertion != find (seek)");
   }
   {
@@ -8477,8 +8480,8 @@ FIO_FUNC void fio_set_test(void) {
 
   fprintf(stderr, "* Removing odd items from %lu items\n", FIO_SET_TEXT_COUNT);
   for (unsigned long i = 1; i < FIO_SET_TEXT_COUNT; i += 2) {
-    fio_set_test_remove(&s, i, i);
-    fio_hash_test_remove(&h, i, i);
+    fio_set_test_remove(&s, i, i, NULL);
+    fio_hash_test_remove(&h, i, i, NULL);
     FIO_ASSERT(!(fio_set_test_find(&s, i, i)),
                "Removal failed in set (still exists).");
     FIO_ASSERT(!(fio_hash_test_find(&h, i, i)),
@@ -8510,49 +8513,49 @@ FIO_FUNC void fio_set_test(void) {
     {
       fprintf(stderr, "* Poping two elements (testing pop through holes)\n");
       FIO_ASSERT(fio_set_test_last(&s), "Pop `last` 1 failed - no last object");
-      uintptr_t tmp = *fio_set_test_last(&s);
+      uintptr_t tmp = fio_set_test_last(&s);
       FIO_ASSERT(tmp, "Pop set `last` 1 failed to collect object");
       fio_set_test_pop(&s);
       FIO_ASSERT(
-          *fio_set_test_last(&s) != tmp,
+          fio_set_test_last(&s) != tmp,
           "Pop `last` 2 in set same as `last` 1 - failed to collect object");
-      tmp = fio_hash_test_last(&h)->key;
+      tmp = fio_hash_test_last(&h).key;
       FIO_ASSERT(tmp, "Pop hash `last` 1 failed to collect object");
       fio_hash_test_pop(&h);
       FIO_ASSERT(
-          fio_hash_test_last(&h)->key != tmp,
+          fio_hash_test_last(&h).key != tmp,
           "Pop `last` 2 in hash same as `last` 1 - failed to collect object");
       FIO_ASSERT(fio_set_test_last(&s), "Pop `last` 2 failed - no last object");
-      FIO_ASSERT(fio_hash_test_last(&h),
+      FIO_ASSERT(fio_hash_test_last(&h).obj,
                  "Pop `last` 2 failed in hash - no last object");
       fio_set_test_pop(&s);
       fio_hash_test_pop(&h);
     }
     if (1) {
       uintptr_t tmp = 1;
-      fio_set_test_remove(&s, tmp, tmp);
-      fio_hash_test_remove(&h, tmp, tmp);
+      fio_set_test_remove(&s, tmp, tmp, NULL);
+      fio_hash_test_remove(&h, tmp, tmp, NULL);
       size_t count = s.count;
-      fio_set_test_overwrite(&s, tmp, tmp);
+      fio_set_test_overwrite(&s, tmp, tmp, NULL);
       FIO_ASSERT(
           count + 1 == s.count,
           "Re-adding a removed item in set should increase count by 1 (%zu + "
           "1 != %zu).",
           count, (size_t)s.count);
       count = h.count;
-      fio_hash_test_insert(&h, tmp, tmp, tmp);
+      fio_hash_test_insert(&h, tmp, tmp, tmp, NULL);
       FIO_ASSERT(
           count + 1 == h.count,
           "Re-adding a removed item in hash should increase count by 1 (%zu + "
           "1 != %zu).",
           count, (size_t)s.count);
-      tmp = *fio_set_test_find(&s, tmp, tmp);
+      tmp = fio_set_test_find(&s, tmp, tmp);
       FIO_ASSERT(tmp == 1,
                  "Re-adding a removed item should update the item in the set "
                  "(%lu != 1)!",
-                 (unsigned long)*fio_set_test_find(&s, tmp, tmp));
-      fio_set_test_remove(&s, tmp, tmp);
-      fio_hash_test_remove(&h, tmp, tmp);
+                 (unsigned long)fio_set_test_find(&s, tmp, tmp));
+      fio_set_test_remove(&s, tmp, tmp, NULL);
+      fio_hash_test_remove(&h, tmp, tmp, NULL);
       FIO_ASSERT(count == h.count,
                  "Re-removing an item should decrease count (%zu != %zu).",
                  count, (size_t)s.count);
@@ -8589,14 +8592,13 @@ FIO_FUNC void fio_set_test(void) {
     fio_set_test_insert(&s, i, i);
     FIO_ASSERT(fio_set_test_find(&s, i, i),
                "find failed after insert (2nd round)");
-    FIO_ASSERT(i == *fio_set_test_find(&s, i, i),
+    FIO_ASSERT(i == fio_set_test_find(&s, i, i),
                "insertion (2nd round) != find");
     FIO_ASSERT(i == s.count, "count error (%lu != %lu) post insertion.", i,
                s.count);
   }
   fio_set_test_free(&s);
 }
-#undef FIO_SET_NAME
 
 /* *****************************************************************************
 SipHash tests

data/ext/iodine/fio.h

@@ -402,10 +402,8 @@ extern size_t FIO_LOG_LEVEL;
 /** Tests for an allocation failure. The behavior can be overridden. */
 #define FIO_ASSERT_ALLOC(ptr)                                                  \
   if (!(ptr)) {                                                                \
-    fprintf(stderr,                                                            \
-            "FATAL ERROR: memory allocation error "__FILE__                    \
-            ":%d\n",                                                           \
-            __LINE__);                                                         \
+    fprintf(stderr, "\nFATAL ERROR: memory allocation error "__FILE__          \
+                    ":" FIO_MACRO2STR(__LINE__) "\n");                         \
     perror("             Error details (errno)");                              \
     kill(0, SIGINT);                                                           \
     exit(errno);                                                               \
@@ -2738,11 +2736,11 @@ FIO_FUNC inline int fio_ls_embd_any(fio_ls_embd_s *list);
 Independent Linked List API
 ***************************************************************************** */
 
-/** Adds an object to the list's head. */
-FIO_FUNC inline void fio_ls_push(fio_ls_s *pos, const void *obj);
+/** Adds an object to the list's head, returnin's the object's location. */
+FIO_FUNC inline fio_ls_s *fio_ls_push(fio_ls_s *pos, const void *obj);
 
-/** Adds an object to the list's tail. */
-FIO_FUNC inline void fio_ls_unshift(fio_ls_s *pos, const void *obj);
+/** Adds an object to the list's tail, returnin's the object's location. */
+FIO_FUNC inline fio_ls_s *fio_ls_unshift(fio_ls_s *pos, const void *obj);
 
 /** Removes an object from the list's head. */
 FIO_FUNC inline void *fio_ls_pop(fio_ls_s *list);
@@ -2848,7 +2846,7 @@ FIO_FUNC inline void *fio_ls_remove(fio_ls_s *node) {
 }
 
 /** Adds an object to the list's head. */
-FIO_FUNC inline void fio_ls_push(fio_ls_s *pos, const void *obj) {
+FIO_FUNC inline fio_ls_s *fio_ls_push(fio_ls_s *pos, const void *obj) {
   /* prepare item */
   fio_ls_s *item = (fio_ls_s *)malloc(sizeof(*item));
   if (!item) {
@@ -2859,11 +2857,12 @@ FIO_FUNC inline void fio_ls_push(fio_ls_s *pos, const void *obj) {
   /* inject item */
   pos->prev->next = item;
   pos->prev = item;
+  return item;
 }
 
 /** Adds an object to the list's tail. */
-FIO_FUNC inline void fio_ls_unshift(fio_ls_s *pos, const void *obj) {
-  fio_ls_push(pos->next, obj);
+FIO_FUNC inline fio_ls_s *fio_ls_unshift(fio_ls_s *pos, const void *obj) {
+  return fio_ls_push(pos->next, obj);
 }
 
 /** Removes an object from the list's head. */
@@ -4207,9 +4206,9 @@ inline FIO_FUNC ssize_t fio_str_send_free2(const intptr_t uuid,
 typedef struct {
   FIO_SET_KEY_TYPE key;
   FIO_SET_OBJ_TYPE obj;
-} FIO_NAME(_couplet_s);
+} FIO_NAME(couplet_s);
 
-#define FIO_SET_TYPE FIO_NAME(_couplet_s)
+#define FIO_SET_TYPE FIO_NAME(couplet_s)
 
 /** key copy required? */
 #ifndef FIO_SET_KEY_COPY
@@ -4270,26 +4269,10 @@ FIO_FUNC void FIO_NAME(free)(FIO_NAME(s) * set);
  *
  * NOTE: This is the function's Hash Map variant. See FIO_SET_KEY_TYPE.
  */
-FIO_FUNC inline FIO_SET_OBJ_TYPE *
+FIO_FUNC inline FIO_SET_OBJ_TYPE
     FIO_NAME(find)(FIO_NAME(s) * set, const FIO_SET_HASH_TYPE hash_value,
                    FIO_SET_KEY_TYPE key);
 
-/**
- * Inserts an object to the Hash Map, rehashing if required, returning the new
- * object's location using a pointer.
- *
- * If an object already exists in the Hash Map with the same key, it will be
- * destroyed.
- *
- * NOTE 1: This is the function's Hash Map variant. See FIO_SET_KEY_TYPE.
- *
- * NOTE 2: This is equivelant to calling the `insert2` with `old` set to NULL.
- */
-FIO_FUNC inline void FIO_NAME(insert)(FIO_NAME(s) * set,
-                                      const FIO_SET_HASH_TYPE hash_value,
-                                      FIO_SET_KEY_TYPE key,
-                                      FIO_SET_OBJ_TYPE obj);
-
 /**
  * Inserts an object to the Hash Map, rehashing if required, returning the new
  * object's location using a pointer.
@@ -4301,22 +4284,11 @@ FIO_FUNC inline void FIO_NAME(insert)(FIO_NAME(s) * set,
  *
  * NOTE: This is the function's Hash Map variant. See FIO_SET_KEY_TYPE.
  */
-FIO_FUNC inline void FIO_NAME(insert2)(FIO_NAME(s) * set,
-                                       const FIO_SET_HASH_TYPE hash_value,
-                                       FIO_SET_KEY_TYPE key,
-                                       FIO_SET_OBJ_TYPE obj,
-                                       FIO_SET_OBJ_TYPE *old);
-
-/**
- * Removes an object from the Hash Map, rehashing if required.
- *
- * Returns 0 on success and -1 if the object wasn't found.
- *
- * NOTE: This is the function's Hash Map variant. See FIO_SET_KEY_TYPE.
- */
-FIO_FUNC inline int FIO_NAME(remove)(FIO_NAME(s) * set,
-                                     const FIO_SET_HASH_TYPE hash_value,
-                                     FIO_SET_KEY_TYPE key);
+FIO_FUNC inline void FIO_NAME(insert)(FIO_NAME(s) * set,
+                                      const FIO_SET_HASH_TYPE hash_value,
+                                      FIO_SET_KEY_TYPE key,
+                                      FIO_SET_OBJ_TYPE obj,
+                                      FIO_SET_OBJ_TYPE *old);
 
 /**
  * Removes an object from the Hash Map, rehashing if required.
@@ -4328,10 +4300,10 @@ FIO_FUNC inline int FIO_NAME(remove)(FIO_NAME(s) * set,
  *
  * NOTE: This is the function's Hash Map variant. See FIO_SET_KEY_TYPE.
  */
-FIO_FUNC inline int FIO_NAME(remove2)(FIO_NAME(s) * set,
-                                      const FIO_SET_HASH_TYPE hash_value,
-                                      FIO_SET_KEY_TYPE key,
-                                      FIO_SET_OBJ_TYPE *old);
+FIO_FUNC inline int FIO_NAME(remove)(FIO_NAME(s) * set,
+                                     const FIO_SET_HASH_TYPE hash_value,
+                                     FIO_SET_KEY_TYPE key,
+                                     FIO_SET_OBJ_TYPE *old);
 
 #else
 
@@ -4340,47 +4312,35 @@ FIO_FUNC inline int FIO_NAME(remove2)(FIO_NAME(s) * set,
  *
  * NOTE: This is the function's pure Set variant (no FIO_SET_KEY_TYPE).
  */
-FIO_FUNC inline FIO_SET_OBJ_TYPE *
+FIO_FUNC inline FIO_SET_OBJ_TYPE
     FIO_NAME(find)(FIO_NAME(s) * set, const FIO_SET_HASH_TYPE hash_value,
                    FIO_SET_OBJ_TYPE obj);
 
 /**
  * Inserts an object to the Set only if it's missing, rehashing if required,
- * returning the new (or old) object's pointer.
- *
+ * returning the new (or old) object.
  *
  * If the object already exists in the set, than the new object will be
- * destroyed and the old object's address will be returned.
+ * destroyed and the old object will be returned.
  *
  * NOTE: This is the function's pure Set variant (no FIO_SET_KEY_TYPE).
  */
-FIO_FUNC inline FIO_SET_OBJ_TYPE *
+FIO_FUNC inline FIO_SET_OBJ_TYPE
     FIO_NAME(insert)(FIO_NAME(s) * set, const FIO_SET_HASH_TYPE hash_value,
                      FIO_SET_OBJ_TYPE obj);
 
 /**
  * Inserts an object to the Set, rehashing if required, returning the new
- * object's pointer.
+ * object.
  *
  * If the object already exists in the set, it will be destroyed and
  * overwritten.
  *
- * NOTE: This function doesn't exist when FIO_SET_KEY_TYPE is defined.
- */
-FIO_FUNC inline FIO_SET_OBJ_TYPE *
-    FIO_NAME(overwrite)(FIO_NAME(s) * set, const FIO_SET_HASH_TYPE hash_value,
-                        FIO_SET_OBJ_TYPE obj);
-
-/**
- * The same as `overwrite`, only it copies the old object (if any) to the
- * location pointed to by `old`.
- *
  * When setting `old` to NULL, the function behaves the same as `overwrite`.
  */
-FIO_FUNC FIO_SET_OBJ_TYPE *FIO_NAME(replace)(FIO_NAME(s) * set,
-                                             const FIO_SET_HASH_TYPE hash_value,
-                                             FIO_SET_OBJ_TYPE obj,
-                                             FIO_SET_OBJ_TYPE *old);
+FIO_FUNC FIO_SET_OBJ_TYPE
+    FIO_NAME(overwrite)(FIO_NAME(s) * set, const FIO_SET_HASH_TYPE hash_value,
+                        FIO_SET_OBJ_TYPE obj, FIO_SET_OBJ_TYPE *old);
 
 /**
  * Removes an object from the Set, rehashing if required.
@@ -4391,7 +4351,8 @@ FIO_FUNC FIO_SET_OBJ_TYPE *FIO_NAME(replace)(FIO_NAME(s) * set,
  */
 FIO_FUNC inline int FIO_NAME(remove)(FIO_NAME(s) * set,
                                      const FIO_SET_HASH_TYPE hash_value,
-                                     FIO_SET_OBJ_TYPE obj);
+                                     FIO_SET_OBJ_TYPE obj,
+                                     FIO_SET_OBJ_TYPE *old);
 
 #endif
 /**
@@ -4400,7 +4361,7 @@ FIO_FUNC inline int FIO_NAME(remove)(FIO_NAME(s) * set,
  * Remember that objects might be destroyed if the Set is altered
  * (`FIO_SET_OBJ_DESTROY` / `FIO_SET_KEY_DESTROY`).
  */
-FIO_FUNC inline FIO_SET_TYPE *FIO_NAME(last)(FIO_NAME(s) * set);
+FIO_FUNC inline FIO_SET_TYPE FIO_NAME(last)(FIO_NAME(s) * set);
 
 /**
  * Allows the Hash to be momentarily used as a stack, destroying the last
@@ -4579,11 +4540,14 @@ FIO_FUNC inline void FIO_NAME(_reallocate_set_mem_)(FIO_NAME(s) * set) {
  * If the object already exists in the set, it will be destroyed and
  * overwritten.
  */
-FIO_FUNC inline FIO_SET_TYPE *FIO_NAME(_insert_or_overwrite_)(
+FIO_FUNC inline FIO_SET_TYPE FIO_NAME(_insert_or_overwrite_)(
     FIO_NAME(s) * set, const FIO_SET_HASH_TYPE hash_value, FIO_SET_TYPE obj,
     int overwrite, FIO_SET_OBJ_TYPE *old) {
-  if (FIO_SET_HASH_COMPARE(hash_value, FIO_SET_HASH_INVALID))
-    return NULL;
+  if (FIO_SET_HASH_COMPARE(hash_value, FIO_SET_HASH_INVALID)) {
+    FIO_SET_TYPE empty;
+    memset(&empty, 0, sizeof(empty));
+    return empty;
+  }
 
   /* automatic fragmentation protection */
   if (FIO_NAME(is_fragmented)(set))
@@ -4603,7 +4567,7 @@ FIO_FUNC inline FIO_SET_TYPE *FIO_NAME(_insert_or_overwrite_)(
     /* overwrite existing object */
     if (!overwrite) {
       FIO_SET_DESTROY(obj);
-      return &pos->pos->obj;
+      return pos->pos->obj;
     }
 #ifdef FIO_SET_KEY_TYPE
     if (old) {
@@ -4612,7 +4576,7 @@ FIO_FUNC inline FIO_SET_TYPE *FIO_NAME(_insert_or_overwrite_)(
     /* no need to recreate the key object, just the value object */
     FIO_SET_OBJ_DESTROY(pos->pos->obj.obj);
     FIO_SET_OBJ_COPY(pos->pos->obj.obj, obj.obj);
-    return &pos->pos->obj;
+    return pos->pos->obj;
 #else
     if (old) {
       FIO_SET_COPY((*old), pos->pos->obj);
@@ -4630,7 +4594,7 @@ FIO_FUNC inline FIO_SET_TYPE *FIO_NAME(_insert_or_overwrite_)(
   pos->pos->hash = hash_value;
   FIO_SET_COPY(pos->pos->obj, obj);
 
-  return &pos->pos->obj;
+  return pos->pos->obj;
 }
 
 /* *****************************************************************************
@@ -4661,29 +4625,17 @@ FIO_FUNC void FIO_NAME(free)(FIO_NAME(s) * s) {
  *
  * NOTE: This is the function's Hash Map variant. See FIO_SET_KEY_TYPE.
  */
-FIO_FUNC FIO_SET_OBJ_TYPE *FIO_NAME(find)(FIO_NAME(s) * set,
-                                          const FIO_SET_HASH_TYPE hash_value,
-                                          FIO_SET_KEY_TYPE key) {
+FIO_FUNC FIO_SET_OBJ_TYPE FIO_NAME(find)(FIO_NAME(s) * set,
+                                         const FIO_SET_HASH_TYPE hash_value,
+                                         FIO_SET_KEY_TYPE key) {
   FIO_NAME(_map_s_) *pos =
       FIO_NAME(_find_map_pos_)(set, hash_value, (FIO_SET_TYPE){.key = key});
-  if (!pos || !pos->pos)
-    return NULL;
-  return &pos->pos->obj.obj;
-}
-
-/**
- * Inserts an object to the Hash Map, rehashing if required, returning the new
- * object's location using a pointer.
- *
- * If the object already exists in the set, it will be destroyed.
- *
- * NOTE: This is the function's Hash Map variant. See FIO_SET_KEY_TYPE.
- */
-FIO_FUNC void FIO_NAME(insert)(FIO_NAME(s) * set,
-                               const FIO_SET_HASH_TYPE hash_value,
-                               FIO_SET_KEY_TYPE key, FIO_SET_OBJ_TYPE obj) {
-  FIO_NAME(_insert_or_overwrite_)
-  (set, hash_value, (FIO_SET_TYPE){.key = key, .obj = obj}, 1, NULL);
+  if (!pos || !pos->pos) {
+    FIO_SET_OBJ_TYPE empty;
+    memset(&empty, 0, sizeof(empty));
+    return empty;
+  }
+  return pos->pos->obj.obj;
 }
 
 /**
@@ -4697,10 +4649,10 @@ FIO_FUNC void FIO_NAME(insert)(FIO_NAME(s) * set,
  *
  * NOTE: This is the function's Hash Map variant. See FIO_SET_KEY_TYPE.
  */
-FIO_FUNC void FIO_NAME(insert2)(FIO_NAME(s) * set,
-                                const FIO_SET_HASH_TYPE hash_value,
-                                FIO_SET_KEY_TYPE key, FIO_SET_OBJ_TYPE obj,
-                                FIO_SET_OBJ_TYPE *old) {
+FIO_FUNC void FIO_NAME(insert)(FIO_NAME(s) * set,
+                               const FIO_SET_HASH_TYPE hash_value,
+                               FIO_SET_KEY_TYPE key, FIO_SET_OBJ_TYPE obj,
+                               FIO_SET_OBJ_TYPE *old) {
   FIO_NAME(_insert_or_overwrite_)
   (set, hash_value, (FIO_SET_TYPE){.key = key, .obj = obj}, 1, old);
 }
@@ -4715,10 +4667,10 @@ FIO_FUNC void FIO_NAME(insert2)(FIO_NAME(s) * set,
  *
  * NOTE: This is the function's Hash Map variant. See FIO_SET_KEY_TYPE.
  */
-FIO_FUNC inline int FIO_NAME(remove2)(FIO_NAME(s) * set,
-                                      const FIO_SET_HASH_TYPE hash_value,
-                                      FIO_SET_KEY_TYPE key,
-                                      FIO_SET_OBJ_TYPE *old) {
+FIO_FUNC inline int FIO_NAME(remove)(FIO_NAME(s) * set,
+                                     const FIO_SET_HASH_TYPE hash_value,
+                                     FIO_SET_KEY_TYPE key,
+                                     FIO_SET_OBJ_TYPE *old) {
   if (FIO_SET_HASH_COMPARE(hash_value, FIO_SET_HASH_INVALID))
     return -1;
   FIO_NAME(_map_s_) *pos =
@@ -4740,22 +4692,19 @@ FIO_FUNC inline int FIO_NAME(remove2)(FIO_NAME(s) * set,
   return 0;
 }
 
-FIO_FUNC inline int FIO_NAME(remove)(FIO_NAME(s) * set,
-                                     const FIO_SET_HASH_TYPE hash_value,
-                                     FIO_SET_KEY_TYPE key) {
-  return FIO_NAME(remove2)(set, hash_value, key, NULL);
-}
-
 #else
 
 /** Locates an object in the Set, if it exists. */
-FIO_FUNC FIO_SET_OBJ_TYPE *FIO_NAME(find)(FIO_NAME(s) * set,
-                                          const FIO_SET_HASH_TYPE hash_value,
-                                          FIO_SET_OBJ_TYPE obj) {
+FIO_FUNC FIO_SET_OBJ_TYPE FIO_NAME(find)(FIO_NAME(s) * set,
+                                         const FIO_SET_HASH_TYPE hash_value,
+                                         FIO_SET_OBJ_TYPE obj) {
   FIO_NAME(_map_s_) *pos = FIO_NAME(_find_map_pos_)(set, hash_value, obj);
-  if (!pos || !pos->pos)
-    return NULL;
-  return &pos->pos->obj;
+  if (!pos || !pos->pos) {
+    FIO_SET_OBJ_TYPE empty;
+    memset(&empty, 0, sizeof(empty));
+    return empty;
+  }
+  return pos->pos->obj;
 }
 
 /**
@@ -4765,9 +4714,9 @@ FIO_FUNC FIO_SET_OBJ_TYPE *FIO_NAME(find)(FIO_NAME(s) * set,
  * If the object already exists in the set, than the new object will be
  * destroyed and the old object's address will be returned.
  */
-FIO_FUNC FIO_SET_OBJ_TYPE *FIO_NAME(insert)(FIO_NAME(s) * set,
-                                            const FIO_SET_HASH_TYPE hash_value,
-                                            FIO_SET_OBJ_TYPE obj) {
+FIO_FUNC FIO_SET_OBJ_TYPE FIO_NAME(insert)(FIO_NAME(s) * set,
+                                           const FIO_SET_HASH_TYPE hash_value,
+                                           FIO_SET_OBJ_TYPE obj) {
   return FIO_NAME(_insert_or_overwrite_)(set, hash_value, obj, 0, NULL);
 }
 
@@ -4777,23 +4726,12 @@ FIO_FUNC FIO_SET_OBJ_TYPE *FIO_NAME(insert)(FIO_NAME(s) * set,
  *
  * If the object already exists in the set, it will be destroyed and
  * overwritten.
- */
-FIO_FUNC FIO_SET_OBJ_TYPE *
-FIO_NAME(overwrite)(FIO_NAME(s) * set, const FIO_SET_HASH_TYPE hash_value,
-                    FIO_SET_OBJ_TYPE obj) {
-  return FIO_NAME(_insert_or_overwrite_)(set, hash_value, obj, 1, NULL);
-}
-
-/**
- * The same as `overwrite`, only it copies the old object (if any) to the
- * location pointed to by `old`.
  *
  * When setting `old` to NULL, the function behaves the same as `overwrite`.
  */
-FIO_FUNC FIO_SET_OBJ_TYPE *FIO_NAME(replace)(FIO_NAME(s) * set,
-                                             const FIO_SET_HASH_TYPE hash_value,
-                                             FIO_SET_OBJ_TYPE obj,
-                                             FIO_SET_OBJ_TYPE *old) {
+FIO_FUNC FIO_SET_OBJ_TYPE
+FIO_NAME(overwrite)(FIO_NAME(s) * set, const FIO_SET_HASH_TYPE hash_value,
+                    FIO_SET_OBJ_TYPE obj, FIO_SET_OBJ_TYPE *old) {
   return FIO_NAME(_insert_or_overwrite_)(set, hash_value, obj, 1, old);
 }
 
@@ -4802,12 +4740,14 @@ FIO_FUNC FIO_SET_OBJ_TYPE *FIO_NAME(replace)(FIO_NAME(s) * set,
  */
 FIO_FUNC int FIO_NAME(remove)(FIO_NAME(s) * set,
                               const FIO_SET_HASH_TYPE hash_value,
-                              FIO_SET_OBJ_TYPE obj) {
+                              FIO_SET_OBJ_TYPE obj, FIO_SET_OBJ_TYPE *old) {
   if (FIO_SET_HASH_COMPARE(hash_value, FIO_SET_HASH_INVALID))
     return -1;
   FIO_NAME(_map_s_) *pos = FIO_NAME(_find_map_pos_)(set, hash_value, obj);
   if (!pos || !pos->pos)
     return -1;
+  if (old)
+    FIO_SET_COPY((*old), pos->pos->obj);
   FIO_SET_DESTROY(pos->pos->obj);
   --set->count;
   pos->pos->hash = FIO_SET_HASH_INVALID;
@@ -4829,10 +4769,13 @@ FIO_FUNC int FIO_NAME(remove)(FIO_NAME(s) * set,
  * Remember that objects might be destroyed if the Set is altered
  * (`FIO_SET_OBJ_DESTROY` / `FIO_SET_KEY_DESTROY`).
  */
-FIO_FUNC inline FIO_SET_TYPE *FIO_NAME(last)(FIO_NAME(s) * set) {
-  if (!set->ordered || !set->pos)
-    return NULL;
-  return &set->ordered[set->pos - 1].obj;
+FIO_FUNC inline FIO_SET_TYPE FIO_NAME(last)(FIO_NAME(s) * set) {
+  if (!set->ordered || !set->pos) {
+    FIO_SET_TYPE empty;
+    memset(&empty, 0, sizeof(empty));
+    return empty;
+  }
+  return set->ordered[set->pos - 1].obj;
 }
 
 /**