iodine 0.3.4 → 0.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c4de811f5a2734382cc86765e77dcecf4b997fc6
-  data.tar.gz: 55422a643eab1c3cc0b3b18048521dc0aeac463b
+  metadata.gz: 84f989dded41a91d68df5799a63f428dec2dedd9
+  data.tar.gz: 7810e73f1f50a5ac9428419d8f17fa6d31aeb8b4
 SHA512:
-  metadata.gz: 59195e229155fc2ae56e240767a2707d6936758d4a3cfb999343856a753ffcd93ad2c82922a245f13ef95f32c968edaf49af504b64cc5b3152b6fa94bde4f1f5
-  data.tar.gz: a875bc77077fcfd0c1ca8d6d4d5fd6c9e53ff5759d578461f343af6ab226b3b26b1b5228765e4c156a37516338f802c1f3207040ac286e775d69b24758af92d2
+  metadata.gz: 607d4b9e6956149302d33e4f3b9a097a83ace382be08a7b55a80c86e4f57630c5dc0abcb7668ab69469a6aeb834f68606087d40f10ac5e3d8cc1f1714cd73e2b
+  data.tar.gz: 4651ef17299e34d1eb83d7fd673e57340b3ec060c3d0b633918ef6876644624072e02f9c930acec4c1a010a4a5ce4ead2a5aa106d134b9882bbe75a36b0a00d2

data/CHANGELOG.md

@@ -8,6 +8,14 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ***
 
+#### Change log v.0.3.5
+
+**Fix**: (`sock`) Fixed an issue with the `sendfile` implementation on macOS and BSD, where medium to large files wouldn't be sent correctly.
+
+**Minor changes**: This release incorporates some more minor changes from the [`facil.io` 0.4.2 update](https://github.com/boazsegev/facil.io/releases/tag/v.0.4.2).
+
+***
+
 #### Change log v.0.3.4
 
 **Fix**: (`sock`, `facil`, bscrypt) Add missing `static` keywords to prevent state collisions with other libraries.

data/bin/config.ru

@@ -83,6 +83,9 @@ end
 # ab -n 1000000 -c 2000 -k http://127.0.0.1:3000/
 # wrk -c400 -d5 -t12 http://localhost:3000/
 #
+# ab -n 1000000 -c 2000 -r http://127.0.0.1:3000/
+# wrk -c400 -d5 -t12 -H"Connection: close" http://localhost:3000/
+#
 # def cycle
 #   puts `wrk -c4000 -d5 -t12 http://localhost:3000/`
 #   sleep(2)

data/ext/iodine/facil.c

@@ -255,11 +255,19 @@ struct ListenerProtocol {
   protocol_s protocol;
   protocol_s *(*on_open)(intptr_t uuid, void *udata);
   void *udata;
+  void *rw_udata;
+  sock_rw_hook_s *(*set_rw_hooks)(intptr_t uuid, void *udata);
   void (*on_start)(void *udata);
   void (*on_finish)(void *udata);
   const char *port;
 };
 
+static sock_rw_hook_s *listener_set_rw_hooks(intptr_t uuid, void *udata) {
+  (void)udata;
+  (void)uuid;
+  return NULL; /* (sock_rw_hook_s *)&SOCK_DEFAULT_HOOKS; */
+}
+
 static void listener_ping(intptr_t uuid, protocol_s *plistener) {
   // fprintf(stderr, "*** Listener Ping Called for %ld\n", sock_uuid2fd(uuid));
   uuid_data(uuid).active = facil_data->last_cycle;
@@ -274,15 +282,22 @@ static void listener_deferred_on_open(void *uuid_, void *srv_uuid_) {
       (struct ListenerProtocol *)protocol_try_lock(sock_uuid2fd(srv_uuid),
                                                    FIO_PR_LOCK_WRITE);
   if (!listener) {
-    if (errno != EBADF)
+    if (sock_isvalid(uuid) && sock_isvalid(srv_uuid))
       defer(listener_deferred_on_open, uuid_, srv_uuid_);
+    else
+      sock_close(uuid);
     return;
   }
+  {
+    sock_rw_hook_s *hooks = listener->set_rw_hooks(uuid, listener->rw_udata);
+    if (hooks)
+      sock_rw_hook_set(uuid, hooks);
+  }
   protocol_s *pr = listener->on_open(uuid, listener->udata);
+  protocol_unlock((protocol_s *)listener, FIO_PR_LOCK_WRITE);
   facil_attach(uuid, pr);
   if (!pr)
     sock_close(uuid);
-  protocol_unlock((protocol_s *)listener, FIO_PR_LOCK_WRITE);
 }
 
 static void listener_on_data(intptr_t uuid, protocol_s *plistener) {
@@ -323,6 +338,8 @@ listener_alloc(struct facil_listen_args settings) {
     settings.on_start = (void (*)(void *))mock_on_close;
   if (!settings.on_finish)
     settings.on_finish = (void (*)(void *))mock_on_close;
+  if (!settings.set_rw_hooks)
+    settings.set_rw_hooks = listener_set_rw_hooks;
   struct ListenerProtocol *listener = malloc(sizeof(*listener));
   if (listener) {
     *listener = (struct ListenerProtocol){
@@ -334,6 +351,8 @@ listener_alloc(struct facil_listen_args settings) {
         .udata = settings.udata,
         .on_start = settings.on_start,
         .on_finish = settings.on_finish,
+        .set_rw_hooks = settings.set_rw_hooks,
+        .rw_udata = settings.rw_udata,
         .port = settings.port,
     };
     return listener;
@@ -391,21 +410,26 @@ struct ConnectProtocol {
   protocol_s protocol;
   protocol_s *(*on_connect)(intptr_t uuid, void *udata);
   void (*on_fail)(void *udata);
+  sock_rw_hook_s *(*set_rw_hooks)(intptr_t uuid, void *udata);
   void *udata;
+  void *rw_udata;
   int opened;
 };
 
 static void connector_on_ready(intptr_t uuid, protocol_s *_connector) {
   struct ConnectProtocol *connector = (void *)_connector;
-  connector->opened = 1;
   // fprintf(stderr, "connector_on_ready called\n");
-  if (connector->on_connect) {
-    sock_touch(uuid);
-    if (facil_attach(uuid, connector->on_connect(uuid, connector->udata)) == -1)
-      goto error;
-    uuid_data(uuid).protocol->on_ready(uuid, uuid_data(uuid).protocol);
-    return;
+  if (!connector->opened) {
+    sock_rw_hook_s *hooks = connector->set_rw_hooks(uuid, connector->rw_udata);
+    if (hooks)
+      sock_rw_hook_set(uuid, hooks);
   }
+  connector->opened = 1;
+  sock_touch(uuid);
+  if (facil_attach(uuid, connector->on_connect(uuid, connector->udata)) == -1)
+    goto error;
+  uuid_data(uuid).protocol->on_ready(uuid, uuid_data(uuid).protocol);
+  return;
 error:
   sock_close(uuid);
 }
@@ -426,6 +450,8 @@ static void connector_on_close(protocol_s *pconnector) {
 intptr_t facil_connect(struct facil_connect_args opt) {
   if (!opt.address || !opt.port || !opt.on_connect)
     return -1;
+  if (!opt.set_rw_hooks)
+    opt.set_rw_hooks = listener_set_rw_hooks;
   if (!facil_data->last_cycle)
     time(&facil_data->last_cycle);
   struct ConnectProtocol *connector = malloc(sizeof(*connector));
@@ -437,6 +463,8 @@ intptr_t facil_connect(struct facil_connect_args opt) {
       .protocol.on_data = connector_on_data,
       .protocol.on_ready = connector_on_ready,
       .protocol.on_close = connector_on_close,
+      .set_rw_hooks = opt.set_rw_hooks,
+      .rw_udata = opt.rw_udata,
       .opened = 0,
   };
   if (!connector)
@@ -656,6 +684,7 @@ static void facil_cleanup(void *arg) {
   facil_cycle(arg, NULL);
   ((struct facil_run_args *)arg)->on_finish();
   defer_perform();
+  evio_close();
 }
 
 #undef facil_run

data/ext/iodine/facil.h

@@ -15,7 +15,7 @@ extern "C" {
 #define H_FACIL_H
 #define FACIL_VERSION_MAJOR 0
 #define FACIL_VERSION_MINOR 4
-#define FACIL_VERSION_PATCH 1
+#define FACIL_VERSION_PATCH 2
 
 #ifndef FACIL_PRINT_STATE
 /**
@@ -154,8 +154,8 @@ int main() {
 struct facil_listen_args {
   /**
    * Called whenever a new connection is accepted.
-   * Should return a pointer to
-   * the connection's protocol. */
+   * Should return a pointer to the connection's protocol
+   */
   protocol_s *(*on_open)(intptr_t fduuid, void *udata);
   /** The network service / port. Defaults to "3000". */
   const char *port;
@@ -163,6 +163,16 @@ struct facil_listen_args {
   const char *address;
   /** Opaque user data. */
   void *udata;
+  /** Opaque user data for `set_rw_hooks`. */
+  void *rw_udata;
+  /** (optional)
+   * Called before `on_open`, allowing Read/Write hook initialization.
+   * Should return a pointer to the new RW hooks or NULL (to use default hooks).
+   *
+   * This allows a seperation between the transport layer (i.e. TLS) and the
+   * protocol (i.e. HTTP).
+   */
+  sock_rw_hook_s *(*set_rw_hooks)(intptr_t fduuid, void *rw_udata);
   /**
    * Called when the server starts, allowing for further initialization, such as
    * timed event scheduling.
@@ -210,6 +220,16 @@ struct facil_connect_args {
   void (*on_fail)(void *udata);
   /** Opaque user data. */
   void *udata;
+  /** Opaque user data for `set_rw_hooks`. */
+  void *rw_udata;
+  /** (optional)
+   * Called before `on_connect`, allowing Read/Write hook initialization.
+   * Should return a pointer to the new RW hooks or NULL (to use default hooks).
+   *
+   * This allows a seperation between the transport layer (i.e. TLS) and the
+   * protocol (i.e. HTTP).
+   */
+  sock_rw_hook_s *(*set_rw_hooks)(intptr_t fduuid, void *udata);
 };
 
 /**

data/ext/iodine/http.c

@@ -88,6 +88,8 @@ int http_listen(const char *port, const char *address,
   }
 
   return facil_listen(.port = port, .address = address,
+                      .set_rw_hooks = arg_settings.set_rw_hooks,
+                      .rw_udata = arg_settings.rw_udata,
                       .on_finish = http_on_finish, .on_open = on_open_callback,
                       .udata = settings);
 }

data/ext/iodine/http.h

@@ -74,6 +74,13 @@ typedef struct {
   The length of the public_folder string.
   */
   size_t public_folder_length;
+  /** (optional)
+   * Allows a an implementation for the transport layer (i.e. TLS) without
+   * effecting the HTTP protocol.
+   */
+  sock_rw_hook_s *(*set_rw_hooks)(intptr_t fduuid, void *rw_udata);
+  /** Opaque user data for `set_rw_hooks`. */
+  void *rw_udata;
   /**
   Logging flag - set to TRUE to log static file requests.
 

data/ext/iodine/sock.c

@@ -200,7 +200,7 @@ static ssize_t sock_default_hooks_flush(intptr_t uuid) {
   return (((void)(uuid)), 0);
 }
 
-static sock_rw_hook_s sock_default_hooks = {
+const sock_rw_hook_s SOCK_DEFAULT_HOOKS = {
     .read = sock_default_hooks_read,
     .write = sock_default_hooks_write,
     .flush = sock_default_hooks_flush,
@@ -271,10 +271,11 @@ static inline int initialize_sock_lib(size_t capacity) {
   if (new_collection) {
     sock_data_store.fds = new_collection;
     for (size_t i = sock_data_store.capacity; i < capacity; i++) {
-      fdinfo(i) = (struct fd_data_s){.open = 0,
-                                     .lock = SPN_LOCK_INIT,
-                                     .rw_hooks = &sock_default_hooks,
-                                     .counter = 0};
+      fdinfo(i) =
+          (struct fd_data_s){.open = 0,
+                             .lock = SPN_LOCK_INIT,
+                             .rw_hooks = (sock_rw_hook_s *)&SOCK_DEFAULT_HOOKS,
+                             .counter = 0};
     }
     sock_data_store.capacity = capacity;
 
@@ -313,7 +314,7 @@ clear:
   sock_data_store.fds[fd] =
       (struct fd_data_s){.open = is_open,
                          .lock = fdinfo(fd).lock,
-                         .rw_hooks = &sock_default_hooks,
+                         .rw_hooks = (sock_rw_hook_s *)&SOCK_DEFAULT_HOOKS,
                          .counter = fdinfo(fd).counter + 1};
   spn_unlock(&(fdinfo(fd).lock));
   packet = old_data.packet;
@@ -324,7 +325,7 @@ clear:
   }
   old_data.rw_hooks->on_close(((fd << 8) | old_data.counter),
                               old_data.rw_hooks);
-  if (old_data.open || (old_data.rw_hooks != &sock_default_hooks)) {
+  if (old_data.open || (old_data.rw_hooks != &SOCK_DEFAULT_HOOKS)) {
     sock_on_close((fd << 8) | old_data.counter);
     evio_remove((fd << 8) | old_data.counter);
   }
@@ -455,25 +456,57 @@ static int sock_sendfile_from_fd(int fd, struct packet_s *packet) {
 static int sock_sendfile_from_fd(int fd, struct packet_s *packet) {
   struct sock_packet_file_data_s *ext = (void *)packet->buffer.buf;
   off_t act_sent = 0;
-  ssize_t count = 0;
-  do {
-    fdinfo(fd).sent += act_sent;
-    packet->buffer.len -= act_sent;
+  ssize_t ret = 0;
+  while (packet->buffer.len) {
     act_sent = packet->buffer.len;
 #if defined(__APPLE__)
-    count = sendfile(ext->fd, fd, ext->offset + fdinfo(fd).sent, &act_sent,
-                     NULL, 0);
+    ret = sendfile(ext->fd, fd, ext->offset + fdinfo(fd).sent, &act_sent, NULL,
+                   0);
 #else
-    count = sendfile(ext->fd, fd, ext->offset + fdinfo(fd).sent,
-                     (size_t)act_sent, NULL, &act_sent, 0);
+    ret = sendfile(ext->fd, fd, ext->offset + fdinfo(fd).sent, (size_t)act_sent,
+                   NULL, &act_sent, 0);
 #endif
-  } while (count >= 0 && packet->buffer.len > (size_t)act_sent);
-  if (count < 0)
-    return -1;
+    if (ret < 0)
+      goto error;
+    fdinfo(fd).sent += act_sent;
+    packet->buffer.len -= act_sent;
+  }
   sock_packet_rotate_unsafe(fd);
   return act_sent;
+error:
+  if (errno == EAGAIN) {
+    fdinfo(fd).sent += act_sent;
+    packet->buffer.len -= act_sent;
+  }
+  return -1;
 }
 
+// static int sock_sendfile_from_fd(int fd, struct packet_s *packet) {
+//   struct sock_packet_file_data_s *ext = (void *)packet->buffer.buf;
+//   off_t act_sent = 0;
+//   ssize_t count = 0;
+//   do {
+//     fdinfo(fd).sent += act_sent;
+//     packet->buffer.len -= act_sent;
+//     act_sent = packet->buffer.len;
+// #if defined(__APPLE__)
+//     count = sendfile(ext->fd, fd, ext->offset + fdinfo(fd).sent, &act_sent,
+//                      NULL, 0);
+// #else
+//     count = sendfile(ext->fd, fd, ext->offset + fdinfo(fd).sent,
+//                      (size_t)act_sent, NULL, &act_sent, 0);
+// #endif
+//   } while (count >= 0 && packet->buffer.len > (size_t)act_sent);
+//   if (!act_sent) {
+//     fprintf(stderr, "Rotating after sent == %lu and length == %lu\n",
+//             (size_t)act_sent, packet->buffer.len);
+//     sock_packet_rotate_unsafe(fd);
+//   }
+//   if (count < 0)
+//     return -1;
+//   return act_sent;
+// }
+
 #else
 static int (*sock_sendfile_from_fd)(int fd, struct packet_s *packet) =
     sock_write_from_fd;
@@ -891,7 +924,7 @@ ssize_t sock_write2_fn(sock_write_info_s options) {
     ext->offset = options.offset;
     packet->metadata = (struct packet_metadata_s){
         .write_func =
-            (fdinfo(sock_uuid2fd(options.uuid)).rw_hooks == &sock_default_hooks
+            (fdinfo(sock_uuid2fd(options.uuid)).rw_hooks == &SOCK_DEFAULT_HOOKS
                  ? sock_sendfile_from_fd
                  : sock_write_from_fd),
         .free_func = options.move ? sock_close_from_fd
@@ -1046,7 +1079,8 @@ ssize_t sock_buffer_send(intptr_t uuid, sock_buffer_s *buffer) {
     return -1;
   }
   packet_s **tmp, *packet = (packet_s *)((uintptr_t)(buffer) -
-                                         sizeof(struct packet_metadata_s));
+                                         (uintptr_t)(&((packet_s *)0)->buffer));
+  // (packet_s *)((uintptr_t)(buffer) - sizeof(struct packet_metadata_s));
   packet->metadata = (struct packet_metadata_s){
       .write_func = sock_write_buffer,
       .free_func = (void (*)(packet_s *))SOCK_DEALLOC_NOOP};
@@ -1075,7 +1109,8 @@ Use `sock_buffer_free` to free unused buffers that were checked-out using
 */
 void sock_buffer_free(sock_buffer_s *buffer) {
   packet_s *packet =
-      (packet_s *)((uintptr_t)(buffer) - sizeof(struct packet_metadata_s));
+      (packet_s *)((uintptr_t)(buffer) - (uintptr_t)(&((packet_s *)0)->buffer));
+  // (packet_s *)((uintptr_t)(buffer) - sizeof(struct packet_metadata_s));
   sock_packet_free(packet);
 }
 
@@ -1089,7 +1124,7 @@ Experimental
 struct sock_rw_hook_s *sock_rw_hook_get(intptr_t uuid) {
   if (validate_uuid(uuid) || !fdinfo(sock_uuid2fd(uuid)).open ||
       ((uuid = sock_uuid2fd(uuid)),
-       fdinfo(uuid).rw_hooks == &sock_default_hooks))
+       fdinfo(uuid).rw_hooks == &SOCK_DEFAULT_HOOKS))
     return NULL;
   return fdinfo(uuid).rw_hooks;
 }
@@ -1107,7 +1142,7 @@ int sock_rw_hook_set(intptr_t uuid, sock_rw_hook_s *rw_hooks) {
   if (!rw_hooks->on_close)
     rw_hooks->on_close = sock_default_hooks_on_close;
   uuid = sock_uuid2fd(uuid);
-  lock_fd(sock_uuid2fd(uuid));
+  lock_fd(uuid);
   fdinfo(uuid).rw_hooks = rw_hooks;
   unlock_fd(uuid);
   return 0;

data/ext/iodine/sock.h

@@ -474,6 +474,9 @@ struct sock_rw_hook_s *sock_rw_hook_get(intptr_t fduuid);
 /** Sets a socket hook state (a pointer to the struct). */
 int sock_rw_hook_set(intptr_t fduuid, sock_rw_hook_s *rw_hooks);
 
+/** The default Read/Write hooks used for system Read/Write */
+extern const sock_rw_hook_s SOCK_DEFAULT_HOOKS;
+
 /* *****************************************************************************
 test
 */

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '0.3.4'.freeze
+  VERSION = '0.3.5'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iodine
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.3.5
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-05-29 00:00:00.000000000 Z
+date: 2017-06-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack