iodine 0.7.4 → 0.7.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6853939131113d6d1055ae516e38fb0f5ced25fa9fdc6f1915e2fb59cd7af749
-  data.tar.gz: 628c7b663864b8f99a79e6a37ebe26be080e5f4bed537715717c7e2879e1cbaa
+  metadata.gz: 21610266b95f78b98341f1cfad626edec6f6aa903befe8c8ba6defa863c650ed
+  data.tar.gz: 2260a4db63a0a833d2d6902d3f54aed522d67f33378904caedd1c77eb6517c3f
 SHA512:
-  metadata.gz: 133121bf7da250b83f7e4131e68b09cc66bc972a91338ad54e77597c2ed433e8b86be546ce80272414573c386ed043a681c8255fc4316599c1686eb72d2fb144
-  data.tar.gz: e28e559b199684495cbf767cd75983aa51859b0544c3017f314ef848add51c088adf4551d1ab7abe7a4ec331580fbc25c802c1ff0860ae2c437a58864628de9f
+  metadata.gz: b9b5ac545d5b135548e5c781fb0212afba358b55b7e7b497212cfabd07924b56549fdb85a892162ae1c7e0f0be0d93d0d18c38bdb36d7f64c67fd5266fa1c307
+  data.tar.gz: ae58b456d93c90037847867d62b4f2243599618f5a9445a8c5b143c747567c96479881ee4571eea3ba58ea92d54091c76141eb33d96693fd5baf65333c9c98ea

data/CHANGELOG.md

@@ -6,6 +6,14 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ## Changes:
 
+#### Change log v.0.7.5
+
+**Fix**: fixed issue with direct calls to `publish` in the pre-defined pub/sub engines. These direct calls are used by custom engines when the default engine was replaced and would attempt (erroneously) direct engine access rather than use the `fio_publish` function.
+
+**Fix**: fixed possible Array overflow risk that could result in memory corruption in some cases.
+
+**Fix**: fixed more missing `static` keywords in the code. these should have little or no effect on the namespace (they were using long unique names with the `iodine` prefix).
+
 #### Change log v.0.7.4
 
 **Fix**: fixed a missing `static` keyword in the Ruby<=>C storage bridge which caused performance degradation and introduced namespace conflict risks.

data/examples/pubsub_engine.ru

@@ -7,7 +7,7 @@ require 'iodine'
 class PubSubReporter < Iodine::PubSub::Engine
   def initialize
     # make sure engine setup is complete
-    super 
+    super
     # register engine and make it into the new default
     @target = Iodine::PubSub.default
     Iodine::PubSub.default = self
@@ -20,7 +20,7 @@ class PubSubReporter < Iodine::PubSub::Engine
     puts "* Unsubscribing to \"#{to}\" (#{as || "exact match"})"
   end
   def publish to, msg
-    puts "* Publishing to \"#{to}\": #{msg.to_s[0..6]}..."
+    puts "* Publishing to \"#{to}\": #{msg.to_s[0..12]}..."
     # we need to forward the message to the actual engine (the previous default engine),
     # or it will never be received by any Pub/Sub client.
     @target.publish to, msg

data/ext/iodine/fio.c

@@ -224,9 +224,9 @@ typedef struct {
 
 /** The logging level */
 #if DEBUG
-size_t FIO_LOG_LEVEL = FIO_LOG_LEVEL_DEBUG;
+int FIO_LOG_LEVEL = FIO_LOG_LEVEL_DEBUG;
 #else
-size_t FIO_LOG_LEVEL = FIO_LOG_LEVEL_INFO;
+int FIO_LOG_LEVEL = FIO_LOG_LEVEL_INFO;
 #endif
 static fio_data_s *fio_data = NULL;
 

data/ext/iodine/fio.h

@@ -319,6 +319,22 @@ void *fio_mmap(size_t size);
  */
 void fio_malloc_after_fork(void);
 
+#if FIO_FORCE_MALLOC
+#define FIO_MALLOC(size) malloc((size))
+#define FIO_CALLOC(size, units) calloc((size), (units))
+#define FIO_REALLOC(ptr, new_length, existing_data_length)                     \
+  realloc((ptr), (new_length))
+#define FIO_FREE free
+
+#else
+#define FIO_MALLOC(size) fio_malloc((size))
+#define FIO_CALLOC(size, units) fio_calloc((size), (units))
+#define FIO_REALLOC(ptr, new_length, existing_data_length)                     \
+  fio_realloc2((ptr), (new_length), (existing_data_length))
+#define FIO_FREE fio_free
+
+#endif
+
 /* *****************************************************************************
 
 
@@ -361,13 +377,23 @@ Logging and testing helpers
 #define FIO_LOG_LEVEL_DEBUG 5
 
 /** The logging level */
-extern size_t FIO_LOG_LEVEL;
+extern int FIO_LOG_LEVEL;
 
 #ifndef FIO_LOG_PRINT
 #define FIO_LOG_PRINT(level, ...)                                              \
   do {                                                                         \
-    if (level <= FIO_LOG_LEVEL)                                                \
-      fprintf(stderr, "\n" __VA_ARGS__);                                       \
+    if (level <= FIO_LOG_LEVEL) {                                              \
+      char tmp___log[512];                                                     \
+      int len___log = snprintf(tmp___log, 500, __VA_ARGS__);                   \
+      if (len___log <= 0 || len___log > 500) {                                 \
+        fwrite("ERROR: log line output too long (can't write).", 46, 1,        \
+               stderr);                                                        \
+        break;                                                                 \
+      }                                                                        \
+      tmp___log[len___log++] = '\n';                                           \
+      tmp___log[len___log] = '0';                                              \
+      fwrite(tmp___log, len___log, 1, stderr);                                 \
+    }                                                                          \
   } while (0)
 #define FIO_LOG_DEBUG(...)                                                     \
   FIO_LOG_PRINT(FIO_LOG_LEVEL_DEBUG,                                           \
@@ -384,7 +410,7 @@ extern size_t FIO_LOG_LEVEL;
 #endif
 
 #if FIO_PRINT_STATE
-#define FIO_LOG_STATE(...) fprintf(stderr, "\n" __VA_ARGS__)
+#define FIO_LOG_STATE(...) FIO_LOG_PRINT(0, __VA_ARGS__)
 #else
 #define FIO_LOG_STATE(...)
 #endif
@@ -1022,12 +1048,12 @@ inline FIO_FUNC ssize_t fio_write(const intptr_t uuid, const void *buffer,
                                   const size_t length) {
   if (!length || !buffer)
     return 0;
-  void *cpy = fio_malloc(length);
+  void *cpy = FIO_MALLOC(length);
   if (!cpy)
     return -1;
   memcpy(cpy, buffer, length);
   return fio_write2(uuid, .data.buffer = cpy, .length = length,
-                    .after.dealloc = fio_free);
+                    .after.dealloc = FIO_FREE);
 }
 
 /**
@@ -2981,7 +3007,7 @@ typedef struct {
   ((fio_str_s){.data = (buffer),                                               \
                .len = (length),                                                \
                .capa = (capacity),                                             \
-               .dealloc = fio_free})
+               .dealloc = FIO_FREE})
 
 /**
  * This macro allows the container to be initialized with existing data, as long
@@ -3285,7 +3311,7 @@ inline FIO_FUNC fio_str_info_s fio_str_info(const fio_str_s *s) {
  * NOTE: This makes the allocation and reference counting logic more intuitive.
  */
 inline FIO_FUNC fio_str_s *fio_str_new2(void) {
-  fio_str_s *str = fio_malloc(sizeof(*str));
+  fio_str_s *str = FIO_MALLOC(sizeof(*str));
   FIO_ASSERT_ALLOC(str);
   *str = FIO_STR_INIT;
   return str;
@@ -3358,7 +3384,7 @@ FIO_FUNC void fio_str_free2(fio_str_s *s) {
   if (fio_str_free(s)) {
     return;
   }
-  fio_free(s);
+  FIO_FREE(s);
 }
 
 /** Returns the String's length in bytes. */
@@ -3457,11 +3483,11 @@ FIO_FUNC fio_str_info_s fio_str_capa_assert(fio_str_s *s, size_t needed) {
   }
   if (needed > s->capa) {
     needed = ROUND_UP_CAPA2WORDS(needed);
-    if (s->dealloc == fio_free) {
-      tmp = (char *)fio_realloc2(s->data, needed + 1, s->len);
+    if (s->dealloc == FIO_FREE) {
+      tmp = (char *)FIO_REALLOC(s->data, needed + 1, s->len);
       FIO_ASSERT_ALLOC(tmp);
     } else {
-      tmp = (char *)fio_malloc(needed + 1);
+      tmp = (char *)FIO_MALLOC(needed + 1);
       FIO_ASSERT_ALLOC(tmp);
       memcpy(tmp, s->data, s->len);
       if (s->dealloc)
@@ -3482,7 +3508,7 @@ is_small:
                             .data = FIO_STR_SMALL_DATA(s)};
   }
   needed = ROUND_UP_CAPA2WORDS(needed);
-  tmp = (char *)fio_malloc(needed + 1);
+  tmp = (char *)FIO_MALLOC(needed + 1);
   FIO_ASSERT_ALLOC(tmp);
   const size_t existing_len = (size_t)((s->small >> 1) & 0xFF);
   if (existing_len) {
@@ -3495,7 +3521,7 @@ is_small:
       .small = 0,
       .capa = needed,
       .len = existing_len,
-      .dealloc = fio_free,
+      .dealloc = FIO_FREE,
       .data = tmp,
   };
 #else
@@ -3504,7 +3530,7 @@ is_small:
       .small = 0,
       .capa = needed,
       .len = existing_len,
-      .dealloc = fio_free,
+      .dealloc = FIO_FREE,
       .data = tmp,
   };
 #endif
@@ -3534,7 +3560,7 @@ shrink2small:
   if (len) {
     memcpy(FIO_STR_SMALL_DATA(s), tmp, len + 1);
   }
-  fio_free(tmp);
+  FIO_FREE(tmp);
 }
 
 /* *****************************************************************************
@@ -3938,7 +3964,7 @@ FIO_FUNC fio_str_info_s fio_str_readfile(fio_str_s *s, const char *filename,
       if (home[home_len - 1] == '/' || home[home_len - 1] == '\\')
         --home_len;
       path_len = home_len + filename_len - 1;
-      path = fio_malloc(path_len + 1);
+      path = FIO_MALLOC(path_len + 1);
       FIO_ASSERT_ALLOC(path);
       memcpy(path, home, home_len);
       memcpy(path + home_len, filename + 1, filename_len);
@@ -3978,7 +4004,7 @@ FIO_FUNC fio_str_info_s fio_str_readfile(fio_str_s *s, const char *filename,
   }
   close(file);
 finish:
-  fio_free(path);
+  FIO_FREE(path);
   return state;
 #else
   /* TODO: consider adding non POSIX implementations. */
@@ -4130,17 +4156,17 @@ static FIO_ARY_TYPE const FIO_NAME(s___const_invalid_object);
 
 /* Customizable memory management */
 #ifndef FIO_ARY_MALLOC /* NULL ptr indicates new allocation */
-#define FIO_ARY_MALLOC(size) fio_malloc((size))
+#define FIO_ARY_MALLOC(size) FIO_MALLOC((size))
 #endif
 
 /* Customizable memory management */
 #ifndef FIO_ARY_REALLOC /* NULL ptr indicates new allocation */
 #define FIO_ARY_REALLOC(ptr, original_size, new_size, valid_data_length)       \
-  fio_realloc2((ptr), (new_size), (valid_data_length))
+  FIO_REALLOC((ptr), (new_size), (valid_data_length))
 #endif
 
 #ifndef FIO_ARY_DEALLOC
-#define FIO_ARY_DEALLOC(ptr, size) fio_free((ptr))
+#define FIO_ARY_DEALLOC(ptr, size) FIO_FREE((ptr))
 #endif
 
 /* padding to be assumed for future expansion. */
@@ -4351,13 +4377,13 @@ FIO_FUNC inline intptr_t FIO_NAME(__rel2absolute)(FIO_NAME(s) * ary,
 FIO_FUNC void FIO_NAME(__require_on_top)(FIO_NAME(s) * ary, size_t len) {
   if (ary->end + len < ary->capa)
     return;
-  len = FIO_ARY_SIZE2WORDS(len + ary->end);
+  len = FIO_ARY_SIZE2WORDS((len + ary->end));
   /* reallocate enough memory */
   ary->arry = FIO_ARY_REALLOC(ary->arry, sizeof(*ary->arry) * ary->capa,
                               (len) * sizeof(*ary->arry),
                               ary->end * sizeof(*ary->arry));
   FIO_ASSERT_ALLOC(ary->arry);
-  ary->capa = len + 1;
+  ary->capa = len;
 }
 
 /** Makes sure that `len` positions are available at the Array's head. */
@@ -4380,7 +4406,7 @@ FIO_FUNC void FIO_NAME(__require_on_bottom)(FIO_NAME(s) * ary, size_t len) {
             len * sizeof(*ary->arry));
   ary->start = ary->end - len;
   if (tmp != ary->arry) {
-    fio_free(tmp);
+    FIO_FREE(tmp);
   }
 }
 
@@ -4804,7 +4830,7 @@ FIO_FUNC inline void FIO_NAME(_test)(void) {
 }
 #undef TEST_LIMIT
 #else
-FIO_FUNC inline void FIO_NAME(_test)(void);
+FIO_FUNC inline void FIO_NAME(_test)(void) {}
 #endif
 
 /* *****************************************************************************
@@ -4985,13 +5011,15 @@ Done
 /* Customizable memory management */
 #ifndef FIO_SET_REALLOC /* NULL ptr indicates new allocation */
 #define FIO_SET_REALLOC(ptr, original_size, new_size, valid_data_length)       \
-  fio_realloc2((ptr), (new_size), (valid_data_length))
+  FIO_REALLOC((ptr), (new_size), (valid_data_length))
 #endif
+
 #ifndef FIO_SET_CALLOC
-#define FIO_SET_CALLOC(size, count) fio_calloc((size), (count))
+#define FIO_SET_CALLOC(size, count) FIO_CALLOC((size), (count))
 #endif
+
 #ifndef FIO_SET_FREE
-#define FIO_SET_FREE(ptr, size) fio_free((ptr))
+#define FIO_SET_FREE(ptr, size) FIO_FREE((ptr))
 #endif
 
 /* The maximum number of bins to rotate when partial collisions occure */
@@ -5354,16 +5382,17 @@ FIO_FUNC inline FIO_SET_TYPE FIO_NAME(_insert_or_overwrite_)(
   /* automatic fragmentation protection */
   if (FIO_NAME(is_fragmented)(set))
     FIO_NAME(rehash)(set);
+  /* automatic capacity validation (we can never be at 100% capacity) */
+  else if (set->pos >= set->capa) {
+    set->mask = (set->mask << 1) | 3;
+    FIO_NAME(rehash)(set);
+  }
 
-  /* locate future position, rehashing until a position is available */
+  /* locate future position */
   FIO_NAME(_map_s_) *pos = FIO_NAME(_find_map_pos_)(set, hash_value, obj);
+
   if (!pos) {
-    /* no pos - so we know that we are inserting an object. */
-    /* Either we are over capacity, or we have too many holes in the map. */
-    if (set->pos >= set->capa) {
-      set->mask = (set->mask << 1) | 3;
-      FIO_NAME(rehash)(set);
-    }
+    /* inserting a new object, with too many holes in the map */
     FIO_SET_COPY(set->ordered[set->pos].obj, obj);
     set->ordered[set->pos].hash = hash_value;
     ++set->pos;
@@ -5493,6 +5522,7 @@ FIO_FUNC inline int FIO_NAME(remove)(FIO_NAME(s) * set,
   --set->count;
   pos->pos->hash = FIO_SET_HASH_INVALID;
   if (pos->pos == set->pos + set->ordered - 1) {
+    /* removing last item inserted */
     pos->hash = FIO_SET_HASH_INVALID; /* no need for a "hole" */
     do {
       --set->pos;
@@ -5563,6 +5593,8 @@ FIO_FUNC int FIO_NAME(remove)(FIO_NAME(s) * set,
   --set->count;
   pos->pos->hash = FIO_SET_HASH_INVALID;
   if (pos->pos == set->pos + set->ordered - 1) {
+    /* removing last item inserted */
+    pos->hash = FIO_SET_HASH_INVALID; /* no need for a "hole" */
     do {
       --set->pos;
     } while (set->pos && FIO_SET_HASH_COMPARE(set->ordered[set->pos - 1].hash,

data/ext/iodine/fiobject.c

@@ -61,10 +61,10 @@ void *__attribute__((weak)) fio_mmap(size_t size) { return fio_malloc(size); }
 /** The logging level */
 #if DEBUG
 #pragma weak FIO_LOG_LEVEL
-size_t __attribute__((weak)) FIO_LOG_LEVEL = FIO_LOG_LEVEL_DEBUG;
+int __attribute__((weak)) FIO_LOG_LEVEL = FIO_LOG_LEVEL_DEBUG;
 #else
 #pragma weak FIO_LOG_LEVEL
-size_t __attribute__((weak)) FIO_LOG_LEVEL = FIO_LOG_LEVEL_INFO;
+int __attribute__((weak)) FIO_LOG_LEVEL = FIO_LOG_LEVEL_INFO;
 #endif
 
 /**

data/ext/iodine/iodine.c

@@ -156,7 +156,7 @@ static VALUE iodine_logging_get(VALUE self) {
  */
 static VALUE iodine_logging_set(VALUE self, VALUE val) {
   Check_Type(val, T_FIXNUM);
-  FIO_LOG_LEVEL = FIX2ULONG(val);
+  FIO_LOG_LEVEL = FIX2INT(val);
   return self;
 }
 

data/ext/iodine/iodine_defer.c

@@ -61,7 +61,7 @@ struct CreateThreadArgs {
 };
 
 /* used for GVL signalling */
-void call_async_signal(void *pool) {
+static void call_async_signal(void *pool) {
   fio_stop();
   (void)pool;
 }
@@ -292,7 +292,7 @@ Sets a block of code to run before a new worker process is forked (cluster mode
 
 Code runs within the master (root) process.
 */
-VALUE iodine_before_fork_add(VALUE self) {
+static VALUE iodine_before_fork_add(VALUE self) {
   // clang-format on
   rb_need_block();
   VALUE block = rb_block_proc();
@@ -309,7 +309,7 @@ Sets a block of code to run after a new worker process is forked (cluster mode o
 
 Code runs in both the parent and the child.
 */
-VALUE iodine_after_fork_add(VALUE self) {
+static VALUE iodine_after_fork_add(VALUE self) {
   // clang-format on
   rb_need_block();
   VALUE block = rb_block_proc();
@@ -326,7 +326,7 @@ Sets a block of code to run after a new worker process is forked (cluster mode o
 
 Code runs in both the parent and the child.
 */
-VALUE iodine_after_fork_in_worker_add(VALUE self) {
+static VALUE iodine_after_fork_in_worker_add(VALUE self) {
   // clang-format on
   rb_need_block();
   VALUE block = rb_block_proc();
@@ -343,7 +343,7 @@ Sets a block of code to run after a new worker process is forked (cluster mode o
 
 Code runs in both the parent and the child.
 */
-VALUE iodine_after_fork_in_master_add(VALUE self) {
+static VALUE iodine_after_fork_in_master_add(VALUE self) {
   // clang-format on
   rb_need_block();
   VALUE block = rb_block_proc();
@@ -358,7 +358,7 @@ VALUE iodine_after_fork_in_master_add(VALUE self) {
 /**
 Sets a block of code to run once a Worker process shuts down (both in single process mode and cluster mode).
 */
-VALUE iodine_on_shutdown_add(VALUE self) {
+static VALUE iodine_on_shutdown_add(VALUE self) {
   // clang-format on
   rb_need_block();
   VALUE block = rb_block_proc();

data/ext/iodine/iodine_http.c

@@ -246,7 +246,7 @@ Copying data from the C request to the Rack's ENV
 
 #define to_upper(c) (((c) >= 'a' && (c) <= 'z') ? ((c) & ~32) : (c))
 
-int iodine_copy2env_task(FIOBJ o, void *env_) {
+static int iodine_copy2env_task(FIOBJ o, void *env_) {
   VALUE env = (VALUE)env_;
   FIOBJ name = fiobj_hash_key_in_loop();
   fio_str_info_s tmp = fiobj_obj2cstr(name);
@@ -285,6 +285,7 @@ int iodine_copy2env_task(FIOBJ o, void *env_) {
   }
   return 0;
 }
+
 static inline VALUE copy2env(iodine_http_request_handle_s *handle) {
   VALUE env;
   http_s *h = handle->h;
@@ -819,7 +820,7 @@ Once HTTP/2 is supported (planned, but probably very far away), HTTP/2
 timeouts will be dynamically managed by Iodine. The `timeout` option is only
 relevant to HTTP/1.x connections.
 */
-VALUE iodine_http_listen(VALUE self, VALUE opt) {
+static VALUE iodine_http_listen(VALUE self, VALUE opt) {
   // clang-format on
   uint8_t log_http = 0;
   size_t ping = 0;

data/ext/iodine/iodine_json.c

@@ -15,6 +15,7 @@ static VALUE object_class;
 static VALUE array_class;
 
 #define FIO_ARY_NAME fio_json_stack
+#define FIO_ARY_TYPE VALUE
 #include "fio.h"
 
 /* *****************************************************************************
@@ -97,13 +98,13 @@ static int fio_json_on_start_object(json_parser_s *p) {
   iodine_json_parser_s *pr = (iodine_json_parser_s *)p;
   if (pr->target) {
     /* push NULL, don't free the objects */
-    fio_json_stack_push(&pr->stack, (void *)pr->top);
+    fio_json_stack_push(&pr->stack, pr->top);
     pr->top = pr->target;
     pr->target = 0;
   } else {
     VALUE h = rb_hash_new();
     iodine_json_add2parser(pr, h);
-    fio_json_stack_push(&pr->stack, (void *)pr->top);
+    fio_json_stack_push(&pr->stack, pr->top);
     pr->top = h;
   }
   pr->is_hash = 1;
@@ -128,7 +129,7 @@ static int fio_json_on_start_array(json_parser_s *p) {
     return -1;
   VALUE ary = rb_ary_new();
   iodine_json_add2parser(pr, ary);
-  fio_json_stack_push(&pr->stack, (void *)pr->top);
+  fio_json_stack_push(&pr->stack, pr->top);
   pr->top = ary;
   pr->is_hash = 0;
   return 0;

data/ext/iodine/iodine_mustache.c

@@ -27,7 +27,7 @@ static void iodine_mustache_data_free(void *c_) {
   (void)c_;
 }
 
-const rb_data_type_t iodine_mustache_data_type = {
+static const rb_data_type_t iodine_mustache_data_type = {
     .wrap_struct_name = "IodineMustacheData",
     .function =
         {

data/ext/iodine/iodine_pubsub.c

@@ -130,17 +130,6 @@ CLUSTER (not just this process) subscribes to a stream / channel.
 */
 static VALUE iodine_pubsub_subscribe(VALUE self, VALUE to, VALUE match) {
   return Qnil;
-#if 0
-  iodine_pubsub_s *e = iodine_pubsub_CData(self);
-  if (e->engine == &e->do_not_touch) {
-    /* this is a Ruby engine, nothing to do. */
-    return Qnil;
-  }
-  FIOBJ ch = fiobj_str_new(RSTRING_PTR(to), RSTRING_LEN(to));
-  e->engine->subscribe(e->engine, ch, SYM2ID(match) == redis_id);
-  fiobj_free(ch);
-  return to;
-#endif
   (void)self;
   (void)to;
   (void)match;
@@ -152,17 +141,6 @@ process CLUSTER (not just this process) unsubscribes from a stream / channel.
 */
 static VALUE iodine_pubsub_unsubscribe(VALUE self, VALUE to, VALUE match) {
   return Qnil;
-#if 0
-  iodine_pubsub_s *e = iodine_pubsub_CData(self);
-  if (e->engine == &e->do_not_touch) {
-    /* this is a Ruby engine, nothing to do. */
-    return Qnil;
-  }
-  FIOBJ ch = fiobj_str_new(RSTRING_PTR(to), RSTRING_LEN(to));
-  e->engine->unsubscribe(e->engine, ch, SYM2ID(match) == redis_id);
-  fiobj_free(ch);
-  return to;
-#endif
   (void)self;
   (void)to;
   (void)match;
@@ -181,12 +159,12 @@ NOTE: this callback is called per process event (not per cluster event) and the
 */
 static VALUE iodine_pubsub_publish(VALUE self, VALUE to, VALUE message) {
   iodine_pubsub_s *e = iodine_pubsub_CData(self);
-  if (e->engine == &e->do_not_touch) {
+  if (!e || e->engine == &e->do_not_touch) {
     /* this is a Ruby engine, nothing to do. */
     return Qnil;
   }
-  e->engine->publish(e->engine, IODINE_RSTRINFO(to), IODINE_RSTRINFO(message),
-                     0);
+  fio_publish(.engine = e->engine, .channel = IODINE_RSTRINFO(to),
+              .message = IODINE_RSTRINFO(message));
   return self;
 }
 

data/ext/iodine/iodine_store.c

@@ -111,7 +111,7 @@ static void storage_clear(void *ignore) {
 the data-type used to identify the registry
 this sets the callbacks.
 */
-static struct rb_data_type_struct storage_type_struct = {
+static const struct rb_data_type_struct storage_type_struct = {
     .wrap_struct_name = "RubyReferencesIn_C_Land",
     .function.dfree = (void (*)(void *))storage_clear,
     .function.dmark = (void (*)(void *))storage_mark,

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '0.7.4'.freeze
+  VERSION = '0.7.5'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iodine
 version: !ruby/object:Gem::Version
-  version: 0.7.4
+  version: 0.7.5
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-10-16 00:00:00.000000000 Z
+date: 2018-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -244,7 +244,7 @@ licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-post_install_message: 'Thank you for installing Iodine 0.7.4.
+post_install_message: 'Thank you for installing Iodine 0.7.5.
 
 '
 rdoc_options: []