iodine 0.6.5 → 0.7.0

data/ext/iodine/redis_engine.h

@@ -7,8 +7,8 @@ Feel free to copy, use and enjoy according to the license provided.
 #ifndef H_REDIS_ENGINE_H
 #define H_REDIS_ENGINE_H
 
-#include "fiobj.h"
-#include "pubsub.h"
+#include <fio.h>
+#include <fiobj.h>
 
 /* support C++ */
 #ifdef __cplusplus
@@ -17,20 +17,18 @@ extern "C" {
 
 /** possible arguments for the `redis_engine_create` function call */
 struct redis_engine_create_args {
-  /** Redis server's address */
-  const char *address;
-  /** Redis server's port */
-  const char *port;
-  /** Redis server's password, if any */
-  const char *auth;
-  /** Redis server's password length (if any). */
-  size_t auth_len;
+  /** Redis server's address, defaults to localhost. */
+  fio_str_info_s address;
+  /** Redis server's port, defaults to 6379. */
+  fio_str_info_s port;
+  /** Redis server's password, if any. */
+  fio_str_info_s auth;
   /** A `ping` will be sent every `ping_interval` interval or inactivity. */
   uint8_t ping_interval;
 };
 
 /**
- * See the {pubsub.h} file for documentation about engines.
+ * See the {fio.h} file for documentation about engines.
  *
  * The engine is active only after facil.io starts running.
  *
@@ -44,7 +42,7 @@ struct redis_engine_create_args {
  * callbacks have been called (or facil.io exits)... If the engine is destroyed
  * midway, memory leaks might occur (and little puppies might cry).
  */
-pubsub_engine_s *redis_engine_create(struct redis_engine_create_args);
+fio_pubsub_engine_s *redis_engine_create(struct redis_engine_create_args);
 #define redis_engine_create(...)                                               \
   redis_engine_create((struct redis_engine_create_args){__VA_ARGS__})
 
@@ -61,8 +59,8 @@ pubsub_engine_s *redis_engine_create(struct redis_engine_create_args);
  * Redis connection's protocol (best case scenario, a disconnection will occur
  * before and messages are lost).
  */
-intptr_t redis_engine_send(pubsub_engine_s *engine, FIOBJ command, FIOBJ data,
-                           void (*callback)(pubsub_engine_s *e, FIOBJ reply,
+intptr_t redis_engine_send(fio_pubsub_engine_s *engine, FIOBJ command,
+                           void (*callback)(fio_pubsub_engine_s *e, FIOBJ reply,
                                             void *udata),
                            void *udata);
 
@@ -71,7 +69,7 @@ intptr_t redis_engine_send(pubsub_engine_s *engine, FIOBJ command, FIOBJ data,
  *
  * function names speak for themselves ;-)
  */
-void redis_engine_destroy(pubsub_engine_s *engine);
+void redis_engine_destroy(fio_pubsub_engine_s *engine);
 
 /* support C++ */
 #ifdef __cplusplus

data/ext/iodine/resp_parser.h

@@ -19,6 +19,10 @@ Feel free to copy, use and enjoy according to the license provided.
  */
 #define H_RESP_PARSER_H
 
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
@@ -177,6 +181,8 @@ Parsing RESP requests
  */
 static size_t resp_parse(resp_parser_s *parser, const void *buffer,
                          size_t length) {
+  if (!parser->obj_countdown)
+    parser->obj_countdown = 1; /* always expect something... */
   uint8_t *pos = (uint8_t *)buffer;
   const uint8_t *stop = pos + length;
   while (pos < stop) {
@@ -201,7 +207,7 @@ static size_t resp_parse(resp_parser_s *parser, const void *buffer,
         parser->expecting = 0;
         --parser->obj_countdown;
         if (parser->obj_countdown <= 0) {
-          parser->obj_countdown = 0;
+          parser->obj_countdown = 1;
           if (resp_on_message(parser))
             goto finish;
         }
@@ -224,13 +230,13 @@ static size_t resp_parse(resp_parser_s *parser, const void *buffer,
         goto finish;
       }
       resp_on_string_chunk(parser, (void *)(pos + 1),
-                           (size_t)((uintptr_t)eol - (uintptr_t)pos - 2));
+                           (size_t)((uintptr_t)eol - (uintptr_t)pos - 1));
       resp_on_end_string(parser);
       --parser->obj_countdown;
       break;
     case '-':
       resp_on_err_msg(parser, pos,
-                      (size_t)((uintptr_t)eol - (uintptr_t)pos - 2));
+                      (size_t)((uintptr_t)eol - (uintptr_t)pos - 1));
       --parser->obj_countdown;
       break;
     case '*': /* fallthrough */
@@ -276,7 +282,6 @@ static size_t resp_parse(resp_parser_s *parser, const void *buffer,
       case '*':
         if (i < 0) {
           resp_on_null(parser);
-          --parser->obj_countdown;
         } else {
           if (resp_on_start_array(parser, i)) {
             pos = eol + 1;
@@ -284,6 +289,7 @@ static size_t resp_parse(resp_parser_s *parser, const void *buffer,
           }
           parser->obj_countdown += i;
         }
+        --parser->obj_countdown;
         break;
       }
     } break;
@@ -300,7 +306,7 @@ static size_t resp_parse(resp_parser_s *parser, const void *buffer,
     }
     pos = eol + 1;
     if (parser->obj_countdown <= 0 && !parser->expecting) {
-      parser->obj_countdown = 0;
+      parser->obj_countdown = 1;
       resp_on_message(parser);
     }
   }

data/ext/iodine/websocket_parser.h

@@ -7,7 +7,7 @@ Feel free to copy, use and enjoy according to the license specified.
 #ifndef H_WEBSOCKET_PARSER_H
 /**\file
 
-A single file Websocket message parser and Websocket message wrapper, decoupled
+A single file WebSocket message parser and WebSocket message wrapper, decoupled
 from any IO layer.
 
 Notice that this header file library includes static funnction declerations that
@@ -30,7 +30,7 @@ static inline __attribute__((unused)) uint64_t
 websocket_wrapped_len(uint64_t len);
 
 /**
- * Wraps a Websocket server message and writes it to the target buffer.
+ * Wraps a WebSocket server message and writes it to the target buffer.
  *
  * The `first` and `last` flags can be used to support message fragmentation.
  *
@@ -38,7 +38,7 @@ websocket_wrapped_len(uint64_t len);
  * * msg:    the message to be wrapped.
  * * len:    the message length.
  * * opcode: set to 1 for UTF-8 message, 2 for binary, etc'.
- * * first:  set to 1 if `msg` points the begining of the message.
+ * * first:  set to 1 if `msg` points the beginning of the message.
  * * last:   set to 1 if `msg + len` ends the message.
  * * client: set to 1 to use client mode (data  masking).
  *
@@ -60,7 +60,7 @@ websocket_server_wrap(void *target, void *msg, uint64_t len,
                       unsigned char last, unsigned char rsv);
 
 /**
- * Wraps a Websocket client message and writes it to the target buffer.
+ * Wraps a WebSocket client message and writes it to the target buffer.
  *
  * The `first` and `last` flags can be used to support message fragmentation.
  *
@@ -68,7 +68,7 @@ websocket_server_wrap(void *target, void *msg, uint64_t len,
  * * msg:    the message to be wrapped.
  * * len:    the message length.
  * * opcode: set to 1 for UTF-8 message, 2 for binary, etc'.
- * * first:  set to 1 if `msg` points the begining of the message.
+ * * first:  set to 1 if `msg` points the beginning of the message.
  * * last:   set to 1 if `msg + len` ends the message.
  * * client: set to 1 to use client mode (data  masking).
  *
@@ -121,7 +121,7 @@ websocket_buffer_peek(void *buffer, uint64_t len);
  * Returns the remaining data in the existing buffer (can be 0).
  *
  * Notice: if there's any data in the buffer that can't be parsed
- * just yet, `memmove` is used to place the data at the begining of the buffer.
+ * just yet, `memmove` is used to place the data at the beginning of the buffer.
  */
 inline static __attribute__((unused)) uint64_t
 websocket_consume(void *buffer, uint64_t len, void *udata,
@@ -241,7 +241,7 @@ Message wrapping
 /** stub byte swap 64 bit integer from pointer */
 static inline uint64_t netpiswap64(uint8_t *i) {
   uint64_t ret = 0;
-  uint8_t *const pret = &ret;
+  uint8_t *const pret = (uint8_t *)&ret;
   pret[7] = i[7];
   pret[6] = i[6];
   pret[5] = i[5];
@@ -308,7 +308,7 @@ static inline uint64_t websocket_wrapped_len(uint64_t len) {
 }
 
 /**
- * Wraps a Websocket server message and writes it to the target buffer.
+ * Wraps a WebSocket server message and writes it to the target buffer.
  *
  * The `first` and `last` flags can be used to support message fragmentation.
  *
@@ -316,7 +316,7 @@ static inline uint64_t websocket_wrapped_len(uint64_t len) {
  * * msg:    the message to be wrapped.
  * * len:    the message length.
  * * opcode: set to 1 for UTF-8 message, 2 for binary, etc'.
- * * first:  set to 1 if `msg` points the begining of the message.
+ * * first:  set to 1 if `msg` points the beginning of the message.
  * * last:   set to 1 if `msg + len` ends the message.
  * * client: set to 1 to use client mode (data  masking).
  *
@@ -368,7 +368,7 @@ static uint64_t websocket_server_wrap(void *target, void *msg, uint64_t len,
 }
 
 /**
- * Wraps a Websocket client message and writes it to the target buffer.
+ * Wraps a WebSocket client message and writes it to the target buffer.
  *
  * The `first` and `last` flags can be used to support message fragmentation.
  *
@@ -376,7 +376,7 @@ static uint64_t websocket_server_wrap(void *target, void *msg, uint64_t len,
  * * msg:    the message to be wrapped.
  * * len:    the message length.
  * * opcode: set to 1 for UTF-8 message, 2 for binary, etc'.
- * * first:  set to 1 if `msg` points the begining of the message.
+ * * first:  set to 1 if `msg` points the beginning of the message.
  * * last:   set to 1 if `msg + len` ends the message.
  *
  * Returns the number of bytes written. Always `websocket_wrapped_len(len) +
@@ -501,7 +501,7 @@ static uint64_t websocket_consume(void *buffer, uint64_t len, void *udata,
       websocket_xmask(payload, info.packet_length, mask);
     } else if (require_masking && info.packet_length) {
 #if DEBUG
-      fprintf(stderr, "ERROR: Websocket protocol error - unmasked data.\n");
+      fprintf(stderr, "ERROR: WebSocket protocol error - unmasked data.\n");
 #endif
       websocket_on_protocol_error(udata);
     }
@@ -536,7 +536,7 @@ static uint64_t websocket_consume(void *buffer, uint64_t len, void *udata,
       break;
     default:
 #if DEBUG
-      fprintf(stderr, "ERROR: Websocket protocol error - unknown opcode %u\n",
+      fprintf(stderr, "ERROR: WebSocket protocol error - unknown opcode %u\n",
               (unsigned int)(pos[0] & 15));
 #endif
       websocket_on_protocol_error(udata);

data/ext/iodine/websockets.c

@@ -4,18 +4,15 @@ license: MIT
 
 Feel free to copy, use and enjoy according to the license provided.
 */
-#include "spnlock.inc"
+#define FIO_INCLUDE_LINKED_LIST
+#define FIO_INCLUDE_STR
+#include <fio.h>
 
-#include "fio_llist.h"
-#include "fiobj.h"
+#include <fiobj.h>
 
-#include "evio.h"
-#include "fio_base64.h"
-#include "fio_sha1.h"
-#include "http.h"
-#include "http_internal.h"
+#include <http.h>
+#include <http_internal.h>
 
-#include "pubsub.h"
 #include <arpa/inet.h>
 #include <errno.h>
 #include <stdio.h>
@@ -23,9 +20,7 @@ Feel free to copy, use and enjoy according to the license provided.
 #include <string.h>
 #include <strings.h>
 
-#include "fio_mem.h"
-
-#include "websocket_parser.h"
+#include <websocket_parser.h>
 
 #if !defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__)
 #include <endian.h>
@@ -106,11 +101,11 @@ The Websocket object (protocol + parser)
 */
 struct ws_s {
   /** The Websocket protocol */
-  protocol_s protocol;
+  fio_protocol_s protocol;
   /** connection data */
   intptr_t fd;
   /** callbacks */
-  void (*on_message)(ws_s *ws, char *data, size_t size, uint8_t is_text);
+  void (*on_message)(ws_s *ws, fio_str_info_s msg, uint8_t is_text);
   void (*on_shutdown)(ws_s *ws);
   void (*on_ready)(ws_s *ws);
   void (*on_open)(ws_s *ws);
@@ -133,18 +128,13 @@ struct ws_s {
   uint8_t is_client;
 };
 
-/**
-The Websocket Protocol Identifying String. Used for the `each` function.
-*/
-char *WEBSOCKET_ID_STR = "websockets";
-
 /* *****************************************************************************
 Create/Destroy the websocket subscription objects
 ***************************************************************************** */
 
 static inline void clear_subscriptions(ws_s *ws) {
   while (fio_ls_any(&ws->subscriptions)) {
-    pubsub_unsubscribe(fio_ls_pop(&ws->subscriptions));
+    fio_unsubscribe(fio_ls_pop(&ws->subscriptions));
   }
 }
 
@@ -157,7 +147,8 @@ static void websocket_on_unwrapped(void *ws_p, void *msg, uint64_t len,
                                    unsigned char rsv) {
   ws_s *ws = ws_p;
   if (last && first) {
-    ws->on_message(ws, msg, len, (uint8_t)text);
+    ws->on_message(ws, (fio_str_info_s){.data = msg, .len = len},
+                   (uint8_t)text);
     return;
   }
   if (first) {
@@ -168,8 +159,7 @@ static void websocket_on_unwrapped(void *ws_p, void *msg, uint64_t len,
   }
   fiobj_str_write(ws->msg, msg, len);
   if (last) {
-    fio_cstr_s s = fiobj_obj2cstr(ws->msg);
-    ws->on_message(ws, (char *)s.data, s.len, ws->is_text);
+    ws->on_message(ws, fiobj_obj2cstr(ws->msg), ws->is_text);
   }
 
   (void)rsv;
@@ -181,14 +171,14 @@ static void websocket_on_protocol_ping(void *ws_p, void *msg_, uint64_t len) {
     len = (((ws_s *)ws)->is_client
                ? websocket_client_wrap(buff, msg_, len, 10, 1, 1, 0)
                : websocket_server_wrap(buff, msg_, len, 10, 1, 1, 0));
-    sock_write2(.uuid = ws->fd, .buffer = buff, .length = len);
+    fio_write2(ws->fd, .data.buffer = buff, .length = len);
   } else {
     if (((ws_s *)ws)->is_client) {
-      sock_write2(.uuid = ws->fd, .buffer = "\x89\x80mask", .length = 2,
-                  .dealloc = SOCK_DEALLOC_NOOP);
+      fio_write2(ws->fd, .data.buffer = "\x89\x80mask", .length = 2,
+                 .after.dealloc = FIO_DEALLOC_NOOP);
     } else {
-      sock_write2(.uuid = ws->fd, .buffer = "\x89\x00", .length = 2,
-                  .dealloc = SOCK_DEALLOC_NOOP);
+      fio_write2(ws->fd, .data.buffer = "\x89\x00", .length = 2,
+                 .after.dealloc = FIO_DEALLOC_NOOP);
     }
   }
 }
@@ -199,11 +189,11 @@ static void websocket_on_protocol_pong(void *ws_p, void *msg, uint64_t len) {
 }
 static void websocket_on_protocol_close(void *ws_p) {
   ws_s *ws = ws_p;
-  sock_close(ws->fd);
+  fio_close(ws->fd);
 }
 static void websocket_on_protocol_error(void *ws_p) {
   ws_s *ws = ws_p;
-  sock_close(ws->fd);
+  fio_close(ws->fd);
 }
 
 /*******************************************************************************
@@ -212,44 +202,45 @@ The Websocket Protocol implementation
 
 #define ws_protocol(fd) ((ws_s *)(server_get_protocol(fd)))
 
-static void ws_ping(intptr_t fd, protocol_s *ws) {
+static void ws_ping(intptr_t fd, fio_protocol_s *ws) {
   (void)(ws);
   if (((ws_s *)ws)->is_client) {
-    sock_write2(.uuid = fd, .buffer = "\x89\x80MASK", .length = 6,
-                .dealloc = SOCK_DEALLOC_NOOP);
+    fio_write2(fd, .data.buffer = "\x89\x80MASK", .length = 6,
+               .after.dealloc = FIO_DEALLOC_NOOP);
   } else {
-    sock_write2(.uuid = fd, .buffer = "\x89\x00", .length = 2,
-                .dealloc = SOCK_DEALLOC_NOOP);
+    fio_write2(fd, .data.buffer = "\x89\x00", .length = 2,
+               .after.dealloc = FIO_DEALLOC_NOOP);
   }
 }
 
-static void on_close(intptr_t uuid, protocol_s *_ws) {
+static void on_close(intptr_t uuid, fio_protocol_s *_ws) {
   destroy_ws((ws_s *)_ws);
   (void)uuid;
 }
 
-static void on_ready(intptr_t fduuid, protocol_s *ws) {
+static void on_ready(intptr_t fduuid, fio_protocol_s *ws) {
   (void)(fduuid);
-  if (ws && ws->service == WEBSOCKET_ID_STR && ((ws_s *)ws)->on_ready)
+  if (((ws_s *)ws)->on_ready)
     ((ws_s *)ws)->on_ready((ws_s *)ws);
 }
 
-static void on_shutdown(intptr_t fd, protocol_s *ws) {
+static uint8_t on_shutdown(intptr_t fd, fio_protocol_s *ws) {
   (void)(fd);
   if (ws && ((ws_s *)ws)->on_shutdown)
     ((ws_s *)ws)->on_shutdown((ws_s *)ws);
   if (((ws_s *)ws)->is_client) {
-    sock_write2(.uuid = fd, .buffer = "\x8a\x80MASK", .length = 6,
-                .dealloc = SOCK_DEALLOC_NOOP);
+    fio_write2(fd, .data.buffer = "\x8a\x80MASK", .length = 6,
+               .after.dealloc = FIO_DEALLOC_NOOP);
   } else {
-    sock_write2(.uuid = fd, .buffer = "\x8a\x00", .length = 2,
-                .dealloc = SOCK_DEALLOC_NOOP);
+    fio_write2(fd, .data.buffer = "\x8a\x00", .length = 2,
+               .after.dealloc = FIO_DEALLOC_NOOP);
   }
+  return 0;
 }
 
-static void on_data(intptr_t sockfd, protocol_s *ws_) {
+static void on_data(intptr_t sockfd, fio_protocol_s *ws_) {
   ws_s *const ws = (ws_s *)ws_;
-  if (ws == NULL || ws->protocol.service != WEBSOCKET_ID_STR)
+  if (ws == NULL)
     return;
   struct websocket_packet_info_s info =
       websocket_buffer_peek(ws->buffer.data, ws->length);
@@ -271,18 +262,18 @@ static void on_data(intptr_t sockfd, protocol_s *ws_) {
     }
   }
 
-  const ssize_t len = sock_read(sockfd, (uint8_t *)ws->buffer.data + ws->length,
-                                ws->buffer.size - ws->length);
+  const ssize_t len = fio_read(sockfd, (uint8_t *)ws->buffer.data + ws->length,
+                               ws->buffer.size - ws->length);
   if (len <= 0) {
     return;
   }
   ws->length = websocket_consume(ws->buffer.data, ws->length + len, ws,
                                  (~(ws->is_client) & 1));
 
-  facil_force_event(sockfd, FIO_EVENT_ON_DATA);
+  fio_force_event(sockfd, FIO_EVENT_ON_DATA);
 }
 
-static void on_data_first(intptr_t sockfd, protocol_s *ws_) {
+static void on_data_first(intptr_t sockfd, fio_protocol_s *ws_) {
   ws_s *const ws = (ws_s *)ws_;
   if (ws->on_open)
     ws->on_open(ws);
@@ -293,9 +284,8 @@ static void on_data_first(intptr_t sockfd, protocol_s *ws_) {
     ws->length = websocket_consume(ws->buffer.data, ws->length, ws,
                                    (~(ws->is_client) & 1));
   }
-  evio_add_write(sock_uuid2fd(sockfd), (void *)sockfd);
-
-  facil_force_event(sockfd, FIO_EVENT_ON_DATA);
+  fio_force_event(sockfd, FIO_EVENT_ON_DATA);
+  fio_force_event(sockfd, FIO_EVENT_ON_READY);
 }
 
 /* later */
@@ -310,7 +300,6 @@ static ws_s *new_websocket(intptr_t uuid) {
   // allocate the protocol object
   ws_s *ws = malloc(sizeof(*ws));
   *ws = (ws_s){
-      .protocol.service = WEBSOCKET_ID_STR,
       .protocol.ping = ws_ping,
       .protocol.on_data = on_data_first,
       .protocol.on_close = on_close,
@@ -355,10 +344,10 @@ void websocket_attach(intptr_t uuid, http_settings_s *http_settings,
     // buffer limits
     ws->max_msg_size = http_settings->ws_max_msg_size;
     // update the timeout
-    facil_set_timeout(uuid, http_settings->ws_timeout);
+    fio_timeout_set(uuid, http_settings->ws_timeout);
   } else {
     ws->max_msg_size = (1024 * 256);
-    facil_set_timeout(uuid, 40);
+    fio_timeout_set(uuid, 40);
   }
 
   if (data && length) {
@@ -367,7 +356,7 @@ void websocket_attach(intptr_t uuid, http_settings_s *http_settings,
       ws->buffer = resize_ws_buffer(ws, ws->buffer);
       if (!ws->buffer.data) {
         // no memory.
-        facil_attach(uuid, (protocol_s *)ws);
+        fio_attach(uuid, (fio_protocol_s *)ws);
         websocket_close(ws);
         return;
       }
@@ -375,10 +364,10 @@ void websocket_attach(intptr_t uuid, http_settings_s *http_settings,
     memcpy(ws->buffer.data, data, length);
     ws->length = length;
   }
-  // update the protocol object, cleanning up the old one
-  facil_attach(uuid, (protocol_s *)ws);
+  // update the protocol object, cleaning up the old one
+  fio_attach(uuid, (fio_protocol_s *)ws);
   // allow the on_open and on_data to take over the control.
-  facil_force_event(uuid, FIO_EVENT_ON_DATA);
+  fio_force_event(uuid, FIO_EVENT_ON_DATA);
 }
 
 /*******************************************************************************
@@ -387,36 +376,6 @@ Writing to the Websocket
 #define WS_MAX_FRAME_SIZE                                                      \
   (FIO_MEMORY_BLOCK_ALLOC_LIMIT - 4096) // should be less then `unsigned short`
 
-// clang-format off
-#if !defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__)
-#   if defined(__has_include)
-#     if __has_include(<endian.h>)
-#      include <endian.h>
-#     elif __has_include(<sys/endian.h>)
-#      include <sys/endian.h>
-#     endif
-#   endif
-#   if !defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__) && \
-                __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
-#      define __BIG_ENDIAN__
-#   endif
-#endif
-// clang-format on
-
-#ifdef __BIG_ENDIAN__
-/** byte swap 64 bit integer */
-#define bswap64(i) (i)
-
-#else
-// TODO: check for __builtin_bswap64
-/** byte swap 64 bit integer */
-#define bswap64(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))
-#endif
-
 static void websocket_write_impl(intptr_t fd, void *data, size_t len, char text,
                                  char first, char last, char client) {
   if (len <= WS_MAX_FRAME_SIZE) {
@@ -425,7 +384,8 @@ static void websocket_write_impl(intptr_t fd, void *data, size_t len, char text,
                                           first, last, 0)
                   : websocket_server_wrap(buff, data, len, (text ? 1 : 2),
                                           first, last, 0));
-    sock_write2(.uuid = fd, .buffer = buff, .length = len, .dealloc = fio_free);
+    fio_write2(fd, .data.buffer = buff, .length = len,
+               .after.dealloc = fio_free);
   } else {
     /* frame fragmentation is better for large data then large frames */
     while (len > WS_MAX_FRAME_SIZE) {
@@ -440,77 +400,128 @@ static void websocket_write_impl(intptr_t fd, void *data, size_t len, char text,
 }
 
 /* *****************************************************************************
-UTF-8 testing. This part was practically copied from:
-https://stackoverflow.com/a/22135005/4025095
-and
-http://bjoern.hoehrmann.de/utf-8/decoder/dfa
+Multi-client broadcast optimizations
 ***************************************************************************** */
-/* Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de> */
-/* See http://bjoern.hoehrmann.de/utf-8/decoder/dfa/ for details. */
-
-#define UTF8_ACCEPT 0
-#define UTF8_REJECT 1
-
-static const uint8_t utf8d[] = {
-    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,   0, // 00..1f
-    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,   0, // 20..3f
-    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,   0, // 40..5f
-    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   0,   0,   0,   0,   0,   0,   0,   0, // 60..7f
-    1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,
-    1,   1,   1,   1,   1,   9,   9,   9,   9,   9,   9,
-    9,   9,   9,   9,   9,   9,   9,   9,   9,   9, // 80..9f
-    7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,
-    7,   7,   7,   7,   7,   7,   7,   7,   7,   7,   7,
-    7,   7,   7,   7,   7,   7,   7,   7,   7,   7, // a0..bf
-    8,   8,   2,   2,   2,   2,   2,   2,   2,   2,   2,
-    2,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,
-    2,   2,   2,   2,   2,   2,   2,   2,   2,   2, // c0..df
-    0xa, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3,
-    0x3, 0x3, 0x4, 0x3, 0x3, // e0..ef
-    0xb, 0x6, 0x6, 0x6, 0x5, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8,
-    0x8, 0x8, 0x8, 0x8, 0x8, // f0..ff
-    0x0, 0x1, 0x2, 0x3, 0x5, 0x8, 0x7, 0x1, 0x1, 0x1, 0x4,
-    0x6, 0x1, 0x1, 0x1, 0x1, // s0..s0
-    1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,
-    1,   1,   1,   1,   1,   1,   0,   1,   1,   1,   1,
-    1,   0,   1,   0,   1,   1,   1,   1,   1,   1, // s1..s2
-    1,   2,   1,   1,   1,   1,   1,   2,   1,   2,   1,
-    1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,
-    1,   2,   1,   1,   1,   1,   1,   1,   1,   1, // s3..s4
-    1,   2,   1,   1,   1,   1,   1,   1,   1,   2,   1,
-    1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,
-    1,   3,   1,   3,   1,   1,   1,   1,   1,   1, // s5..s6
-    1,   3,   1,   1,   1,   1,   1,   3,   1,   3,   1,
-    1,   1,   1,   1,   1,   1,   3,   1,   1,   1,   1,
-    1,   1,   1,   1,   1,   1,   1,   1,   1,   1, // s7..s8
-};
 
-static inline uint32_t validate_utf8(uint8_t *str, size_t len) {
-  uint32_t state = 0;
-  while (len) {
-    uint32_t type = utf8d[*str];
-    state = utf8d[256 + state * 16 + type];
-    if (state == UTF8_REJECT)
-      return 0;
-    len--;
-    str++;
+static void websocket_optimize_free(fio_msg_s *msg, void *metadata) {
+  fiobj_free((FIOBJ)metadata);
+  (void)msg;
+}
+
+static inline fio_msg_metadata_s websocket_optimize(fio_str_info_s msg,
+                                                    unsigned char opcode) {
+  FIOBJ out = fiobj_str_buf(msg.len + 10);
+  fiobj_str_resize(out,
+                   websocket_server_wrap(fiobj_obj2cstr(out).data, msg.data,
+                                         msg.len, opcode, 1, 1, 0));
+  fio_msg_metadata_s ret = {
+      .on_finish = websocket_optimize_free,
+      .metadata = (void *)out,
+  };
+  return ret;
+}
+static fio_msg_metadata_s websocket_optimize_generic(fio_str_info_s ch,
+                                                     fio_str_info_s msg,
+                                                     uint8_t is_json) {
+  fio_str_s tmp = FIO_STR_INIT_EXISTING(ch.data, ch.len, 0); // don't free
+  tmp.dealloc = NULL;
+  unsigned char opcode = 2;
+  if (tmp.len <= (2 << 19) && fio_str_utf8_valid(&tmp)) {
+    opcode = 1;
   }
-  return state == 0;
+  fio_msg_metadata_s ret = websocket_optimize(msg, opcode);
+  ret.type_id = WEBSOCKET_OPTIMIZE_PUBSUB;
+  return ret;
+  (void)ch;
+  (void)is_json;
+}
+
+static fio_msg_metadata_s websocket_optimize_text(fio_str_info_s ch,
+                                                  fio_str_info_s msg,
+                                                  uint8_t is_json) {
+  fio_msg_metadata_s ret = websocket_optimize(msg, 1);
+  ret.type_id = WEBSOCKET_OPTIMIZE_PUBSUB_TEXT;
+  return ret;
+  (void)ch;
+  (void)is_json;
+}
+
+static fio_msg_metadata_s websocket_optimize_binary(fio_str_info_s ch,
+                                                    fio_str_info_s msg,
+                                                    uint8_t is_json) {
+  fio_msg_metadata_s ret = websocket_optimize(msg, 2);
+  ret.type_id = WEBSOCKET_OPTIMIZE_PUBSUB_BINARY;
+  return ret;
+  (void)ch;
+  (void)is_json;
 }
+
+/**
+ * Enables (or disables) broadcast optimizations.
+ *
+ * When using WebSocket pub/sub system is originally optimized for either
+ * non-direct transmission (messages are handled by callbacks) or direct
+ * transmission to 1-3 clients per channel (on average), meaning that the
+ * majority of the messages are meant for a single recipient (or multiple
+ * callback recipients) and only some are expected to be directly transmitted to
+ * a group.
+ *
+ * However, when most messages are intended for direct transmission to more than
+ * 3 clients (on average), certain optimizations can be made to improve memory
+ * consumption (minimize duplication or WebSocket network data).
+ *
+ * This function allows enablement (or disablement) of these optimizations.
+ * These optimizations include:
+ *
+ * * WEBSOCKET_OPTIMIZE_PUBSUB - optimize all direct transmission messages,
+ *                               best attempt to detect Text vs. Binary data.
+ * * WEBSOCKET_OPTIMIZE_PUBSUB_TEXT - optimize direct pub/sub text messages.
+ * * WEBSOCKET_OPTIMIZE_PUBSUB_BINARY - optimize direct pub/sub binary messages.
+ *
+ * Note: to disable an optimization it should be disabled the same amount of
+ * times it was enabled - multiple optimization enablements for the same type
+ * are merged, but reference counted (disabled when reference is zero).
+ */
+void websocket_optimize4broadcasts(intptr_t type, int enable) {
+  static intptr_t generic = 0;
+  static intptr_t text = 0;
+  static intptr_t binary = 0;
+  fio_msg_metadata_s (*callback)(fio_str_info_s, fio_str_info_s, uint8_t);
+  intptr_t *counter;
+  switch ((0 - type)) {
+  case (0 - WEBSOCKET_OPTIMIZE_PUBSUB):
+    counter = &generic;
+    callback = websocket_optimize_generic;
+    break;
+  case (0 - WEBSOCKET_OPTIMIZE_PUBSUB_TEXT):
+    counter = &text;
+    callback = websocket_optimize_text;
+    break;
+  case (0 - WEBSOCKET_OPTIMIZE_PUBSUB_BINARY):
+    counter = &binary;
+    callback = websocket_optimize_binary;
+    break;
+  default:
+    return;
+  }
+  if (enable) {
+    if (fio_atomic_add(counter, 1) == 1) {
+      fio_message_metadata_callback_set(callback, 1);
+    }
+  } else {
+    if (fio_atomic_sub(counter, 1) == 0) {
+      fio_message_metadata_callback_set(callback, 0);
+    }
+  }
+}
+
 /* *****************************************************************************
 Subscription handling
 ***************************************************************************** */
 
 typedef struct {
-  void (*on_message)(websocket_pubsub_notification_s notification);
+  void (*on_message)(ws_s *ws, fio_str_info_s channel, fio_str_info_s msg,
+                     void *udata);
   void (*on_unsubscribe)(void *udata);
   void *udata;
 } websocket_sub_data_s;
@@ -518,73 +529,82 @@ typedef struct {
 static void websocket_on_unsubscribe(void *u1, void *u2) {
   websocket_sub_data_s *d = u2;
   (void)u1;
-  if (d->on_unsubscribe)
+  if (d->on_unsubscribe) {
     d->on_unsubscribe(d->udata);
+  }
   free(d);
 }
 
-static inline void
-websocket_on_pubsub_message_direct_internal(pubsub_message_s *msg,
-                                            uint8_t txt) {
-  protocol_s *pr =
-      facil_protocol_try_lock((intptr_t)msg->udata1, FIO_PR_LOCK_WRITE);
+static inline void websocket_on_pubsub_message_direct_internal(fio_msg_s *msg,
+                                                               uint8_t txt) {
+  fio_protocol_s *pr =
+      fio_protocol_try_lock((intptr_t)msg->udata1, FIO_PR_LOCK_WRITE);
   if (!pr) {
     if (errno == EBADF)
       return;
-    pubsub_defer(msg);
+    fio_message_defer(msg);
     return;
   }
-  FIOBJ message;
-  fio_cstr_s tmp;
-  if (FIOBJ_TYPE_IS(msg->message, FIOBJ_T_STRING)) {
-    message = fiobj_dup(msg->message);
-    tmp = fiobj_obj2cstr(message);
-    if (txt == 2) {
-      /* unknown text state */
-      txt =
-          (tmp.len >= (2 << 14) ? 0
-                                : validate_utf8((uint8_t *)tmp.data, tmp.len));
-    }
-  } else {
-    message = fiobj_obj2json(msg->message, 0);
-    tmp = fiobj_obj2cstr(message);
+  FIOBJ message = FIOBJ_INVALID;
+  FIOBJ pre_wrapped = FIOBJ_INVALID;
+  switch (txt) {
+  case 0:
+    pre_wrapped =
+        (FIOBJ)fio_message_metadata(msg, WEBSOCKET_OPTIMIZE_PUBSUB_BINARY);
+    break;
+  case 1:
+    pre_wrapped =
+        (FIOBJ)fio_message_metadata(msg, WEBSOCKET_OPTIMIZE_PUBSUB_TEXT);
+    break;
+  case 2:
+    pre_wrapped = (FIOBJ)fio_message_metadata(msg, WEBSOCKET_OPTIMIZE_PUBSUB);
+    break;
+  default:
+    break;
+  }
+  if (pre_wrapped) {
+    // fprintf(stderr, "INFO: WebSocket Pub/Sub optimized for broadcast\n");
+    fiobj_send_free((intptr_t)msg->udata1, fiobj_dup(pre_wrapped));
+    goto finish;
   }
-  websocket_write((ws_s *)pr, tmp.data, tmp.len, txt & 1);
-  facil_protocol_unlock(pr, FIO_PR_LOCK_WRITE);
+  if (txt == 2) {
+    /* unknown text state */
+    fio_str_s tmp =
+        FIO_STR_INIT_EXISTING(msg->msg.data, msg->msg.len, 0); // don't free
+    txt = (tmp.len >= (2 << 14) ? 0 : fio_str_utf8_valid(&tmp));
+  }
+  websocket_write((ws_s *)pr, msg->msg, txt & 1);
   fiobj_free(message);
+finish:
+  fio_protocol_unlock(pr, FIO_PR_LOCK_WRITE);
 }
 
-static void websocket_on_pubsub_message_direct(pubsub_message_s *msg) {
+static void websocket_on_pubsub_message_direct(fio_msg_s *msg) {
   websocket_on_pubsub_message_direct_internal(msg, 2);
 }
 
-static void websocket_on_pubsub_message_direct_txt(pubsub_message_s *msg) {
+static void websocket_on_pubsub_message_direct_txt(fio_msg_s *msg) {
   websocket_on_pubsub_message_direct_internal(msg, 1);
 }
 
-static void websocket_on_pubsub_message_direct_bin(pubsub_message_s *msg) {
+static void websocket_on_pubsub_message_direct_bin(fio_msg_s *msg) {
   websocket_on_pubsub_message_direct_internal(msg, 0);
 }
 
-static void websocket_on_pubsub_message(pubsub_message_s *msg) {
-  protocol_s *pr =
-      facil_protocol_try_lock((intptr_t)msg->udata1, FIO_PR_LOCK_TASK);
+static void websocket_on_pubsub_message(fio_msg_s *msg) {
+  fio_protocol_s *pr =
+      fio_protocol_try_lock((intptr_t)msg->udata1, FIO_PR_LOCK_TASK);
   if (!pr) {
     if (errno == EBADF)
       return;
-    pubsub_defer(msg);
+    fio_message_defer(msg);
     return;
   }
   websocket_sub_data_s *d = msg->udata2;
 
   if (d->on_message)
-    d->on_message((websocket_pubsub_notification_s){
-        .ws = (ws_s *)pr,
-        .subscription_id = (intptr_t)msg->subscription,
-        .channel = msg->channel,
-        .message = msg->message,
-    });
-  facil_protocol_unlock(pr, FIO_PR_LOCK_TASK);
+    d->on_message((ws_s *)pr, msg->channel, msg->msg, d->udata);
+  fio_protocol_unlock(pr, FIO_PR_LOCK_TASK);
 }
 
 /**
@@ -595,12 +615,17 @@ uintptr_t websocket_subscribe(struct websocket_subscribe_s args) {
   if (!args.ws)
     goto error;
   websocket_sub_data_s *d = malloc(sizeof(*d));
-  *d = (websocket_sub_data_s){.udata = args.udata,
-                              .on_message = args.on_message,
-                              .on_unsubscribe = args.on_unsubscribe};
-
-  pubsub_sub_pt sub = pubsub_subscribe(
-          .channel = args.channel, .use_pattern = args.use_pattern,
+  if (!d) {
+    websocket_close(args.ws);
+    goto error;
+  }
+  *d = (websocket_sub_data_s){
+      .udata = args.udata,
+      .on_message = args.on_message,
+      .on_unsubscribe = args.on_unsubscribe,
+  };
+  subscription_s *sub = fio_subscribe(
+          .channel = args.channel, .match = args.match,
           .on_unsubscribe = websocket_on_unsubscribe,
           .on_message =
               (args.on_message
@@ -612,7 +637,7 @@ uintptr_t websocket_subscribe(struct websocket_subscribe_s args) {
                                : websocket_on_pubsub_message_direct),
           .udata1 = (void *)args.ws->fd, .udata2 = d);
   if (!sub) {
-    free(d);
+    /* don't free `d`, return (`d` freed by callback) */
     return 0;
   }
   fio_ls_push(&args.ws->subscriptions, sub);
@@ -623,37 +648,11 @@ error:
   return 0;
 }
 
-/**
- * Returns the existing subscription's ID (if exists) or 0 (no subscription).
- */
-#undef websocket_find_sub
-uintptr_t websocket_find_sub(struct websocket_subscribe_s args) {
-  pubsub_sub_pt sub = pubsub_find_sub(
-          .channel = args.channel, .use_pattern = args.use_pattern,
-          .on_unsubscribe = websocket_on_unsubscribe,
-          .on_message =
-              (args.on_message
-                   ? websocket_on_pubsub_message
-                   : args.force_binary
-                         ? websocket_on_pubsub_message_direct_bin
-                         : args.force_text
-                               ? websocket_on_pubsub_message_direct_txt
-                               : websocket_on_pubsub_message_direct),
-          .udata1 = (void *)args.ws->fd, .udata2 = args.udata);
-  if (!sub)
-    return 0;
-  FIO_LS_FOR(&args.ws->subscriptions, pos) {
-    if (pos->obj == sub)
-      return (uintptr_t)pos;
-  }
-  return 0;
-}
-
 /**
  * Unsubscribes from a channel.
  */
 void websocket_unsubscribe(ws_s *ws, uintptr_t subscription_id) {
-  pubsub_unsubscribe((pubsub_sub_pt)((fio_ls_s *)subscription_id)->obj);
+  fio_unsubscribe((subscription_s *)((fio_ls_s *)subscription_id)->obj);
   fio_ls_remove((fio_ls_s *)subscription_id);
   (void)ws;
 }
@@ -663,9 +662,11 @@ The API implementation
 */
 
 /** Returns the opaque user data associated with the websocket. */
-void *websocket_udata(ws_s *ws) { return ws->udata; }
+void *websocket_udata_get(ws_s *ws) { return ws->udata; }
+
 /** Returns the the process specific connection's UUID (see `libsock`). */
 intptr_t websocket_uuid(ws_s *ws) { return ws->fd; }
+
 /** Sets the opaque user data associated with the websocket.
  * Returns the old value, if any. */
 void *websocket_udata_set(ws_s *ws, void *udata) {
@@ -673,181 +674,27 @@ void *websocket_udata_set(ws_s *ws, void *udata) {
   ws->udata = udata;
   return old;
 }
+
+/**
+ * Returns 1 if the WebSocket connection is in Client mode (connected to a
+ * remote server) and 0 if the connection is in Server mode (a connection
+ * established using facil.io's HTTP server).
+ */
+uint8_t websocket_is_client(ws_s *ws) { return ws->is_client; }
+
 /** 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) {
-  if (sock_isvalid(ws->fd)) {
-    websocket_write_impl(ws->fd, data, size, is_text, 1, 1, ws->is_client);
+int websocket_write(ws_s *ws, fio_str_info_s msg, uint8_t is_text) {
+  if (fio_is_valid(ws->fd)) {
+    websocket_write_impl(ws->fd, msg.data, msg.len, is_text, 1, 1,
+                         ws->is_client);
     return 0;
   }
   return -1;
 }
 /** Closes a websocket connection. */
 void websocket_close(ws_s *ws) {
-  sock_write2(.uuid = ws->fd, .buffer = "\x88\x00", .length = 2,
-              .dealloc = SOCK_DEALLOC_NOOP);
-  sock_close(ws->fd);
+  fio_write2(ws->fd, .data.buffer = "\x88\x00", .length = 2,
+             .after.dealloc = FIO_DEALLOC_NOOP);
+  fio_close(ws->fd);
   return;
 }
-
-/**
-Counts the number of websocket connections.
-*/
-size_t websocket_count(void) { return facil_count(WEBSOCKET_ID_STR); }
-
-/*******************************************************************************
-Each Implementation
-*/
-
-/** A task container. */
-struct WSTask {
-  void (*task)(ws_s *, void *);
-  void (*on_finish)(ws_s *, void *);
-  void *arg;
-};
-/** Performs a task on each websocket connection that shares the same process
- */
-static void perform_ws_task(intptr_t fd, protocol_s *ws_, void *tsk_) {
-  (void)(fd);
-  struct WSTask *tsk = tsk_;
-  tsk->task((ws_s *)(ws_), tsk->arg);
-}
-/** clears away a wesbocket task. */
-static void finish_ws_task(intptr_t fd, void *arg) {
-  struct WSTask *tsk = arg;
-  if (tsk->on_finish) {
-    protocol_s *ws = facil_protocol_try_lock(fd, FIO_PR_LOCK_TASK);
-    if (!ws && errno != EBADF) {
-      defer((void (*)(void *, void *))finish_ws_task, (void *)fd, arg);
-      return;
-    }
-    tsk->on_finish((ws_s *)ws, tsk->arg);
-    if (ws)
-      facil_protocol_unlock(ws, FIO_PR_LOCK_TASK);
-  }
-  free(tsk);
-}
-
-/**
-Performs a task on each websocket connection that shares the same process
-(except the originating `ws_s` connection which is allowed to be NULL).
- */
-#undef websocket_each
-void __attribute__((deprecated))
-websocket_each(struct websocket_each_args_s args) {
-  struct WSTask *tsk = malloc(sizeof(*tsk));
-  tsk->arg = args.arg;
-  tsk->on_finish = args.on_finish;
-  tsk->task = args.task;
-  facil_each(.origin = (args.origin ? args.origin->fd : -1),
-             .service = WEBSOCKET_ID_STR, .task = perform_ws_task, .arg = tsk,
-             .on_complete = finish_ws_task);
-}
-/*******************************************************************************
-Multi-Write (direct broadcast) Implementation
-*/
-struct websocket_multi_write {
-  uint8_t (*if_callback)(ws_s *ws_to, void *arg);
-  void (*on_finished)(ws_s *ws_origin, void *arg);
-  intptr_t origin;
-  void *arg;
-  spn_lock_i lock;
-  /* ... we need to have padding for pointer arithmatics... */
-  uint8_t as_client;
-  /* ... we need to have padding for pointer arithmatics... */
-  size_t count;
-  size_t length;
-  uint8_t buffer[]; /* starts on border alignment */
-};
-
-static void ws_mw_defered_on_finish_fb(intptr_t fd, void *arg) {
-  (void)(fd);
-  struct websocket_multi_write *fin = arg;
-  if (fin->on_finished)
-    fin->on_finished(NULL, fin->arg);
-  free(fin);
-}
-static void ws_mw_defered_on_finish(intptr_t fd, protocol_s *ws, void *arg) {
-  (void)fd;
-  struct websocket_multi_write *fin = arg;
-  if (fin->on_finished) {
-    fin->on_finished((ws_s *)ws, fin->arg);
-  }
-  free(fin);
-}
-
-static void ws_reduce_or_free_multi_write(void *buff) {
-  struct websocket_multi_write *mw = (void *)((uintptr_t)buff - sizeof(*mw));
-  spn_lock(&mw->lock);
-  mw->count -= 1;
-  if (!mw->count) {
-    spn_unlock(&mw->lock);
-    if (mw->on_finished) {
-      facil_defer(.uuid = mw->origin, .task = ws_mw_defered_on_finish,
-                  .arg = mw, .fallback = ws_mw_defered_on_finish_fb,
-                  .type = FIO_PR_LOCK_WRITE);
-    } else
-      free(mw);
-  } else
-    spn_unlock(&mw->lock);
-}
-
-static void ws_finish_multi_write(intptr_t fd, void *arg) {
-  struct websocket_multi_write *multi = arg;
-  (void)(fd);
-  ws_reduce_or_free_multi_write(multi->buffer);
-}
-
-static void ws_direct_multi_write(intptr_t fd, protocol_s *_ws, void *arg) {
-  struct websocket_multi_write *multi = arg;
-  if (((ws_s *)(_ws))->is_client != multi->as_client)
-    return;
-  spn_lock(&multi->lock);
-  multi->count += 1;
-  spn_unlock(&multi->lock);
-  sock_write2(.uuid = fd, .buffer = multi->buffer, .length = multi->length,
-              .dealloc = ws_reduce_or_free_multi_write);
-}
-
-static void ws_check_multi_write(intptr_t fd, protocol_s *_ws, void *arg) {
-  struct websocket_multi_write *multi = arg;
-  if (((ws_s *)(_ws))->is_client != multi->as_client)
-    return;
-  if (multi->if_callback((void *)_ws, multi->arg))
-    ws_direct_multi_write(fd, _ws, arg);
-}
-
-#undef websocket_write_each
-int __attribute__((deprecated))
-websocket_write_each(struct websocket_write_each_args_s args) {
-  if (!args.data || !args.length)
-    return -1;
-  struct websocket_multi_write *multi =
-      malloc(sizeof(*multi) + args.length + 16 /* max head size + 2 */);
-  if (!multi) {
-    if (args.on_finished)
-      defer((void (*)(void *, void *))args.on_finished, NULL, args.arg);
-    return -1;
-  }
-  *multi = (struct websocket_multi_write){
-      .length =
-          (args.as_client
-               ? websocket_client_wrap(multi->buffer, args.data, args.length,
-                                       args.is_text ? 1 : 2, 1, 1, 0)
-               : websocket_server_wrap(multi->buffer, args.data, args.length,
-                                       args.is_text ? 1 : 2, 1, 1, 0)),
-      .if_callback = args.filter,
-      .on_finished = args.on_finished,
-      .arg = args.arg,
-      .origin = (args.origin ? args.origin->fd : -1),
-      .as_client = args.as_client,
-      .lock = SPN_LOCK_INIT,
-      .count = 1,
-  };
-
-  facil_each(.origin = multi->origin, .service = WEBSOCKET_ID_STR,
-             .task_type = FIO_PR_LOCK_WRITE,
-             .task =
-                 (args.filter ? ws_check_multi_write : ws_direct_multi_write),
-             .arg = multi, .on_complete = ws_finish_multi_write);
-  return 0;
-}