iodine 0.4.14 → 0.4.15

data/ext/iodine/fiobject.h

@@ -0,0 +1,276 @@
+#ifndef H_FIOBJECT_H
+/*
+Copyright: Boaz Segev, 2017
+License: MIT
+*/
+
+/**
+This facil.io core library provides wrappers around complex and (or) dynamic
+types, abstracting some complexity and making dynamic type related tasks easier.
+
+
+The library offers a rudementry protection against cyclic references using the
+`FIOBJ_NESTING_PROTECTION` flag (i.e., nesting an Array within itself)...
+however, this isn't fully tested and the performance price is high.
+*/
+#define H_FIOBJECT_H
+
+#include <stdarg.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* *****************************************************************************
+Core Types
+***************************************************************************** */
+
+/** The dynamic facil.io object type. */
+typedef struct { uintptr_t type; } fiobj_s;
+typedef fiobj_s *fiobj_pt;
+
+/** A string information type, reports anformation about a C string. */
+typedef struct {
+  union {
+    uint64_t len;
+    uint64_t length;
+  };
+  union {
+    void *buffer;
+    uint8_t *bytes;
+    char *data;
+    char *value;
+    char *name;
+  };
+} fio_cstr_s;
+
+/**
+ * Sets the default state for nesting protection.
+ *
+ * NOTICE: facil.io's default makefile will disables nesting protection.
+ *
+ * This effects traversing functions, such as `fiobj_each2`, `fiobj_dup`,
+ * `fiobj_free` etc'.
+ */
+#ifndef FIOBJ_NESTING_PROTECTION
+#define FIOBJ_NESTING_PROTECTION 0
+#endif
+
+/* *****************************************************************************
+Generic Object API
+***************************************************************************** */
+
+/** Returns a C string naming the objects dynamic type. */
+const char *fiobj_type_name(const fiobj_s *obj);
+
+/**
+ * Copy by reference(!) - increases an object's (and any nested object's)
+ * reference count.
+ *
+ * Always returns the value passed along.
+ *
+ * Future implementations might provide `fiobj_dup2` providing a deep copy.
+ *
+ * We don't need this feature just yet, so I'm not working on it.
+ */
+fiobj_s *fiobj_dup(fiobj_s *);
+
+/**
+ * Decreases an object's reference count, releasing memory and
+ * resources.
+ *
+ * This function affects nested objects, meaning that when an Array or
+ * a Hash object is passed along, it's children (nested objects) are
+ * also freed.
+ */
+void fiobj_free(fiobj_s *);
+
+/**
+ * Attempts to return the object's current reference count.
+ *
+ * This is mostly for testing rather than normal library operations.
+ */
+uintptr_t fiobj_reference_count(const fiobj_s *);
+
+/**
+ * Tests if an object evaluates as TRUE.
+ *
+ * This is object type specific. For example, empty strings might evaluate as
+ * FALSE, even though they aren't a boolean type.
+ */
+int fiobj_is_true(const fiobj_s *);
+
+/**
+ * Returns an Object's numerical value.
+ *
+ * If a String or Symbol are passed to the function, they will be
+ * parsed assuming base 10 numerical data.
+ *
+ * Hashes and Arrays return their object count.
+ *
+ * IO and File objects return their underlying file descriptor.
+ *
+ * A type error results in 0.
+ */
+int64_t fiobj_obj2num(const fiobj_s *obj);
+
+/**
+ * Returns a Float's value.
+ *
+ * If a String or Symbol are passed to the function, they will be
+ * parsed assuming base 10 numerical data.
+ *
+ * Hashes and Arrays return their object count.
+ *
+ * IO and File objects return their underlying file descriptor.
+ *
+ * A type error results in 0.
+ */
+double fiobj_obj2float(const fiobj_s *obj);
+
+/**
+ * Returns a C String (NUL terminated) using the `fio_cstr_s` data type.
+ *
+ * The Sting in binary safe and might contain NUL bytes in the middle as well as
+ * a terminating NUL.
+ *
+ * If a Symbol, a Number or a Float are passed to the function, they
+ * will be parsed as a *temporary*, thread-safe, String.
+ *
+ * Numbers will be represented in base 10 numerical data.
+ *
+ * A type error results in NULL (i.e. object isn't a String).
+ */
+fio_cstr_s fiobj_obj2cstr(const fiobj_s *obj);
+
+/**
+ * Single layer iteration using a callback for each nested fio object.
+ *
+ * Accepts any `fiobj_s *` type but only collections (Arrays and Hashes) are
+ * processed. The container itself (the Array or the Hash) is **not** processed
+ * (unlike `fiobj_each2`).
+ *
+ * The callback task function must accept an object and an opaque user pointer.
+ *
+ * Hash objects pass along a `FIOBJ_T_COUPLET` object, containing
+ * references for both the key (Symbol) and the object (any object).
+ *
+ * If the callback returns -1, the loop is broken. Any other value is ignored.
+ *
+ * Returns the "stop" position, i.e., the number of items processed + the
+ * starting point.
+ */
+size_t fiobj_each1(fiobj_s *, size_t start_at,
+                   int (*task)(fiobj_s *obj, void *arg), void *arg);
+
+/**
+ * Deep iteration using a callback for each fio object, including the parent.
+ *
+ * Accepts any `fiobj_s *` type.
+ *
+ * Collections (Arrays, Hashes) are deeply probed and shouldn't be edited
+ * during an `fiobj_each2` call (or weird things may happen).
+ *
+ * The callback task function must accept an object and an opaque user pointer.
+ *
+ * If `FIOBJ_NESTING_PROTECTION` is equal to 1 and a cyclic (or recursive)
+ * nesting is detected, a NULL pointer (not a NULL object) will be used instead
+ * of the original (cyclic) object and the original (cyclic) object will be
+ * available using the `fiobj_each_get_cyclic` function.
+ *
+ * Hash objects pass along a `FIOBJ_T_COUPLET` object, containing
+ * references for both the key (Symbol) and the object (any object).
+ *
+ * Notice that when passing collections to the function, the collection itself
+ * is sent to the callback followed by it's children (if any). This is true also
+ * for nested collections (a nested Hash will be sent first, followed by the
+ * nested Hash's children and then followed by the rest of it's siblings.
+ *
+ * If the callback returns -1, the loop is broken. Any other value is ignored.
+ */
+void fiobj_each2(fiobj_s *, int (*task)(fiobj_s *obj, void *arg), void *arg);
+
+/** Within `fiobj_each2`, this will return the current cyclic object, if any. */
+fiobj_s *fiobj_each_get_cyclic(void);
+
+/**
+ * Deeply compare two objects. No hashing or recursive functio n calls are
+ * involved.
+ *
+ * Uses a similar algorithm to `fiobj_each2`, except adjusted to two objects.
+ *
+ * Hash order will be tested when comapring Hashes.
+ *
+ * KNOWN ISSUES:
+ *
+ * * Cyclic nesting will cause this function to hang (much like `fiobj_each2`).
+ *
+ *   If `FIOBJ_NESTING_PROTECTION` is set, then cyclic nesting might produce
+ *   false positives.
+ *
+ * * Hash order will be tested as well as the Hash content, which means that
+ * equal Hashes might be considered unequal if their order doesn't match.
+ *
+ */
+int fiobj_iseq(const fiobj_s *obj1, const fiobj_s *obj2);
+
+/* *****************************************************************************
+Helpers: not fiobj_s specific, but since they're used internally, they're here.
+***************************************************************************** */
+
+/**
+ * A helper function that converts between String data to a signed int64_t.
+ *
+ * Numbers are assumed to be in base 10.
+ *
+ * The `0x##` (or `x##`) and `0b##` (or `b##`) are recognized as base 16 and
+ * base 2 (binary MSB first) respectively.
+ *
+ * The pointer will be updated to point to the first byte after the number.
+ */
+int64_t fio_atol(char **pstr);
+
+/** A helper function that convers between String data to a signed double. */
+double fio_atof(char **pstr);
+
+/**
+ * A helper function that convers between a signed int64_t to a string.
+ *
+ * No overflow guard is provided, make sure there's at least 66 bytes available
+ * (for base 2).
+ *
+ * Supports base 2, base 10 and base 16. An unsupported base will silently
+ * default to base 10. Prefixes aren't added (i.e., no "0x" or "0b" at the
+ * beginning of the string).
+ *
+ * Returns the number of bytes actually written (excluding the NUL terminator).
+ */
+size_t fio_ltoa(char *dest, int64_t num, uint8_t base);
+
+/**
+ * A helper function that convers between a double to a string.
+ *
+ * No overflow guard is provided, make sure there's at least 130 bytes available
+ * (for base 2).
+ *
+ * Supports base 2, base 10 and base 16. An unsupported base will silently
+ * default to base 10. Prefixes aren't added (i.e., no "0x" or "0b" at the
+ * beginning of the string).
+ *
+ * Returns the number of bytes actually written (excluding the NUL terminator).
+ */
+size_t fio_ftoa(char *dest, double num, uint8_t base);
+
+#ifdef DEBUG
+void fiobj_test(void);
+int fiobj_test_json_str(char const *json, size_t len, uint8_t print_result);
+#endif
+
+#ifdef __cplusplus
+} /* closing brace for extern "C" */
+#endif
+
+#endif

data/ext/iodine/pubsub.h

@@ -146,7 +146,7 @@ int pubsub_publish(struct pubsub_publish_args);
  *
  * This should only be called from within the `on_message` callback.
  *
- * It's recommended that the `on_message` callback return immediately followin
+ * It's recommended that the `on_message` callback return immediately following
  * this function call, as code might run concurrently.
  *
  * Uses reference counting for zero copy.

data/ext/iodine/resp.c

@@ -751,7 +751,7 @@ void resp_test(void) {
     resp_free_object(obj);
   } else
     fprintf(stderr, "* ERR / Simple String FAILED (type %d)\n",
-            obj ? obj->type : -1);
+            obj ? (int)obj->type : -1);
 
   len = sizeof(b_num) - 1;
   obj = resp_parser_feed(parser, b_num, &len);
@@ -820,7 +820,7 @@ void resp_test(void) {
     }
     resp_free_object(obj);
   } else {
-    fprintf(stderr, "* Array FAILED (type == %d)\n", obj ? obj->type : -1);
+    fprintf(stderr, "* Array FAILED (type == %d)\n", obj ? (int)obj->type : -1);
   }
   {
     // uint8_t buff[128] = {0};

data/ext/iodine/siphash.c

@@ -130,6 +130,8 @@ uint64_t siphash24(const void *data, size_t len, uint64_t iv_key[2]) {
 #if defined(DEBUG) && DEBUG == 1
 
 #include <stdio.h>
+#include <time.h>
+
 void bscrypt_test_siphash(void) {
   uint64_t result =
       siphash24("\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e",
@@ -137,6 +139,15 @@ void bscrypt_test_siphash(void) {
   fprintf(stderr, "===================================\n");
   fprintf(stderr, "SipHash simple test %s\n",
           (result == 0xa129ca6149be45e5ULL) ? "passed" : "FAILED");
+  clock_t start;
+  start = clock();
+  for (size_t i = 0; i < 100000; i++) {
+    __asm__ volatile("" ::: "memory");
+    result = siphash24("The quick brown fox jumps over the lazy dog ", 43,
+                       SIPHASH_DEFAULT_KEY);
+  }
+  fprintf(stderr, "bscrypt 100K SipHash: %lf\n",
+          (double)(clock() - start) / CLOCKS_PER_SEC);
   fprintf(stderr, "===================================\n");
 }
 

data/ext/iodine/spnlock.inc

@@ -38,20 +38,22 @@ spinlock / sync for tasks
 
 /** locks use a single byte */
 typedef volatile unsigned char spn_lock_i;
+
 /** The initail value of an unlocked spinlock. */
 #define SPN_LOCK_INIT 0
 
-/* Select the correct compiler builtin method. */
-#if defined(__has_builtin)
-
-#if __has_builtin(__atomic_exchange_n)
+/* C11 Atomics are defined? */
+#if defined(__ATOMIC_RELAXED)
 #define SPN_LOCK_BUILTIN(...) __atomic_exchange_n(__VA_ARGS__, __ATOMIC_ACQ_REL)
 /** An atomic addition operation */
 #define spn_add(...) __atomic_add_fetch(__VA_ARGS__, __ATOMIC_ACQ_REL)
 /** An atomic subtraction operation */
 #define spn_sub(...) __atomic_sub_fetch(__VA_ARGS__, __ATOMIC_ACQ_REL)
 
-#elif __has_builtin(__sync_fetch_and_or)
+/* Select the correct compiler builtin method. */
+#elif defined(__has_builtin)
+
+#if __has_builtin(__sync_fetch_and_or)
 #define SPN_LOCK_BUILTIN(...) __sync_fetch_and_or(__VA_ARGS__)
 /** An atomic addition operation */
 #define spn_add(...) __sync_add_and_fetch(__VA_ARGS__)

data/ext/iodine/websocket_parser.h

@@ -142,12 +142,47 @@ Message masking
 ***************************************************************************** */
 /** used internally to mask and unmask client messages. */
 void websocket_xmask(void *msg, uint64_t len, uint32_t mask) {
-  const uint64_t xmask = (((uint64_t)mask) << 32) | mask;
-  while (len >= 8) {
-    *((uint64_t *)msg) ^= xmask;
-    len -= 8;
-    msg = (void *)((uintptr_t)msg + 8);
+  if (len > 7) {
+    /* XOR any unaligned memory (4 byte alignment) */
+    const uintptr_t offset = 4 - ((uintptr_t)msg & 3);
+    switch (offset) {
+    case 3:
+      ((uint8_t *)msg)[2] ^= ((uint8_t *)(&mask))[2];
+    /* fallthrough */
+    case 2:
+      ((uint8_t *)msg)[1] ^= ((uint8_t *)(&mask))[1];
+    /* fallthrough */
+    case 1:
+      ((uint8_t *)msg)[0] ^= ((uint8_t *)(&mask))[0];
+      /* rotate mask and move pointer to first 4 byte alignment */
+      mask = (mask << (offset << 3)) | (mask >> ((4 - offset) << 3));
+      msg = (void *)((uintptr_t)msg + offset);
+      len -= offset;
+    }
+#if UINTPTR_MAX <= 0xFFFFFFFF
+    /* handle  4 byte XOR alignment in 32 bit mnachine*/
+    while (len >= 4) {
+      *((uint32_t *)msg) ^= mask;
+      len -= 4;
+      msg = (void *)((uintptr_t)msg + 4);
+    }
+#else
+    /* handle first 4 byte XOR alignment and move on to 64 bits */
+    if ((uintptr_t)msg & 7) {
+      *((uint32_t *)msg) ^= mask;
+      len -= 4;
+      msg = (void *)((uintptr_t)msg + 4);
+    }
+    /* intrinsic / XOR by 8 byte block, memory aligned */
+    const uint64_t xmask = (((uint64_t)mask) << 32) | mask;
+    while (len >= 8) {
+      *((uint64_t *)msg) ^= xmask;
+      len -= 8;
+      msg = (void *)((uintptr_t)msg + 8);
+    }
+#endif
   }
+  /* XOR any leftover bytes (might be non aligned)  */
   switch (len) {
   case 7:
     ((uint8_t *)msg)[6] ^= ((uint8_t *)(&mask))[2];
@@ -335,7 +370,8 @@ static uint64_t websocket_server_wrap(void *target, void *msg, uint64_t len,
  * * first:  set to 1 if `msg` points the begining of the message.
  * * last:   set to 1 if `msg + len` ends the message.
  *
- * Returns the number of bytes written. Always `websocket_wrapped_len(len) + 4`
+ * Returns the number of bytes written. Always `websocket_wrapped_len(len) +
+ * 4`
  */
 static uint64_t websocket_client_wrap(void *target, void *msg, uint64_t len,
                                       unsigned char opcode, unsigned char first,
@@ -390,7 +426,8 @@ static uint64_t websocket_client_wrap(void *target, void *msg, uint64_t len,
 
 /* *****************************************************************************
 Message unwrapping
-***************************************************************************** */
+*****************************************************************************
+*/
 
 /**
  * Returns all known information regarding the upcoming message.

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '0.4.14'.freeze
+  VERSION = '0.4.15'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iodine
 version: !ruby/object:Gem::Version
-  version: 0.4.14
+  version: 0.4.15
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-10-27 00:00:00.000000000 Z
+date: 2017-12-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -177,19 +177,24 @@ files:
 - ext/iodine/fio_hash_table.h
 - ext/iodine/fio_list.h
 - ext/iodine/fiobj.h
-- ext/iodine/fiobj_alloc.c
 - ext/iodine/fiobj_ary.c
-- ext/iodine/fiobj_generic.c
+- ext/iodine/fiobj_ary.h
 - ext/iodine/fiobj_hash.c
-- ext/iodine/fiobj_io.c
+- ext/iodine/fiobj_hash.h
+- ext/iodine/fiobj_internal.c
+- ext/iodine/fiobj_internal.h
 - ext/iodine/fiobj_json.c
-- ext/iodine/fiobj_misc.c
+- ext/iodine/fiobj_json.h
 - ext/iodine/fiobj_numbers.c
+- ext/iodine/fiobj_numbers.h
 - ext/iodine/fiobj_primitives.c
+- ext/iodine/fiobj_primitives.h
 - ext/iodine/fiobj_str.c
+- ext/iodine/fiobj_str.h
 - ext/iodine/fiobj_sym.c
-- ext/iodine/fiobj_tests.c
-- ext/iodine/fiobj_types.h
+- ext/iodine/fiobj_sym.h
+- ext/iodine/fiobject.c
+- ext/iodine/fiobject.h
 - ext/iodine/hex.c
 - ext/iodine/hex.h
 - ext/iodine/http.c