iodine 0.2.9 → 0.2.10

data/ext/iodine/mempool.h

@@ -1,5 +1,5 @@
 /*
-Copyright: Boaz segev, 2016-2017
+Copyright: Boaz Segev, 2016-2017
 License: MIT
 
 Feel free to copy, use and enjoy according to the license provided.
@@ -63,8 +63,8 @@ MEMPOOL_H
 #include <stdlib.h>
 #include <string.h>
 
-#ifndef __unused
-#define __unused __attribute__((unused))
+#ifndef UNUSED_FUNC
+#define UNUSED_FUNC __attribute__((unused))
 #endif
 
 /* *****************************************************************************
@@ -74,11 +74,11 @@ API Declerations
 ***************************************************************************** */
 
 /** Allocates memory from the pool. */
-static __unused void *mempool_malloc(size_t size);
+static UNUSED_FUNC void *mempool_malloc(size_t size);
 /**
  * Frees the memory, releasing it back to the pool (or, sometimes, the system).
  */
-static __unused void mempool_free(void *ptr);
+static UNUSED_FUNC void mempool_free(void *ptr);
 /**
  * Behaves the same a the systems `realloc`, attempting to resize the memory
  * when possible.
@@ -87,13 +87,13 @@ static __unused void mempool_free(void *ptr);
  * otherwise returns a new pointer (either equal to the old or after
  * deallocating the old one).
  */
-static __unused void *mempool_realloc(void *ptr, size_t new_size);
+static UNUSED_FUNC void *mempool_realloc(void *ptr, size_t new_size);
 
 #if defined(DEBUG) && DEBUG == 1
 /** Tests the memory pool, both testing against issues / corruption and testing
  * it's performance against the system's `malloc`.
  */
-static __unused void mempool_test(void);
+static UNUSED_FUNC void mempool_test(void);
 #endif
 
 /* *****************************************************************************
@@ -176,7 +176,7 @@ Memory Block Allocation / Deallocation
     target = mmap(NULL, size, PROT_READ | PROT_WRITE | PROT_EXEC,              \
                   MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);                         \
     if (target == MAP_FAILED)                                                  \
-      target == NULL;                                                          \
+      target = NULL;                                                           \
   } while (0);
 
 #define MEMPOOL_DEALLOC_SPECIAL(target, size) munmap((target), (size))
@@ -200,7 +200,7 @@ Helpers: Memory block slicing and memory pool list maintanence.
 API implementation
 */
 
-static __unused void *mempool_malloc(size_t size) {
+static UNUSED_FUNC void *mempool_malloc(size_t size) {
   if (!size)
     return NULL;
   if (size & 15) {
@@ -304,7 +304,7 @@ alloc_indi:
  * Frees the memory, releasing it back to the pool (or, sometimes, the
  * system).
  */
-static __unused void mempool_free(void *ptr) {
+static UNUSED_FUNC void mempool_free(void *ptr) {
   if (!ptr)
     return;
   mempool_reserved_slice_s **pos, *slice = MEMPOOL_PTR2SLICE(ptr), *tmp;
@@ -417,7 +417,7 @@ error:
  * and valid) otherwise returns a new pointer (either equal to the old or after
  * deallocating the old one).
  */
-static __unused void *mempool_realloc(void *ptr, size_t size) {
+static UNUSED_FUNC void *mempool_realloc(void *ptr, size_t size) {
   if (!size)
     return NULL;
   if (size & 15) {
@@ -531,6 +531,7 @@ TESTING
 #define MEMTEST_SLICE 32
 
 #include <time.h>
+#include <inttypes.h>
 static void mempool_stats(void) {
   fprintf(stderr, "* Pool object: %lu bytes\n"
                   "* Alignment: %lu \n"
@@ -713,12 +714,13 @@ static void mempool_speedtest(size_t memtest_repeats, void *(*mlk)(size_t),
           : (end_test.tv_nsec - start_test.tv_nsec);
   uint64_t sec_for_test = end_test.tv_sec - start_test.tv_sec;
 
-  fprintf(stderr, "Finished test in %llum, %llus %llu mili.sec.\n",
+  fprintf(stderr,
+          "Finished test in %" PRIu64 "m, %" PRIu64 "s %" PRIu64 " mili.sec.\n",
           sec_for_test / 60, sec_for_test - (((sec_for_test) / 60) * 60),
           msec_for_test / 1000000);
 }
 
-static __unused void mempool_test(void) {
+static UNUSED_FUNC void mempool_test(void) {
   fprintf(stderr, "*****************************\n");
   fprintf(stderr, "mempool implementation details:\n");
   mempool_stats();
@@ -799,7 +801,8 @@ static __unused void mempool_test(void) {
             : (end_test.tv_nsec - start_test.tv_nsec);
     uint64_t sec_for_test = end_test.tv_sec - start_test.tv_sec;
 
-    fprintf(stderr, " %llum, %llus %llu mili.sec. ( %lu CPU)\n",
+    fprintf(stderr,
+            " %" PRIu64 "m, %" PRIu64 "s %" PRIu64 " mili.sec. ( %lu CPU)\n",
             sec_for_test / 60, sec_for_test - (((sec_for_test) / 60) * 60),
             msec_for_test / 1000000, end - start);
 

data/ext/iodine/misc.c

@@ -52,7 +52,7 @@ fdump_s *bscrypt_fdump(const char *file_path, size_t size_limit) {
 
   if (stat(file_path, &f_data))
     goto error;
-  if (size_limit == 0 || f_data.st_size < size_limit)
+  if (size_limit == 0 || (size_t)f_data.st_size < size_limit)
     size_limit = f_data.st_size;
   container = malloc(size_limit + sizeof(fdump_s));
   if (!container)
@@ -61,7 +61,7 @@ fdump_s *bscrypt_fdump(const char *file_path, size_t size_limit) {
   file = open(file_path, O_RDONLY);
   if (file < 0)
     goto error;
-  if (read(file, container->data, size_limit) < size_limit)
+  if (read(file, container->data, size_limit) != (ssize_t)size_limit)
     goto error;
   close(file);
   return container;

data/ext/iodine/random.c

@@ -13,6 +13,21 @@ Feel free to copy, use and enjoy in accordance with to the license(s).
 #if defined(USE_ALT_RANDOM) || !defined(HAS_UNIX_FEATURES)
 #include "sha2.h"
 #include <time.h>
+
+#ifdef RUSAGE_SELF
+static size_t get_clock_mili(void) {
+  struct rusage rusage;
+  getrusage(RUSAGE_SELF, &rusage);
+  return ((rusage.ru_utime.tv_sec + rusage.ru_stime.tv_sec) * 1000000) +
+         (rusage.ru_utime.tv_usec + rusage.ru_stime.tv_usec);
+}
+#elif defined CLOCKS_PER_SEC
+#define get_clock_mili() (size_t) clock()
+#else
+#define get_clock_mili() 0
+#error Random alternative failed to find access to the CPU clock state.
+#endif
+
 uint32_t bscrypt_rand32(void) {
   bits256_u pseudo = bscrypt_rand256();
   return pseudo.ints[3];
@@ -32,14 +47,14 @@ bits128_u bscrypt_rand128(void) {
 }
 
 bits256_u bscrypt_rand256(void) {
-  clock_t cpu_state = clock();
+  size_t cpu_state = get_clock_mili();
   time_t the_time;
   time(&the_time);
   bits256_u pseudo;
   sha2_s sha2 = bscrypt_sha2_init(SHA_256);
   bscrypt_sha2_write(&sha2, &cpu_state, sizeof(cpu_state));
   bscrypt_sha2_write(&sha2, &the_time, sizeof(the_time));
-  bscrypt_sha2_write(&sha2, &cpu_state - 2, 64); /* whatever's on the stack */
+  bscrypt_sha2_write(&sha2, ((char *)&cpu_state) - 64, 64); /* the stack */
   bscrypt_sha2_result(&sha2);
   pseudo.words[0] = sha2.digest.i64[0];
   pseudo.words[1] = sha2.digest.i64[1];

data/ext/iodine/sha1.h

@@ -64,7 +64,7 @@ char *bscrypt_sha1_result(sha1_s *s);
 /**
 An SHA1 helper function that performs initialiation, writing and finalizing.
 */
-static inline __unused char *bscrypt_sha1(sha1_s *s, const void *data,
+static inline UNUSED_FUNC char *bscrypt_sha1(sha1_s *s, const void *data,
                                           size_t len) {
   *s = bscrypt_sha1_init();
   bscrypt_sha1_write(s, data, len);

data/ext/iodine/sha2.h

@@ -95,7 +95,7 @@ char *bscrypt_sha2_result(sha2_s *s);
 An SHA2 helper function that performs initialiation, writing and finalizing.
 Uses the SHA2 512 variant.
 */
-static inline __unused char *bscrypt_sha2_512(sha2_s *s, const void *data,
+static inline UNUSED_FUNC char *bscrypt_sha2_512(sha2_s *s, const void *data,
                                               size_t len) {
   *s = bscrypt_sha2_init(SHA_512);
   bscrypt_sha2_write(s, data, len);
@@ -106,7 +106,7 @@ static inline __unused char *bscrypt_sha2_512(sha2_s *s, const void *data,
 An SHA2 helper function that performs initialiation, writing and finalizing.
 Uses the SHA2 256 variant.
 */
-static inline __unused char *bscrypt_sha2_256(sha2_s *s, const void *data,
+static inline UNUSED_FUNC char *bscrypt_sha2_256(sha2_s *s, const void *data,
                                               size_t len) {
   *s = bscrypt_sha2_init(SHA_256);
   bscrypt_sha2_write(s, data, len);
@@ -117,7 +117,7 @@ static inline __unused char *bscrypt_sha2_256(sha2_s *s, const void *data,
 An SHA2 helper function that performs initialiation, writing and finalizing.
 Uses the SHA2 384 variant.
 */
-static inline __unused char *bscrypt_sha2_384(sha2_s *s, const void *data,
+static inline UNUSED_FUNC char *bscrypt_sha2_384(sha2_s *s, const void *data,
                                               size_t len) {
   *s = bscrypt_sha2_init(SHA_384);
   bscrypt_sha2_write(s, data, len);

data/ext/iodine/siphash.c

@@ -24,8 +24,8 @@ Feel free to copy, use and enjoy in accordance with to the license(s).
 #   endif
 #endif
 
-#ifndef __unused
-#   define __unused __attribute__((unused))
+#ifndef UNUSED_FUNC
+#   define UNUSED_FUNC __attribute__((unused))
 #endif
 // clang-format on
 

data/ext/iodine/spnlock.h

@@ -1,10 +1,10 @@
 /*
-Copyright: Boaz segev, 2016-2017
+Copyright: Boaz Segev, 2016-2017
 License: MIT
 
 Feel free to copy, use and enjoy according to the license provided.
 */
-#ifndef _SPN_LOCK_H
+#ifndef SIMPLE_SPN_LOCK_H
 /* *****************************************************************************
 A Simple busy lock implementation ... (spnlock.h)
 
@@ -13,11 +13,10 @@ karnel's code and the more readable Apple's kernel code)
 
 Written by Boaz Segev at 2016. Donated to the public domain for all to enjoy.
 */
-#define _SPN_LOCK_H
+#define SIMPLE_SPN_LOCK_H
 
-/* allow of the unused flag */
-#ifndef __unused
-#define __unused __attribute__((unused))
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
 #endif
 
 #include <stdint.h>
@@ -62,19 +61,17 @@ Written by Boaz Segev at 2016. Donated to the public domain for all to enjoy.
 typedef atomic_bool spn_lock_i;
 #define SPN_LOCK_INIT ATOMIC_VAR_INIT(0)
 /** returns 1 if the lock was busy (TRUE == FAIL). */
-__unused static inline int spn_trylock(spn_lock_i *lock) {
+static inline int spn_trylock(spn_lock_i *lock) {
   __asm__ volatile("" ::: "memory");
   return atomic_exchange(lock, 1);
 }
 /** Releases a lock. */
-__unused static inline void spn_unlock(spn_lock_i *lock) {
+static inline void spn_unlock(spn_lock_i *lock) {
   atomic_store(lock, 0);
   __asm__ volatile("" ::: "memory");
 }
 /** returns a lock's state (non 0 == Busy). */
-__unused static inline int spn_is_locked(spn_lock_i *lock) {
-  return atomic_load(lock);
-}
+static inline int spn_is_locked(spn_lock_i *lock) { return atomic_load(lock); }
 #endif
 #endif
 
@@ -91,9 +88,7 @@ __unused static inline int spn_is_locked(spn_lock_i *lock) {
 /* define the type */
 typedef volatile uint8_t spn_lock_i;
 /** returns 1 if the lock was busy (TRUE == FAIL). */
-__unused static inline int spn_trylock(spn_lock_i *lock) {
-  return __sync_swap(lock, 1);
-}
+static inline int spn_trylock(spn_lock_i *lock) { return __sync_swap(lock, 1); }
 #define SPN_TMP_HAS_BUILTIN 1
 #endif
 /* use gcc builtins if available - trust the compiler */
@@ -102,7 +97,7 @@ __unused static inline int spn_trylock(spn_lock_i *lock) {
 /* define the type */
 typedef volatile uint8_t spn_lock_i;
 /** returns 1 if the lock was busy (TRUE == FAIL). */
-__unused static inline int spn_trylock(spn_lock_i *lock) {
+static inline int spn_trylock(spn_lock_i *lock) {
   return __sync_fetch_and_or(lock, 1);
 }
 #define SPN_TMP_HAS_BUILTIN 1
@@ -119,7 +114,7 @@ __unused static inline int spn_trylock(spn_lock_i *lock) {
 /* define the type */
 typedef volatile uint8_t spn_lock_i;
 /** returns 1 if the lock was busy (TRUE == FAIL). */
-__unused static inline int spn_trylock(spn_lock_i *lock) {
+static inline int spn_trylock(spn_lock_i *lock) {
   spn_lock_i tmp;
   __asm__ volatile("xchgb %0,%1" : "=r"(tmp), "=m"(*lock) : "0"(1) : "memory");
   return tmp;
@@ -130,7 +125,7 @@ __unused static inline int spn_trylock(spn_lock_i *lock) {
 /* define the type */
 typedef volatile uint8_t spn_lock_i;
 /** returns TRUE (non-zero) if the lock was busy (TRUE == FAIL). */
-__unused static inline int spn_trylock(spn_lock_i *lock) {
+static inline int spn_trylock(spn_lock_i *lock) {
   spn_lock_i tmp;
   __asm__ volatile("ldstub    [%1], %0" : "=r"(tmp) : "r"(lock) : "memory");
   return tmp; /* return 0xFF if the lock was busy, 0 if free */
@@ -144,12 +139,12 @@ __unused static inline int spn_trylock(spn_lock_i *lock) {
 #define SPN_LOCK_INIT 0
 
 /** Releases a lock. */
-__unused static inline void spn_unlock(spn_lock_i *lock) {
+static inline void spn_unlock(spn_lock_i *lock) {
   __asm__ volatile("" ::: "memory");
   *lock = 0;
 }
 /** returns a lock's state (non 0 == Busy). */
-__unused static inline int spn_is_locked(spn_lock_i *lock) {
+static inline int spn_is_locked(spn_lock_i *lock) {
   __asm__ volatile("" ::: "memory");
   return *lock;
 }
@@ -157,7 +152,7 @@ __unused static inline int spn_is_locked(spn_lock_i *lock) {
 #endif /* has atomics */
 #include <stdio.h>
 /** Busy waits for the lock. */
-__unused static inline void spn_lock(spn_lock_i *lock) {
+static inline void spn_lock(spn_lock_i *lock) {
   while (spn_trylock(lock)) {
     reschedule_thread();
   }
@@ -168,17 +163,22 @@ spnlock.h finished
 */
 #endif
 
-#if DEBUG == 1 && !defined(_SPN_LOCK_TEST_REPEAT_COUNT)
+#if DEBUG == 1 && !defined(SPN_LOCK_TEST_REPEAT_COUNT)
+
+/* allow of the unused flag */
+#ifndef UNUSED_FUNC
+#define UNUSED_FUNC __attribute__((unused))
+#endif
 
-#define _SPN_LOCK_TEST_REPEAT_COUNT 10000UL
-#define _SPN_LOCK_TEST_THREAD_COUNT 10000UL
+#define SPN_LOCK_TEST_REPEAT_COUNT 10000UL
+#define SPN_LOCK_TEST_THREAD_COUNT 10000UL
 #include <pthread.h>
 #include <stdio.h>
 
-__unused static void *test_spn_lock_work(void *arg) {
+UNUSED_FUNC static void *test_spn_lock_work(void *arg) {
   static spn_lock_i lck = SPN_LOCK_INIT;
   uint64_t *ip = arg;
-  for (size_t i = 0; i < _SPN_LOCK_TEST_REPEAT_COUNT; i++) {
+  for (size_t i = 0; i < SPN_LOCK_TEST_REPEAT_COUNT; i++) {
     spn_lock(&lck);
     uint64_t j = *ip;
     j++;
@@ -189,9 +189,9 @@ __unused static void *test_spn_lock_work(void *arg) {
   return NULL;
 }
 
-__unused static void *test_spn_lock_lockless_work(void *arg) {
+UNUSED_FUNC static void *test_spn_lock_lockless_work(void *arg) {
   uint64_t *ip = arg;
-  for (size_t i = 0; i < _SPN_LOCK_TEST_REPEAT_COUNT; i++) {
+  for (size_t i = 0; i < SPN_LOCK_TEST_REPEAT_COUNT; i++) {
     uint64_t j = *ip;
     j++;
     __asm__ volatile("" ::: "memory", "cc");
@@ -200,16 +200,16 @@ __unused static void *test_spn_lock_lockless_work(void *arg) {
   return NULL;
 }
 
-__unused static void spn_lock_test(void) {
-  time_t start, end;
+UNUSED_FUNC static void spn_lock_test(void) {
+  size_t start, end;
   unsigned long num = 0;
-  pthread_t *threads = malloc(_SPN_LOCK_TEST_THREAD_COUNT * sizeof(*threads));
+  pthread_t *threads = malloc(SPN_LOCK_TEST_THREAD_COUNT * sizeof(*threads));
   void *tmp;
   start = clock();
-  for (size_t i = 0; i < _SPN_LOCK_TEST_THREAD_COUNT; i++) {
+  for (size_t i = 0; i < SPN_LOCK_TEST_THREAD_COUNT; i++) {
     pthread_create(threads + i, NULL, test_spn_lock_lockless_work, &num);
   }
-  for (size_t i = 0; i < _SPN_LOCK_TEST_THREAD_COUNT; i++) {
+  for (size_t i = 0; i < SPN_LOCK_TEST_THREAD_COUNT; i++) {
     pthread_join(threads[i], &tmp);
   }
   end = clock();
@@ -219,7 +219,7 @@ __unused static void spn_lock_test(void) {
   num = 0;
 
   start = clock();
-  for (size_t i = 0; i < _SPN_LOCK_TEST_THREAD_COUNT; i++) {
+  for (size_t i = 0; i < SPN_LOCK_TEST_THREAD_COUNT; i++) {
     if (pthread_create(threads + i, NULL, test_spn_lock_work, &num))
       fprintf(stderr,
               "Failed to create thread number %lu... test will fail to run as "
@@ -227,14 +227,14 @@ __unused static void spn_lock_test(void) {
               i);
     ;
   }
-  for (size_t i = 0; i < _SPN_LOCK_TEST_THREAD_COUNT; i++) {
+  for (size_t i = 0; i < SPN_LOCK_TEST_THREAD_COUNT; i++) {
     pthread_join(threads[i], &tmp);
   }
   end = clock();
   free(threads);
   fprintf(stderr, "Locked Num = %lu with %lu CPU cycles.\n", num, end - start);
   fprintf(stderr, "spn_lock test %s\n",
-          num == _SPN_LOCK_TEST_THREAD_COUNT * _SPN_LOCK_TEST_REPEAT_COUNT
+          num == SPN_LOCK_TEST_THREAD_COUNT * SPN_LOCK_TEST_REPEAT_COUNT
               ? "passed."
               : "FAILED!");
 }

data/lib/iodine/protocol.rb

@@ -28,6 +28,10 @@ module Iodine
   # Use {#defer} to run protocol related tasks (this locks the connection, preventing it from running more then one task at a time and offering thread safety),
   # or {#run} to run asynchronous tasks that aren't protocol related.
   #
+  # <b>Connection timeouts</b>
+  #
+  # By setting a class variable called `@timeout` it is possible to define a default timeout for new connections. However, changing this default timeout should be performed using the {#timeout} methods.
+  #
   # <b>The API:</b>
   #
   # After a new connection is accepted and a new protocol object is created, the protocol will be linked with Iodine's Protocol API.

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '0.2.9'.freeze
+  VERSION = '0.2.10'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iodine
 version: !ruby/object:Gem::Version
-  version: 0.2.9
+  version: 0.2.10
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-01-13 00:00:00.000000000 Z
+date: 2017-01-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -109,6 +109,7 @@ files:
 - bin/poc/gemfile
 - bin/poc/www/index.html
 - bin/raw-rbhttp
+- bin/raw-rbhttp-em
 - bin/raw_broadcast
 - bin/test_with_faye
 - bin/ws-broadcast