iodine 0.1.21 → 0.2.0

data/ext/iodine/websockets.h

@@ -0,0 +1,120 @@
+#ifndef WEBSOCKETS_H
+#define WEBSOCKETS_H
+
+#include "http_request.h"
+#include "http_response.h"
+
+/**
+The Websocket type is an opaque type used by the websocket API to provide
+identify a specific Websocket connection and manage it's internal state.
+*/
+typedef struct Websocket ws_s;
+
+/**
+The protocol / service identifier for `libserver`.
+*/
+extern char* WEBSOCKET_ID_STR;
+/**
+The Websocket Handler contains all the settings required for new websocket
+connections.
+
+This struct is used for the named agruments in the `websocket_upgrade`
+macro.
+*/
+typedef struct {
+  /**
+  The (optional) on_message callback will be called whenever a websocket message
+  is
+  received for this connection.
+
+  The data received points to the websocket's message buffer and it will be
+  overwritten once the function exits (it cannot be saved for later, but it can
+  be copied).
+  */
+  void (*on_message)(ws_s* ws, char* data, size_t size, uint8_t is_text);
+  /**
+  The (optional) on_open callback will be called once the websocket connection
+  is
+  established.
+  */
+  void (*on_open)(ws_s* ws);
+  /**
+  The (optional) on_shutdown callback will be called if a websocket connection
+  is still open while the server is shutting down (called before `on_close`).
+  */
+  void (*on_shutdown)(ws_s* ws);
+  /**
+  The (optional) on_close callback will be called once a websocket connection is
+  terminated or failed to be established.
+  */
+  void (*on_close)(ws_s* ws);
+  /** The `http_request_s` to be converted ("upgraded") to a websocket
+   * connection. Either a request or a response object is required.*/
+  http_request_s* request;
+  /**
+  The (optional) HttpResponse to be used for sending the upgrade response.
+
+  Using this object allows cookies to be set before "upgrading" the connection.
+
+  The ownership of the response object will remain unchanged - so if you have
+  created the response object, you should free it.
+  */
+  http_response_s* response;
+  /**
+  The maximum websocket message size/buffer (in bytes) for this connection.
+  */
+  size_t max_msg_size;
+  /** Opaque user data. */
+  void* udata;
+  /**
+  Timeout for the websocket connections, a ping will be sent
+  whenever the timeout is reached. Connections are only closed when a ping
+  cannot be sent (the network layer fails). Pongs aren't reviewed.
+  */
+  uint8_t timeout;
+} websocket_settings_s;
+
+/** This macro allows easy access to the `websocket_upgrade` function. The macro
+ * allows the use of named arguments, using the `websocket_settings_s` struct
+ * members. i.e.:
+ *
+ *     on_message(ws_s * ws, char * data, size_t size, int is_text) {
+ *        ; // ... this is the websocket on_message callback
+ *        websocket_write(ws, data, size, is_text); // a simple echo example
+ *     }
+ *
+ *     on_request(http_request_s* request) {
+ *        websocket_upgrade( .request = request, .on_message = on_message);
+ *     }
+ *
+ * Returns 0 on sucess and -1 on failure. A response is always sent.
+ */
+ssize_t websocket_upgrade(websocket_settings_s settings);
+#define websocket_upgrade(...) \
+  websocket_upgrade((websocket_settings_s){__VA_ARGS__})
+
+/** Returns the opaque user data associated with the websocket. */
+void* websocket_get_udata(ws_s* ws);
+/** Returns the the process specific connection's UUID (see `libsock`). */
+intptr_t websocket_get_fduuid(ws_s* ws);
+/** Sets the opaque user data associated with the websocket.
+ * Returns the old value, if any. */
+void* websocket_set_udata(ws_s* ws, void* udata);
+/** Writes data to the websocket. Returns -1 on failure (0 on success). */
+int websocket_write(ws_s* ws, void* data, size_t size, uint8_t is_text);
+/** Closes a websocket connection. */
+void websocket_close(ws_s* ws);
+/**
+Performs a task on each websocket connection that shares the same process
+(except the originating `ws_s` connection which is allowed to be NULL).
+ */
+void websocket_each(ws_s* ws_originator,
+                    void (*task)(ws_s* ws_target, void* arg),
+                    void* arg,
+                    void (*on_finish)(ws_s* ws_originator, void* arg));
+/**
+Counts the number of websocket connections.
+*/
+size_t websocket_count(ws_s* ws);
+
+#endif

data/ext/iodine/xor-crypt.c

@@ -0,0 +1,189 @@
+/*
+(un)copyright: Boaz segev, 2016
+License: Public Domain except for any non-public-domain algorithms, which are
+subject to their own licenses.
+
+Feel free to copy, use and enjoy in accordance with to the license(s).
+*/
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+#include "xor-crypt.h"
+/*****************************************************************************
+Useful Macros
+*/
+
+/** 32Bit left rotation, inlined. */
+#define left_rotate32(i, bits)                                                 \
+  (((uint32_t)(i) << (bits)) | ((uint32_t)(i) >> (32 - (bits))))
+/** 32Bit right rotation, inlined. */
+#define right_rotate32(i, bits)                                                \
+  (((uint32_t)(i) >> (bits)) | ((uint32_t)(i) << (32 - (bits))))
+/** 64Bit left rotation, inlined. */
+#define left_rotate64(i, bits)                                                 \
+  (((uint64_t)(i) << (bits)) | ((uint64_t)(i) >> (64 - (bits))))
+/** 64Bit right rotation, inlined. */
+#define right_rotate64(i, bits)                                                \
+  (((uint64_t)(i) >> (bits)) | ((uint64_t)(i) << (64 - (bits))))
+/** unknown size element - left rotation, inlined. */
+#define left_rotate(i, bits) (((i) << (bits)) | ((i) >> (sizeof((i)) - (bits))))
+/** unknown size element - right rotation, inlined. */
+#define right_rotate(i, bits)                                                  \
+  (((i) >> (bits)) | ((i) << (sizeof((i)) - (bits))))
+/** inplace byte swap 16 bit integer */
+#define bswap16(i)                                                             \
+  do {                                                                         \
+    (i) = (((i)&0xFFU) << 8) | (((i)&0xFF00U) >> 8);                           \
+  } while (0);
+/** inplace byte swap 32 bit integer */
+#define bswap32(i)                                                             \
+  do {                                                                         \
+    (i) = (((i)&0xFFUL) << 24) | (((i)&0xFF00UL) << 8) |                       \
+          (((i)&0xFF0000UL) >> 8) | (((i)&0xFF000000UL) >> 24);                \
+  } while (0);
+/** inplace byte swap 64 bit integer */
+#define bswap64(i)                                                             \
+  do {                                                                         \
+    (i) = (((i)&0xFFULL) << 56) | (((i)&0xFF00ULL) << 40) |                    \
+          (((i)&0xFF0000ULL) << 24) | (((i)&0xFF000000ULL) << 8) |             \
+          (((i)&0xFF00000000ULL) >> 8) | (((i)&0xFF0000000000ULL) >> 24) |     \
+          (((i)&0xFF000000000000ULL) >> 40) |                                  \
+          (((i)&0xFF00000000000000ULL) >> 56);                                 \
+  } while (0);
+
+#ifdef HAVE_X86Intrin
+#undef bswap64
+#define bswap64(i)                                                             \
+  { __asm__("bswapq %0" : "+r"(i) :); }
+
+// shadow sched_yield as _mm_pause for spinwait
+#define sched_yield() _mm_pause()
+#endif
+
+/* ***************************************************************************
+XOR encryption
+*/
+
+/**
+Uses an XOR key `xor_key_s` to encrypt / decrypt the data provided.
+
+Encryption/decryption can be destructive (the target and the source can point
+to the same object).
+
+The key's `on_cycle` callback option should be utilized to er-calculate the
+key every cycle. Otherwise, XOR encryption should be avoided.
+
+A more secure encryption would be easier to implement using seperate
+`xor_key_s` objects for encryption and decription.
+
+If `target` is NULL, the source will be used as the target (destructive mode).
+
+Returns -1 on error and 0 on success.
+*/
+int bscrypt_xor_crypt(xor_key_s *key, void *target, const void *source,
+                      size_t length) {
+  if (!source || !key)
+    return -1;
+  if (!length)
+    return 0;
+  if (!target)
+    target = (void *)source;
+  if (key->on_cycle) {
+    /* loop to provide vector initialization when needed. */
+    while (key->position >= key->length) {
+      if (key->on_cycle(key))
+        return -1;
+      key->position -= key->length;
+    }
+  } else if (key->position >= key->length)
+    key->position = 0; /* no callback? no need for vector alterations. */
+  size_t i = 0;
+
+  /* start decryption */
+  while (length > i) {
+    while ((key->length - key->position >= 8) // we have 8 bytes for key.
+           && ((i + 8) <= length)             // we have 8 bytes for stream.
+           && (((uintptr_t)(target + i)) & 7) == 0 // target memory is aligned.
+           && (((uintptr_t)(source + i)) & 7) == 0 // source memory is aligned.
+           && ((uintptr_t)(key->key + key->position) & 7) == 0 // key aligned.
+           ) {
+      // fprintf(stderr, "XOR optimization used i= %lu, key pos = %lu.\n", i,
+      //         key->position);
+      *((uint64_t *)(target + i)) = *((uint64_t *)(source + i)) ^
+                                    *((uint64_t *)(key->key + key->position));
+      key->position += 8;
+      i += 8;
+      if (key->position < key->length)
+        continue;
+      if (key->on_cycle && key->on_cycle(key))
+        return -1;
+      key->position = 0;
+    }
+
+    if (i < length) {
+      // fprintf(stderr, "XOR single byte.\n");
+      *((uint8_t *)(target + i)) =
+          *((uint8_t *)(source + i)) ^ *((uint8_t *)(key->key + key->position));
+      ++i;
+      ++key->position;
+      if (key->position == key->length) {
+        if (key->on_cycle && key->on_cycle(key))
+          return -1;
+        key->position = 0;
+      }
+    }
+  }
+  return 0;
+}
+
+/**
+Similar to the bscrypt_xor_crypt except with a fixed key size of 128bits.
+*/
+int bscrypt_xor128_crypt(uint64_t *key, void *target, const void *source,
+                         size_t length, int (*on_cycle)(uint64_t *key)) {
+  length = length & 31;
+  uint8_t pos = 0;
+  for (size_t i = 0; i < (length >> 3); i++) {
+    ((uint64_t *)target)[0] = ((uint64_t *)source)[0] ^ key[pos++];
+    target += 8;
+    source += 8;
+    if (pos < 2)
+      continue;
+    if (on_cycle && on_cycle(key))
+      return -1;
+    pos = 0;
+  }
+  length = length & 7;
+  for (size_t i = 0; i < length; i++) {
+    ((uint64_t *)target)[i] = ((uint64_t *)source)[i] ^ key[pos];
+  }
+  return 0;
+}
+/**
+Similar to the bscrypt_xor_crypt except with a fixed key size of 256bits.
+*/
+int bscrypt_xor256_crypt(uint64_t *key, void *target, const void *source,
+                         size_t length, int (*on_cycle)(uint64_t *key)) {
+  for (size_t i = 0; i < (length >> 5); i++) {
+    ((uint64_t *)target)[0] = ((uint64_t *)source)[0] ^ key[0];
+    ((uint64_t *)target)[1] = ((uint64_t *)source)[1] ^ key[1];
+    ((uint64_t *)target)[2] = ((uint64_t *)source)[2] ^ key[2];
+    ((uint64_t *)target)[3] = ((uint64_t *)source)[3] ^ key[3];
+    target += 32;
+    source += 32;
+    if (on_cycle && on_cycle(key))
+      return -1;
+  }
+  length = length & 31;
+  uint8_t pos = 0;
+  for (size_t i = 0; i < (length >> 3); i++) {
+    ((uint64_t *)target)[0] = ((uint64_t *)source)[0] ^ key[pos++];
+    target += 8;
+    source += 8;
+  }
+  length = length & 7;
+  for (size_t i = 0; i < length; i++) {
+    ((uint64_t *)target)[i] = ((uint64_t *)source)[i] ^ key[pos];
+  }
+  return 0;
+}

data/ext/iodine/xor-crypt.h

@@ -0,0 +1,107 @@
+/*
+(un)copyright: Boaz segev, 2016
+License: Public Domain except for any non-public-domain algorithms, which are
+subject to their own licenses.
+
+Feel free to copy, use and enjoy in accordance with to the license(s).
+*/
+#ifndef bscrypt_XOR_CRYPT_H
+#define bscrypt_XOR_CRYPT_H
+#include "bscrypt-common.h"
+/* *****************************************************************************
+C++ extern
+*/
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+/* ***************************************************************************
+XOR encryption
+*/
+
+typedef struct xor_key_s xor_key_s;
+/**
+The `xor_key_s` type is a struct containing XOR key data. This will be used for
+all the encryption/decription functions that use XOR key data, such as the
+`bscrypt_xor_crypt` function.
+*/
+struct xor_key_s {
+  /** A pointer to a string containing the key. */
+  uint8_t *key;
+  /** The length of the key string */
+  size_t length;
+  /**
+  The vector / position from which to start the next encryption/decryption.
+
+  This value is automatically advanced when encrypting / decrypting data.
+  */
+  size_t position;
+  /**
+  An optional callback to be called whenever the XOR key finished a cycle and
+  the `position` is being reset to 0.
+
+  The function should return 0 on sucess and -1 on failure. Failue will cause
+  endryption/decryption to fail.
+  */
+  int (*on_cycle)(xor_key_s *key);
+};
+
+typedef struct xor_key_128bit_s xor_key_128bit_s;
+/**
+The `xor_key_128bit_s` type is a struct containing an XOR key data. This will be
+used
+for
+all the encryption/decription functions that use XOR key data, such as the
+`bscrypt.xor_crypt` function.
+*/
+struct xor_key_128bit_s {
+  /** A pointer to a string containing the key. */
+  uint64_t key[2];
+  /**
+  An optional callback to be called whenever the XOR key finished a cycle and
+  the `position` is being reset to 0.
+
+  The function should return 0 on sucess and -1 on failure. Failue will cause
+  endryption/decryption to fail.
+  */
+  int (*on_cycle)(xor_key_128bit_s *key);
+};
+
+/**
+Uses an XOR key `xor_key_s` to encrypt / decrypt the data provided.
+
+Encryption/decryption can be destructive (the target and the source can point
+to the same object).
+
+The key's `on_cycle` callback option should be utilized to re-calculate the
+key every cycle. Otherwise, XOR encryption should be avoided.
+
+A more secure encryption would be easier to implement using seperate
+`xor_key_s` objects for encryption and decription.
+
+If `target` is NULL, the source will be used as the target (destructive mode).
+
+Returns -1 on error and 0 on success.
+*/
+int bscrypt_xor_crypt(xor_key_s *key, void *target, const void *source,
+                      size_t length);
+
+/**
+Similar to the bscrypt_xor_crypt except with a fixed key size of 128bits.
+*/
+int bscrypt_xor128_crypt(uint64_t *key, void *target, const void *source,
+                         size_t length, int (*on_cycle)(uint64_t *key));
+/**
+Similar to the bscrypt_xor_crypt except with a fixed key size of 256bits.
+*/
+int bscrypt_xor256_crypt(uint64_t *key, void *target, const void *source,
+                         size_t length, int (*on_cycle)(uint64_t *key));
+
+/* *****************************************************************************
+C++ extern finish
+*/
+#if defined(__cplusplus)
+}
+#endif
+
+#endif

data/iodine.gemspec

@@ -4,38 +4,45 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'iodine/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "iodine"
+  spec.name          = 'iodine'
   spec.version       = Iodine::VERSION
-  spec.authors       = ["Boaz Segev"]
-  spec.email         = ["Boaz@2be.co.il"]
+  spec.authors       = ['Boaz Segev']
+  spec.email         = ['Boaz@2be.co.il']
 
-  spec.summary       = %q{ The Iodine v.0.1.X line and API is deprecated and will not be supported after v. 0.2.0 is released. }
-  spec.description   = %q{ The Iodine v.0.1.X line and API is deprecated and will not be supported after v. 0.2.0 is released. }
-  spec.homepage      = "https://github.com/boazsegev/iodine"
-  spec.license       = "MIT"
+  spec.summary       = ' Iodine - writing C servers in Ruby.'
+  spec.description   = ' Iodine - writing C servers in Ruby.'
+  spec.homepage      = 'https://github.com/boazsegev/iodine'
+  spec.license       = 'MIT'
 
   # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
   # delete this section to allow pushing this gem to any host.
   if spec.respond_to?(:metadata)
-    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+    spec.metadata['allowed_push_host'] = 'https://rubygems.org'
   else
-    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+    raise 'RubyGems 2.0 or newer is required to protect against public gem pushes.'
   end
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.bindir        = "exe"
+  spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  spec.require_paths = %w(lib ext)
 
-  spec.add_development_dependency "bundler", "~> 1.10"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "minitest"
+  spec.extensions = %w(ext/iodine/extconf.rb)
 
+  spec.required_ruby_version = '>= 2.2.2' # for Rack
 
+  spec.add_dependency 'rack'
+  spec.add_dependency 'rake-compiler'
 
-  spec.post_install_message = "The Iodine 0.1.x API is now deprecated.\n"+
-                              "Version 0.2.x will include a drastic change and it WILL break existing code.\n" +
-                              "DON'T UPGRADE BEYOND THIS POINT UNLESS YOU'RE PREPARED FOR A HUGE CANGE.\n" +
-                              "Future version of Iodine will be written in C and require a Linux/Unix machine."
+  spec.requirements << 'A Unix based system, i.e.: Linux / OS X / BSD.'
+  spec.requirements << 'An updated C compiler, with support for C11 (i.e. gcc 4.9 or later).'
+  spec.requirements << 'Ruby >= 2.2.2'
 
+  spec.add_development_dependency 'bundler', '~> 1.10'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'minitest'
+
+  spec.post_install_message = "** WARNING!\n" \
+                              "Iodine 0.2.0 is NOT an upgrade - it's a total rewrite, it's written in C specifically for Ruby MRI.\n\n" \
+                              'If your application was using Iodine 0.1.x, it might not work after this "upgrade".'
 end