iodine 0.7.16 → 0.7.17

data/ext/iodine/iodine.h

@@ -3,6 +3,36 @@
 
 #include "ruby.h"
 
+#include "fio.h"
+#include "fio_tls.h"
+#include "fiobj.h"
+/* used for iodine_connect and iodine_listen routing */
+typedef struct {
+  fio_str_info_s address;
+  fio_str_info_s port;
+  fio_str_info_s method;
+  fio_str_info_s path;
+  fio_str_info_s body;
+  fio_str_info_s public;
+  fio_str_info_s url;
+  fio_tls_s *tls;
+  VALUE handler;
+  FIOBJ headers;
+  FIOBJ cookies;
+  size_t max_headers;
+  size_t max_body;
+  intptr_t max_clients;
+  size_t max_msg;
+  uint8_t timeout;
+  uint8_t ping;
+  uint8_t log;
+  enum {
+    IODINE_SERVICE_RAW,
+    IODINE_SERVICE_HTTP,
+    IODINE_SERVICE_WS,
+  } service;
+} iodine_connection_args_s;
+
 #include "iodine_caller.h"
 #include "iodine_connection.h"
 #include "iodine_defer.h"
@@ -14,12 +44,15 @@
 #include "iodine_rack_io.h"
 #include "iodine_store.h"
 #include "iodine_tcp.h"
+#include "iodine_tls.h"
 
 /* *****************************************************************************
 Constants
 ***************************************************************************** */
 extern VALUE IodineModule;
 extern VALUE IodineBaseModule;
+extern VALUE iodine_default_args;
+extern ID iodine_call_id;
 
 #define IODINE_RSTRINFO(rstr)                                                  \
   ((fio_str_info_s){.len = RSTRING_LEN(rstr), .data = RSTRING_PTR(rstr)})

data/ext/iodine/iodine_connection.c

@@ -51,14 +51,14 @@ Pub/Sub storage
 
 static inline VALUE iodine_sub_unsubscribe(fio_subhash_s *store,
                                            fio_str_info_s channel) {
-  if (fio_subhash_remove(store, fio_siphash(channel.data, channel.len), channel,
-                         NULL))
+  if (fio_subhash_remove(store, fiobj_hash_string(channel.data, channel.len),
+                         channel, NULL))
     return Qfalse;
   return Qtrue;
 }
 static inline void iodine_sub_add(fio_subhash_s *store, subscription_s *sub) {
   fio_str_info_s ch = fio_subscription_channel(sub);
-  fio_subhash_insert(store, fio_siphash(ch.data, ch.len), ch, sub, NULL);
+  fio_subhash_insert(store, fiobj_hash_string(ch.data, ch.len), ch, sub, NULL);
 }
 static inline void iodine_sub_clear_all(fio_subhash_s *store) {
   fio_subhash_free(store);
@@ -357,7 +357,7 @@ static VALUE iodine_connection_handler_set(VALUE self, VALUE handler) {
   }
   if (data->info.handler != handler) {
     uint8_t answers_on_open = (rb_respond_to(handler, on_open_id) != 0);
-    if(data->answers_on_close)
+    if (data->answers_on_close)
       IodineCaller.call2(data->info.handler, on_close_id, 1, &self);
     fio_lock(&data->lock);
     data->info.handler = handler;
@@ -395,8 +395,13 @@ static void iodine_on_pubsub(fio_msg_s *msg) {
   iodine_connection_data_s *data = msg->udata1;
   VALUE block = (VALUE)msg->udata2;
   switch (block) {
+  case 0:       /* fallthrough */
   case Qnil:    /* fallthrough */
   case Qtrue: { /* Qtrue == binary WebSocket */
+    if (!data) {
+      FIO_LOG_ERROR("Pub/Sub direct called with no connection data!");
+      return;
+    }
     if (data->info.handler == Qnil || data->info.uuid == -1 ||
         fio_is_closed(data->info.uuid))
       return;
@@ -423,7 +428,7 @@ static void iodine_on_pubsub(fio_msg_s *msg) {
     }
   }
   default:
-    if (data->info.uuid != -1) {
+    if (data && data->info.uuid != -1) {
       fio_protocol_s *pr =
           fio_protocol_try_lock(data->info.uuid, FIO_PR_LOCK_TASK);
       if (!pr) {
@@ -560,13 +565,10 @@ The second, optional, argument must be a Hash (if given).
 
 The options Hash supports the following possible keys (other keys are ignored, all keys are Symbols):
 
-:match :: The channel / subject name matching type to be used. Valid value is: `:redis`. Future versions hope to support `:nats` and `:rabbit` patern matching as well.
-
-:to :: The channel / subject to subscribe to.
-
-:as :: (only for WebSocket connections) accepts the optional value `:binary`. default is `:text`. Note that binary transmissions are illegal for some connections (such as SSE) and an attempted binary subscription will fail for these connections.
-
-:handler :: Any object that answers `#call(source, msg)` where source is the stream / channel name.
+- `:match` - The channel / subject name matching type to be used. Valid value is: `:redis`. Future versions hope to support `:nats` and `:rabbit` patern matching as well.
+- `:to` - The channel / subject to subscribe to.
+- `:as` - (only for WebSocket connections) accepts the optional value `:binary`. default is `:text`. Note that binary transmissions are illegal for some connections (such as SSE) and an attempted binary subscription will fail for these connections.
+- `:handler` - Any object that answers `.call(source, msg)` where source is the stream / channel name.
 
 Note: if an existing subscription with the same name exists, it will be replaced by this new subscription.
 
@@ -676,11 +678,9 @@ The method accepts an optional `engine` argument:
 
 Alternatively, accepts the following named arguments:
 
-:to :: The channel to publish to (required).
-
-:message :: The message to be published (required).
-
-:engine :: If provided, the engine to use for pub/sub. Otherwise the default engine is used.
+- `:to` - The channel to publish to (required).
+- `:message` - The message to be published (required).
+- `:engine` - If provided, the engine to use for pub/sub. Otherwise the default engine is used.
 
 */
 static VALUE iodine_pubsub_publish(int argc, VALUE *argv, VALUE self) {
@@ -771,7 +771,7 @@ VALUE iodine_connection_new(iodine_connection_s args) {
 void iodine_connection_fire_event(VALUE connection,
                                   iodine_connection_event_type_e ev,
                                   VALUE msg) {
-  if (connection == Qnil) {
+  if (!connection || connection == Qnil) {
     FIO_LOG_ERROR(
         "(iodine) nil connection handle used by an internal API call");
     return;
@@ -783,6 +783,11 @@ void iodine_connection_fire_event(VALUE connection,
                   (void *)connection);
     return;
   }
+  if (!data->info.handler || data->info.handler == Qnil) {
+    FIO_LOG_DEBUG("(iodine) invalid connection handler, can't fire event %d",
+                  (int)ev);
+    return;
+  }
   VALUE args[2] = {connection, msg};
   switch (ev) {
   case IODINE_CONNECTION_ON_OPEN:

data/ext/iodine/iodine_http.c

@@ -38,6 +38,13 @@ static VALUE RACK_UPGRADE_SSE;
 static VALUE RACK_UPGRADE_WEBSOCKET;
 static VALUE UPGRADE_TCP;
 
+static VALUE HTTP_ACCEPT;
+static VALUE HTTP_USER_AGENT;
+static VALUE HTTP_ACCEPT_ENCODING;
+static VALUE HTTP_ACCEPT_LANGUAGE;
+static VALUE HTTP_CONNECTION;
+static VALUE HTTP_HOST;
+
 static VALUE hijack_func_sym;
 static ID close_method_id;
 static ID each_method_id;
@@ -54,9 +61,6 @@ static rb_encoding *IodineBinaryEncoding;
 
 static uint8_t support_xsendfile = 0;
 
-/** Used by {listen2http} to set missing arguments. */
-VALUE iodine_default_args;
-
 #define rack_declare(rack_name) static VALUE rack_name
 
 #define rack_set(rack_name, str)                                               \
@@ -251,7 +255,20 @@ static int iodine_copy2env_task(FIOBJ o, void *env_) {
   FIOBJ name = fiobj_hash_key_in_loop();
   fio_str_info_s tmp = fiobj_obj2cstr(name);
   VALUE hname = (VALUE)0;
-  if (tmp.len > 59) {
+  /* test for common header names, using pre-allocated memory */
+  if (tmp.len == 6 && !memcmp("accept", tmp.data, 6)) {
+    hname = HTTP_ACCEPT;
+  } else if (tmp.len == 10 && !memcmp("user-agent", tmp.data, 10)) {
+    hname = HTTP_USER_AGENT;
+  } else if (tmp.len == 15 && !memcmp("accept-encoding", tmp.data, 15)) {
+    hname = HTTP_ACCEPT_ENCODING;
+  } else if (tmp.len == 15 && !memcmp("accept-language", tmp.data, 15)) {
+    hname = HTTP_ACCEPT_LANGUAGE;
+  } else if (tmp.len == 10 && !memcmp("connection", tmp.data, 10)) {
+    hname = HTTP_CONNECTION;
+  } else if (tmp.len == 4 && !memcmp("host", tmp.data, 4)) {
+    hname = HTTP_HOST;
+  } else if (tmp.len > 59) {
     char *buf = fio_malloc(tmp.len + 5);
     memcpy(buf, "HTTP_", 5);
     for (size_t i = 0; i < tmp.len; ++i) {
@@ -339,7 +356,7 @@ static inline VALUE copy2env(iodine_http_request_handle_s *handle) {
   /* handle the HOST header, including the possible host:#### format*/
   static uint64_t host_hash = 0;
   if (!host_hash)
-    host_hash = fio_siphash("host", 4);
+    host_hash = fiobj_hash_string("host", 4);
   tmp = fiobj_obj2cstr(fiobj_hash_get2(h->headers, host_hash));
   pos = tmp.data;
   while (*pos && *pos != ':')
@@ -362,7 +379,7 @@ static inline VALUE copy2env(iodine_http_request_handle_s *handle) {
   {
     static uint64_t content_length_hash = 0;
     if (!content_length_hash)
-      content_length_hash = fio_siphash("content-length", 14);
+      content_length_hash = fiobj_hash_string("content-length", 14);
     FIOBJ cl = fiobj_hash_get2(h->headers, content_length_hash);
     if (cl) {
       tmp = fiobj_obj2cstr(fiobj_hash_get2(h->headers, content_length_hash));
@@ -376,7 +393,7 @@ static inline VALUE copy2env(iodine_http_request_handle_s *handle) {
   {
     static uint64_t content_type_hash = 0;
     if (!content_type_hash)
-      content_type_hash = fio_siphash("content-type", 12);
+      content_type_hash = fiobj_hash_string("content-type", 12);
     FIOBJ ct = fiobj_hash_get2(h->headers, content_type_hash);
     if (ct) {
       tmp = fiobj_obj2cstr(ct);
@@ -393,10 +410,10 @@ static inline VALUE copy2env(iodine_http_request_handle_s *handle) {
     FIOBJ objtmp;
     static uint64_t xforward_hash = 0;
     if (!xforward_hash)
-      xforward_hash = fio_siphash("x-forwarded-proto", 27);
+      xforward_hash = fiobj_hash_string("x-forwarded-proto", 27);
     static uint64_t forward_hash = 0;
     if (!forward_hash)
-      forward_hash = fio_siphash("forwarded", 9);
+      forward_hash = fiobj_hash_string("forwarded", 9);
     if ((objtmp = fiobj_hash_get2(h->headers, xforward_hash))) {
       tmp = fiobj_obj2cstr(objtmp);
       if (tmp.len >= 5 && !strncasecmp(tmp.data, "https", 5)) {
@@ -432,11 +449,15 @@ static inline VALUE copy2env(iodine_http_request_handle_s *handle) {
           }
         }
       }
+    } else if (http_settings(h)->tls) {
+      /* no forwarding information, but we do have TLS */
+      rb_hash_aset(env, R_URL_SCHEME, HTTPS_SCHEME);
     } else {
+      /* no TLS, no forwarding, assume `http`, which is the default */
     }
   }
 
-  /* add all remianing headers */
+  /* add all remaining headers */
   fiobj_each1(h->headers, 0, iodine_copy2env_task, (void *)env);
   return env;
 }
@@ -776,213 +797,8 @@ static void on_rack_upgrade(http_s *h, char *proto, size_t len) {
 }
 
 /* *****************************************************************************
-Listenninng to HTTP
-*****************************************************************************
-*/
-
-static void free_iodine_http(http_settings_s *s) {
-  IodineStore.remove((VALUE)s->udata);
-}
-
-// clang-format off
-/**
-Listens to incoming HTTP connections and handles incoming requests using the
-Rack specification.
-
-This is delegated to a lower level C HTTP and Websocket implementation, no
-Ruby object will be crated except the `env` object required by the Rack
-specifications.
-
-Accepts a single Hash argument with the following properties:
-
-(it's possible to set default values using the {Iodine::DEFAULT_HTTP_ARGS} Hash)
-
-app:: the Rack application that handles incoming requests. Default: `nil`.
-port:: the port to listen to. Default: 3000.
-address:: the address to bind to. Default: binds to all possible addresses.
-log:: enable response logging (Hijacked sockets aren't logged). Default: off.
-public:: The root public folder for static file service. Default: none.
-timeout:: Timeout for inactive HTTP/1.x connections. Defaults: 40 seconds.
-max_body:: The maximum body size for incoming HTTP messages in bytes. Default: ~50Mib.
-max_headers:: The maximum total header length for incoming HTTP messages. Default: ~64Kib.
-max_msg:: The maximum Websocket message size allowed. Default: ~250Kib.
-ping:: The Websocket `ping` interval. Default: 40 seconds.
-
-Either the `app` or the `public` properties are required. If niether exists,
-the function will fail. If both exist, Iodine will serve static files as well
-as dynamic requests.
-
-When using the static file server, it's possible to serve `gzip` versions of
-the static files by saving a compressed version with the `gz` extension (i.e.
-`styles.css.gz`).
-
-`gzip` will only be served to clients tat support the `gzip` transfer
-encoding.
-
-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.
-*/
-static VALUE iodine_http_listen(VALUE self, VALUE opt) {
-  // clang-format on
-  uint8_t log_http = 0;
-  size_t ping = 0;
-  size_t max_body = 0;
-  size_t max_headers = 0;
-  size_t max_msg = 0;
-  Check_Type(opt, T_HASH);
-  /* copy from deafult hash */
-  /* test arguments */
-  VALUE app = rb_hash_aref(opt, ID2SYM(rb_intern("app")));
-  VALUE www = rb_hash_aref(opt, ID2SYM(rb_intern("public")));
-  VALUE port = rb_hash_aref(opt, ID2SYM(rb_intern("port")));
-  VALUE address = rb_hash_aref(opt, ID2SYM(rb_intern("address")));
-  VALUE tout = rb_hash_aref(opt, ID2SYM(rb_intern("timeout")));
-  if (www == Qnil) {
-    www = rb_hash_aref(iodine_default_args, ID2SYM(rb_intern("public")));
-  }
-  if (port == Qnil) {
-    port = rb_hash_aref(iodine_default_args, ID2SYM(rb_intern("port")));
-  }
-  if (address == Qnil) {
-    address = rb_hash_aref(iodine_default_args, ID2SYM(rb_intern("address")));
-  }
-  if (tout == Qnil) {
-    tout = rb_hash_aref(iodine_default_args, ID2SYM(rb_intern("timeout")));
-  }
-
-  VALUE tmp = rb_hash_aref(opt, ID2SYM(rb_intern("max_msg")));
-  if (tmp == Qnil) {
-    tmp = rb_hash_aref(iodine_default_args, ID2SYM(rb_intern("max_msg")));
-  }
-  if (tmp != Qnil && tmp != Qfalse) {
-    Check_Type(tmp, T_FIXNUM);
-    max_msg = FIX2ULONG(tmp);
-  }
-
-  tmp = rb_hash_aref(opt, ID2SYM(rb_intern("max_body")));
-  if (tmp == Qnil) {
-    tmp = rb_hash_aref(iodine_default_args, ID2SYM(rb_intern("max_body")));
-  }
-  if (tmp != Qnil && tmp != Qfalse) {
-    Check_Type(tmp, T_FIXNUM);
-    max_body = FIX2ULONG(tmp);
-  }
-  tmp = rb_hash_aref(opt, ID2SYM(rb_intern("max_headers")));
-  if (tmp == Qnil) {
-    tmp = rb_hash_aref(iodine_default_args, ID2SYM(rb_intern("max_headers")));
-  }
-  if (tmp != Qnil && tmp != Qfalse) {
-    Check_Type(tmp, T_FIXNUM);
-    max_headers = FIX2ULONG(tmp);
-  }
-
-  tmp = rb_hash_aref(opt, ID2SYM(rb_intern("ping")));
-  if (tmp == Qnil) {
-    tmp = rb_hash_aref(iodine_default_args, ID2SYM(rb_intern("ping")));
-  }
-  if (tmp != Qnil && tmp != Qfalse) {
-    Check_Type(tmp, T_FIXNUM);
-    ping = FIX2ULONG(tmp);
-  }
-  if (ping > 255) {
-    fprintf(stderr, "Iodine Warning: Websocket timeout value "
-                    "is over 255 and will be ignored.\n");
-    ping = 0;
-  }
-
-  tmp = rb_hash_aref(opt, ID2SYM(rb_intern("log")));
-  if (tmp == Qnil) {
-    tmp = rb_hash_aref(iodine_default_args, ID2SYM(rb_intern("log")));
-  }
-  if (tmp != Qnil && tmp != Qfalse)
-    log_http = 1;
-
-  if ((app == Qnil || app == Qfalse) && (www == Qnil || www == Qfalse)) {
-    fprintf(stderr, "Iodine Warning: HTTP without application or public folder "
-                    "(ignored).\n");
-    return Qfalse;
-  }
-
-  if ((www != Qnil && www != Qfalse)) {
-    Check_Type(www, T_STRING);
-    IodineStore.add(www);
-    rb_hash_aset(env_template_no_upgrade, XSENDFILE_TYPE, XSENDFILE);
-    rb_hash_aset(env_template_no_upgrade, XSENDFILE_TYPE_HEADER, XSENDFILE);
-    support_xsendfile = 1;
-  } else
-    www = 0;
-
-  if ((address != Qnil && address != Qfalse))
-    Check_Type(address, T_STRING);
-  else
-    address = 0;
-
-  if ((tout != Qnil && tout != Qfalse)) {
-    Check_Type(tout, T_FIXNUM);
-    tout = FIX2ULONG(tout);
-  } else
-    tout = 0;
-  if (tout > 255) {
-    fprintf(stderr, "Iodine Warning: HTTP timeout value "
-                    "is over 255 and is silently ignored.\n");
-    tout = 0;
-  }
-
-  if (port != Qnil && port != Qfalse) {
-    if (!RB_TYPE_P(port, T_STRING) && !RB_TYPE_P(port, T_FIXNUM))
-      rb_raise(rb_eTypeError,
-               "The `port` property MUST be either a String or a Number");
-    if (RB_TYPE_P(port, T_FIXNUM))
-      port = rb_funcall2(port, iodine_to_s_method_id, 0, NULL);
-    IodineStore.add(port);
-  } else if (port == Qfalse)
-    port = 0;
-  else if (address &&
-           (StringValueCStr(address)[0] > '9' ||
-            StringValueCStr(address)[0] < '0') &&
-           StringValueCStr(address)[0] != ':' &&
-           (RSTRING_LEN(address) < 3 || StringValueCStr(address)[2] != ':')) {
-    /* address is likely a Unix domain socket address, not an IP address... */
-    port = Qnil;
-  } else {
-    port = rb_str_new("3000", 4);
-    IodineStore.add(port);
-  }
-
-  if ((app != Qnil && app != Qfalse))
-    IodineStore.add(app);
-  else
-    app = 0;
-
-  if (http_listen((port ? StringValueCStr(port) : NULL),
-                  (address ? StringValueCStr(address) : NULL),
-                  .on_request = on_rack_request, .on_upgrade = on_rack_upgrade,
-                  .udata = (void *)app,
-                  .timeout = (tout ? FIX2INT(tout) : tout), .ws_timeout = ping,
-                  .ws_max_msg_size = max_msg, .max_header_size = max_headers,
-                  .on_finish = free_iodine_http, .log = log_http,
-                  .max_body_size = max_body,
-                  .public_folder = (www ? StringValueCStr(www) : NULL)) == -1) {
-    FIO_LOG_ERROR("Failed to initialize a listening HTTP socket for port %s",
-                  port ? StringValueCStr(port) : "3000");
-    rb_raise(rb_eRuntimeError, "Listening socket initialization failed");
-    return Qfalse;
-  }
-
-  if ((app == Qnil || app == Qfalse)) {
-    FIO_LOG_WARNING(
-        "(listen2http) no app, the HTTP service on port %s will only serve "
-        "static files.",
-        (port ? StringValueCStr(port) : "3000"));
-  }
-  if (www) {
-    FIO_LOG_INFO("Serving static files from %s", StringValueCStr(www));
-  }
-
-  return Qtrue;
-  (void)self;
-}
+Rack `env` Template Initialization
+***************************************************************************** */
 
 static void initialize_env_template(void) {
   if (env_template_no_upgrade)
@@ -1054,19 +870,209 @@ static void initialize_env_template(void) {
 }
 
 /* *****************************************************************************
-Initialization
+Listenninng to HTTP
+*****************************************************************************
+*/
+
+static void free_iodine_http(http_settings_s *s) {
+  IodineStore.remove((VALUE)s->udata);
+}
+
+// clang-format off
+/**
+Listens to incoming HTTP connections and handles incoming requests using the
+Rack specification.
+
+This is delegated to a lower level C HTTP and Websocket implementation, no
+Ruby object will be crated except the `env` object required by the Rack
+specifications.
+
+Accepts a single Hash argument with the following properties:
+
+(it's possible to set default values using the {Iodine::DEFAULT_HTTP_ARGS} Hash)
+
+app:: the Rack application that handles incoming requests. Default: `nil`.
+port:: the port to listen to. Default: 3000.
+address:: the address to bind to. Default: binds to all possible addresses.
+log:: enable response logging (Hijacked sockets aren't logged). Default: off.
+public:: The root public folder for static file service. Default: none.
+timeout:: Timeout for inactive HTTP/1.x connections. Defaults: 40 seconds.
+max_body:: The maximum body size for incoming HTTP messages in bytes. Default: ~50Mib.
+max_headers:: The maximum total header length for incoming HTTP messages. Default: ~64Kib.
+max_msg:: The maximum Websocket message size allowed. Default: ~250Kib.
+ping:: The Websocket `ping` interval. Default: 40 seconds.
+
+Either the `app` or the `public` properties are required. If niether exists,
+the function will fail. If both exist, Iodine will serve static files as well
+as dynamic requests.
+
+When using the static file server, it's possible to serve `gzip` versions of
+the static files by saving a compressed version with the `gz` extension (i.e.
+`styles.css.gz`).
+
+`gzip` will only be served to clients tat support the `gzip` transfer
+encoding.
+
+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.
+*/
+intptr_t iodine_http_listen(iodine_connection_args_s args){
+  // clang-format on
+  if (args.public.data) {
+    rb_hash_aset(env_template_no_upgrade, XSENDFILE_TYPE, XSENDFILE);
+    rb_hash_aset(env_template_no_upgrade, XSENDFILE_TYPE_HEADER, XSENDFILE);
+    support_xsendfile = 1;
+  }
+  IodineStore.add(args.handler);
+  intptr_t uuid = http_listen(
+      args.port.data, args.address.data, .on_request = on_rack_request,
+      .on_upgrade = on_rack_upgrade, .udata = (void *)args.handler,
+      .tls = args.tls, .timeout = args.timeout, .ws_timeout = args.ping,
+      .ws_max_msg_size = args.max_msg, .max_header_size = args.max_headers,
+      .on_finish = free_iodine_http, .log = args.log,
+      .max_body_size = args.max_body, .public_folder = args.public.data);
+  if (uuid == -1)
+    return uuid;
+
+  if ((args.handler == Qnil || args.handler == Qfalse)) {
+    FIO_LOG_WARNING("(listen) no handler / app, the HTTP service on port %s "
+                    "will only serve "
+                    "static files.",
+                    args.port.data ? args.port.data : args.address.data);
+  }
+  if (args.public.data) {
+    FIO_LOG_INFO("Serving static files from %s", args.public.data);
+  }
+
+  return uuid;
+}
+
+/* *****************************************************************************
+HTTP Websocket Connect
 ***************************************************************************** */
 
-void iodine_init_http(void) {
+typedef struct {
+  FIOBJ method;
+  FIOBJ headers;
+  FIOBJ cookies;
+  FIOBJ body;
+  VALUE io;
+} request_data_s;
+
+static request_data_s *request_data_create(iodine_connection_args_s *args) {
+  request_data_s *r = fio_malloc(sizeof(*r));
+  FIO_ASSERT_ALLOC(r);
+  VALUE io =
+      iodine_connection_new(.type = IODINE_CONNECTION_WEBSOCKET, .arg = NULL,
+                            .handler = args->handler, .env = Qnil, .uuid = 0);
+
+  *r = (request_data_s){
+      .method = fiobj_str_new(args->method.data, args->method.len),
+      .headers = fiobj_dup(args->headers),
+      .cookies = fiobj_dup(args->cookies),
+      .body = fiobj_str_new(args->body.data, args->body.len),
+      .io = io,
+  };
+  return r;
+}
+
+static void request_data_destroy(request_data_s *r) {
+  fiobj_free(r->method);
+  fiobj_free(r->body);
+  fiobj_free(r->headers);
+  fiobj_free(r->cookies);
+  fio_free(r);
+}
+
+static int each_header_ws_client_task(FIOBJ val, void *h_) {
+  http_s *h = h_;
+  FIOBJ key = fiobj_hash_key_in_loop();
+  http_set_header(h, key, fiobj_dup(val));
+  return 0;
+}
+static int each_cookie_ws_client_task(FIOBJ val, void *h_) {
+  http_s *h = h_;
+  FIOBJ key = fiobj_hash_key_in_loop();
+  fio_str_info_s n = fiobj_obj2cstr(key);
+  fio_str_info_s v = fiobj_obj2cstr(val);
+  http_set_cookie(h, .name = n.data, .name_len = n.len, .value = v.data,
+                  .value_len = v.len);
+  return 0;
+}
 
-  rb_define_module_function(IodineModule, "listen2http", iodine_http_listen, 1);
+static void ws_client_http_connected(http_s *h) {
+  request_data_s *s = h->udata;
+  if (!s)
+    return;
+  h->udata = http_settings(h)->udata = NULL;
+  if (!h->path) {
+    h->path = fiobj_str_new("/", 1);
+  }
+  /* TODO: add headers and cookies */
+  fiobj_each1(s->headers, 0, each_header_ws_client_task, h);
+  fiobj_each1(s->headers, 0, each_cookie_ws_client_task, h);
+  if (s->io && s->io != Qnil)
+    http_upgrade2ws(
+        h, .on_message = iodine_ws_on_message, .on_open = iodine_ws_on_open,
+        .on_ready = iodine_ws_on_ready, .on_shutdown = iodine_ws_on_shutdown,
+        .on_close = iodine_ws_on_close, .udata = (void *)s->io);
+  request_data_destroy(s);
+}
 
-  /** Used by {listen2http} to set missing arguments. */
-  iodine_default_args = rb_hash_new();
+static void ws_client_http_connection_finished(http_settings_s *settings) {
+  if (!settings)
+    return;
+  request_data_s *s = settings->udata;
+  if (s) {
+    if (s->io && s->io != Qnil)
+      iodine_connection_fire_event(s->io, IODINE_CONNECTION_ON_CLOSE, Qnil);
+    request_data_destroy(s);
+  }
+}
 
-  /** Used by {listen2http} to set missing arguments. */
-  rb_const_set(IodineModule, rb_intern2("DEFAULT_HTTP_ARGS", 17),
-               iodine_default_args);
+/** Connects to a (remote) WebSocket service. */
+intptr_t iodine_ws_connect(iodine_connection_args_s args) {
+  // http_connect(url, unixaddr, struct http_settings_s)
+  uint8_t is_unix_socket = 0;
+  if (memchr(args.address.data, '/', args.address.len)) {
+    is_unix_socket = 1;
+  }
+  FIOBJ url_tmp = FIOBJ_INVALID;
+  if (!args.url.data) {
+    url_tmp = fiobj_str_buf(64);
+    if (args.tls)
+      fiobj_str_write(url_tmp, "wss://", 6);
+    else
+      fiobj_str_write(url_tmp, "ws://", 5);
+    if (!is_unix_socket) {
+      fiobj_str_write(url_tmp, args.address.data, args.address.len);
+      if (args.port.data) {
+        fiobj_str_write(url_tmp, ":", 1);
+        fiobj_str_write(url_tmp, args.port.data, args.port.len);
+      }
+    }
+    if (args.path.data)
+      fiobj_str_write(url_tmp, args.path.data, args.path.len);
+    else
+      fiobj_str_write(url_tmp, "/", 1);
+    args.url = fiobj_obj2cstr(url_tmp);
+  }
+
+  intptr_t uuid = http_connect(
+      args.url.data, (is_unix_socket ? args.address.data : NULL),
+      .udata = request_data_create(&args),
+      .on_response = ws_client_http_connected,
+      .on_finish = ws_client_http_connection_finished, .tls = args.tls);
+  fiobj_free(url_tmp);
+  return uuid;
+}
+
+/* *****************************************************************************
+Initialization
+***************************************************************************** */
+
+void iodine_init_http(void) {
 
   rack_autoset(REQUEST_METHOD);
   rack_autoset(PATH_INFO);
@@ -1078,6 +1084,14 @@ void iodine_init_http(void) {
   rack_autoset(SERVER_PROTOCOL);
   rack_autoset(HTTP_VERSION);
   rack_autoset(REMOTE_ADDR);
+
+  rack_autoset(HTTP_ACCEPT);
+  rack_autoset(HTTP_USER_AGENT);
+  rack_autoset(HTTP_ACCEPT_ENCODING);
+  rack_autoset(HTTP_ACCEPT_LANGUAGE);
+  rack_autoset(HTTP_CONNECTION);
+  rack_autoset(HTTP_HOST);
+
   rack_set(HTTP_SCHEME, "http");
   rack_set(HTTPS_SCHEME, "https");
   rack_set(QUERY_ESTRING, "");