iodine 0.7.1 → 0.7.2

data/ext/iodine/fiobject.h

@@ -10,6 +10,10 @@ types, abstracting some complexity and making dynamic type related tasks easier.
 */
 #define H_FIOBJECT_H
 
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
 #include <stdarg.h>
 #include <stdint.h>
 #include <stdio.h>

data/ext/iodine/http.c

@@ -173,7 +173,7 @@ int http_set_header2(http_s *r, fio_str_info_s n, fio_str_info_s v) {
 #undef http_set_cookie
 int http_set_cookie(http_s *h, http_cookie_args_s cookie) {
 #if DEBUG
-  HTTP_ASSERT(h, "Can't set cookie for NULL HTTP handler!");
+  FIO_ASSERT(h, "Can't set cookie for NULL HTTP handler!");
 #endif
   if (HTTP_INVALID_HANDLE(h) || cookie.name_len >= 32768 ||
       cookie.value_len >= 131072) {
@@ -194,10 +194,9 @@ int http_set_cookie(http_s *h, http_cookie_args_s cookie) {
         if (invalid_cookie_name_char[(uint8_t)cookie.name[tmp]]) {
           if (!warn_illegal) {
             ++warn_illegal;
-            fprintf(stderr,
-                    "WARNING: illegal char 0x%.2x in cookie name (in %s)\n"
-                    "         automatic %% encoding applied\n",
-                    cookie.name[tmp], cookie.name);
+            FIO_LOG_WARNING("illegal char 0x%.2x in cookie name (in %s)\n"
+                            "         automatic %% encoding applied",
+                            cookie.name[tmp], cookie.name);
           }
           t.data[len++] = '%';
           t.data[len++] = hex_chars[(cookie.name[tmp] >> 4) & 0x0F];
@@ -218,10 +217,9 @@ int http_set_cookie(http_s *h, http_cookie_args_s cookie) {
         if (invalid_cookie_name_char[(uint8_t)cookie.name[tmp]]) {
           if (!warn_illegal) {
             ++warn_illegal;
-            fprintf(stderr,
-                    "WARNING: illegal char 0x%.2x in cookie name (in %s)\n"
-                    "         automatic %% encoding applied\n",
-                    cookie.name[tmp], cookie.name);
+            FIO_LOG_WARNING("illegal char 0x%.2x in cookie name (in %s)\n"
+                            "         automatic %% encoding applied",
+                            cookie.name[tmp], cookie.name);
           }
           t.data[len++] = '%';
           t.data[len++] = hex_chars[(cookie.name[tmp] >> 4) & 0x0F];
@@ -246,10 +244,9 @@ int http_set_cookie(http_s *h, http_cookie_args_s cookie) {
         if (invalid_cookie_value_char[(uint8_t)cookie.value[tmp]]) {
           if (!warn_illegal) {
             ++warn_illegal;
-            fprintf(stderr,
-                    "WARNING: illegal char 0x%.2x in cookie value (in %s)\n"
-                    "         automatic %% encoding applied\n",
-                    cookie.value[tmp], cookie.name);
+            FIO_LOG_WARNING("illegal char 0x%.2x in cookie value (in %s)\n"
+                            "         automatic %% encoding applied",
+                            cookie.value[tmp], cookie.name);
           }
           t.data[len++] = '%';
           t.data[len++] = hex_chars[(cookie.value[tmp] >> 4) & 0x0F];
@@ -270,10 +267,9 @@ int http_set_cookie(http_s *h, http_cookie_args_s cookie) {
         if (invalid_cookie_value_char[(uint8_t)cookie.value[tmp]]) {
           if (!warn_illegal) {
             ++warn_illegal;
-            fprintf(stderr,
-                    "WARNING: illegal char 0x%.2x in cookie value (in %s)\n"
-                    "         automatic %% encoding applied\n",
-                    cookie.value[tmp], cookie.name);
+            FIO_LOG_WARNING("illegal char 0x%.2x in cookie value (in %s)\n"
+                            "         automatic %% encoding applied",
+                            cookie.value[tmp], cookie.name);
           }
           t.data[len++] = '%';
           t.data[len++] = hex_chars[(cookie.value[tmp] >> 4) & 0x0F];
@@ -591,7 +587,7 @@ open_file:
   s = fiobj_obj2cstr(filename);
   file = open(s.data, O_RDONLY);
   if (file == -1) {
-    fprintf(stderr, "ERROR: Couldn't open file %s!\n", s.data);
+    FIO_LOG_ERROR("(HTTP) couldn't open file %s!\n", s.data);
     perror("     ");
     http_send_error(h, 500);
     return 0;
@@ -704,8 +700,7 @@ int http_push_file(http_s *h, FIOBJ filename, FIOBJ mime_type) {
 #undef http_upgrade2ws
 int http_upgrade2ws(http_s *h, websocket_settings_s args) {
   if (!h) {
-    fprintf(stderr,
-            "ERROR: `http_upgrade2ws` requires a valid `http_s` handle.");
+    FIO_LOG_ERROR("`http_upgrade2ws` requires a valid `http_s` handle.");
     goto error;
   }
   if (HTTP_INVALID_HANDLE(h))
@@ -824,7 +819,7 @@ static void http_on_upgrade_fallback(http_s *h, char *p, size_t i) {
 }
 static void http_on_response_fallback(http_s *h) { http_send_error(h, 400); }
 
-http_settings_s *http_settings_new(http_settings_s arg_settings) {
+static http_settings_s *http_settings_new(http_settings_s arg_settings) {
   /* TODO: improve locality by unifying malloc to a single call */
   if (!arg_settings.on_request)
     arg_settings.on_request = http_on_request_fallback;
@@ -891,7 +886,7 @@ static void http_on_open(intptr_t uuid, void *set) {
   fio_timeout_set(uuid, ((http_settings_s *)set)->timeout);
   if (fio_uuid2fd(uuid) >= ((http_settings_s *)set)->max_clients) {
     if (!at_capa)
-      fprintf(stderr, "WARNING: HTTP server at capacity\n");
+      FIO_LOG_WARNING("HTTP server at capacity");
     at_capa = 1;
     http_send_error2(uuid, 503, set);
     fio_close(uuid);
@@ -923,10 +918,9 @@ static void http_on_finish(intptr_t uuid, void *set) {
 #undef http_listen
 intptr_t http_listen(const char *port, const char *binding,
                      struct http_settings_s arg_settings) {
-  http_lib_init();
   if (arg_settings.on_request == NULL) {
-    fprintf(stderr, "ERROR: http_listen requires the .on_request parameter "
-                    "to be set\n");
+    FIO_LOG_ERROR("http_listen requires the .on_request parameter "
+                  "to be set\n");
     kill(0, SIGINT);
     exit(11);
   }
@@ -1025,19 +1019,18 @@ static void http_on_client_failed(intptr_t uuid, void *set_) {
 intptr_t http_connect(const char *address,
                       struct http_settings_s arg_settings) {
   if (!arg_settings.on_response && !arg_settings.on_upgrade) {
-    fprintf(stderr, "ERROR: http_connect requires either an on_response "
-                    " or an on_upgrade callback.\n");
+    FIO_LOG_ERROR("http_connect requires either an on_response "
+                  " or an on_upgrade callback.\n");
     errno = EINVAL;
     goto on_error;
   }
-  http_lib_init();
   size_t len;
   char *a, *p;
   uint8_t is_websocket = 0;
   uint8_t is_secure = 0;
   FIOBJ path = FIOBJ_INVALID;
   if (!address || (len = strlen(address)) <= 5) {
-    fprintf(stderr, "ERROR: http_connect requires a valid address.\n");
+    FIO_LOG_ERROR("http_connect requires a valid address.");
     errno = EINVAL;
     goto on_error;
   }
@@ -1050,7 +1043,7 @@ intptr_t http_connect(const char *address,
     address += 4;
     len -= 4;
   } else {
-    fprintf(stderr, "ERROR: http_connect requires a valid address.\n");
+    FIO_LOG_ERROR("http_connect requires a valid address.");
     errno = EINVAL;
     goto on_error;
   }
@@ -1058,22 +1051,18 @@ intptr_t http_connect(const char *address,
   if (address[0] == 's') {
     /* TODO: SSL/TLS */
     is_secure = 1;
-    fprintf(stderr, "ERROR: http_connect doesn't support TLS/SSL "
-                    "just yet.\n");
+    FIO_LOG_ERROR("http_connect doesn't support TLS/SSL just yet.");
     errno = EINVAL;
     goto on_error;
   } else if (len <= 3 || strncmp(address, "://", 3)) {
-    fprintf(stderr, "ERROR: http_connect requires a valid address.\n");
+    FIO_LOG_ERROR("http_connect requires a valid address.");
     errno = EINVAL;
     goto on_error;
   } else {
     len -= 3;
     address += 3;
     a = fio_malloc(len + 1);
-    if (!a) {
-      perror("FATAL ERROR: http_connect couldn't allocate memory "
-             "for address parsing");
-    }
+    FIO_ASSERT_ALLOC(a);
     memcpy(a, address, len + 1);
   }
   p = memchr(a, '/', len);
@@ -1113,7 +1102,7 @@ intptr_t http_connect(const char *address,
   if (!arg_settings.timeout)
     settings->timeout = 0; /* allow server to dictate timeout */
   http_s *h = fio_malloc(sizeof(*h));
-  HTTP_ASSERT(h, "HTTP Client handler allocation failed");
+  FIO_ASSERT(h, "HTTP Client handler allocation failed");
   http_s_new(h, 0, http1_vtable());
   h->udata = arg_settings.udata;
   h->status = 0;
@@ -1152,8 +1141,8 @@ static void on_websocket_http_connected(http_s *h) {
   websocket_settings_s *s = h->udata;
   h->udata = http_settings(h)->udata = NULL;
   if (!h->path) {
-    fprintf(stderr, "WARNING: (websocket client) path not specified in "
-                    "address, assuming root!\n");
+    FIO_LOG_WARNING("(websocket client) path not specified in "
+                    "address, assuming root!");
     h->path = fiobj_str_new("/", 1);
   }
   http_upgrade2ws(h, *s);
@@ -1520,8 +1509,7 @@ void http_parse_cookies(http_s *h, uint8_t is_url_encoded) {
   if (!h->headers)
     return;
   if (h->cookies && fiobj_hash_count(h->cookies)) {
-    fprintf(stderr,
-            "WARNING: (http) attempting to parse cookies more than once.\n");
+    FIO_LOG_WARNING("(http) attempting to parse cookies more than once.");
     return;
   }
   static uint64_t setcookie_header_hash;
@@ -1813,7 +1801,6 @@ static void http_mime_parser_on_data(http_mime_parser_s *parser, void *name,
   fiobj_str_resize(n, name_len);
   fiobj_str_write(n, "[name]", 6);
   tmp = fiobj_obj2cstr(n);
-  fprintf(stderr, "filename length %zu\n", filename_len);
   http_add2hash(http_mime_parser2fio(parser)->h->params, tmp.data, tmp.len,
                 filename, filename_len, 0);
   fiobj_free(n);
@@ -2634,29 +2621,37 @@ parse_path:
 /* *****************************************************************************
 Lookup Tables / functions
 ***************************************************************************** */
-#include <fio_hashmap.h>
 
-static fio_hash_s mime_types;
+static FIOBJ tmp_cpy_obj(FIOBJ o) { return fiobj_dup(o); }
 
-#define LONGEST_FILE_EXTENSION_LENGTH 15
+#define FIO_SET_NAME fio_mime_set
+#define FIO_SET_OBJ_TYPE FIOBJ
+#define FIO_SET_OBJ_COMPARE(o1, o2) (1)
+#define FIO_SET_OBJ_COPY(dest, o) (dest) = tmp_cpy_obj((o))
+#define FIO_SET_OBJ_DESTROY(o) fiobj_free((o))
+
+#include <fio.h>
 
-void http_lib_init(void); /* if library not initialized */
+static fio_mime_set_s mime_types = FIO_SET_INIT;
+
+#define LONGEST_FILE_EXTENSION_LENGTH 15
 
 /** Registers a Mime-Type to be associated with the file extension. */
 void http_mimetype_register(char *file_ext, size_t file_ext_len,
                             FIOBJ mime_type_str) {
-  if (!mime_types.map)
-    fio_hash_new(&mime_types);
   uintptr_t hash = fio_siphash(file_ext, file_ext_len);
-  FIOBJ old = (FIOBJ)fio_hash_insert(&mime_types, hash, (void *)mime_type_str);
-#if DEBUG
-  if (old) {
-    fprintf(stderr, "WARNING: mime-type collision: %.*s was %s, now %s\n",
-            (int)file_ext_len, file_ext, fiobj_obj2cstr(old).data,
-            fiobj_obj2cstr(mime_type_str).data);
+  if (mime_type_str == FIOBJ_INVALID) {
+    fio_mime_set_remove(&mime_types, hash, FIOBJ_INVALID);
+  } else {
+    FIOBJ old = FIOBJ_INVALID;
+    fio_mime_set_replace(&mime_types, hash, mime_type_str, &old);
+    if (old != FIOBJ_INVALID) {
+      FIO_LOG_WARNING("mime-type collision: %.*s was %s, now %s",
+                      (int)file_ext_len, file_ext, fiobj_obj2cstr(old).data,
+                      fiobj_obj2cstr(mime_type_str).data);
+      fiobj_free(old);
+    }
   }
-#endif
-  fiobj_free(old);
 }
 
 /**
@@ -2664,11 +2659,11 @@ void http_mimetype_register(char *file_ext, size_t file_ext_len,
  *  Remember to call `fiobj_free`.
  */
 FIOBJ http_mimetype_find(char *file_ext, size_t file_ext_len) {
-  if (!mime_types.map) {
-    http_lib_init();
-  }
   uintptr_t hash = fio_siphash(file_ext, file_ext_len);
-  return fiobj_dup((FIOBJ)fio_hash_find(&mime_types, hash));
+  FIOBJ *result = fio_mime_set_find(&mime_types, hash, FIOBJ_INVALID);
+  if (result)
+    return fiobj_dup(*result);
+  return FIOBJ_INVALID;
 }
 
 /**
@@ -2709,19 +2704,12 @@ finish:
   return mimetype;
 }
 
-/** Clears the Mime-Type registry (it will be emoty afterthis call). */
+/** Clears the Mime-Type registry (it will be empty afterthis call). */
 void http_mimetype_clear(void) {
-  if (!mime_types.map)
-    return;
-  /* rotate data and reinitialize state */
-  fio_hash_s old = mime_types;
-  mime_types = (fio_hash_s)FIO_HASH_INIT;
-  FIOBJ old_date = current_date;
+  fio_mime_set_free(&mime_types);
+  fiobj_free(current_date);
   current_date = FIOBJ_INVALID;
   last_date_added = 0;
-  /* free ols memory / objects */
-  FIO_HASH_FOR_FREE(&old, obj) { fiobj_free((FIOBJ)obj->obj); }
-  fiobj_free(old_date);
 }
 
 /**
@@ -2849,11 +2837,8 @@ fio_str_info_s http_status2str(uintptr_t status) {
 #if DEBUG
 void http_tests(void) {
   fprintf(stderr, "=== Testing HTTP helpers\n");
-#define TEST_ASSERT(cond, ...)                                                 \
-  if (!(cond)) {                                                               \
-    fprintf(stderr, "* " __VA_ARGS__);                                         \
-    fprintf(stderr, "Testing failed.\n");                                      \
-    exit(-1);                                                                  \
-  }
+  FIOBJ html_mime = http_mimetype_find("html", 4);
+  FIO_ASSERT(html_mime,
+             "HTML mime-type not found! Mime-Type registry invalid!\n");
 }
 #endif

data/ext/iodine/http1.c

@@ -248,7 +248,7 @@ static int http1_push_file(http_s *h, FIOBJ filename, FIOBJ mime_type) {
 /**
  * Called befor a pause task,
  */
-void http1_on_pause(http_s *h, http_fio_protocol_s *pr) {
+static void http1_on_pause(http_s *h, http_fio_protocol_s *pr) {
   ((http1pr_s *)pr)->stop = 1;
   fio_suspend(pr->uuid);
   (void)h;
@@ -257,14 +257,14 @@ void http1_on_pause(http_s *h, http_fio_protocol_s *pr) {
 /**
  * called after the resume task had completed.
  */
-void http1_on_resume(http_s *h, http_fio_protocol_s *pr) {
+static void http1_on_resume(http_s *h, http_fio_protocol_s *pr) {
   if (!((http1pr_s *)pr)->stop) {
     fio_force_event(pr->uuid, FIO_EVENT_ON_DATA);
   }
   (void)h;
 }
 
-intptr_t http1_hijack(http_s *h, fio_str_info_s *leftover) {
+static intptr_t http1_hijack(http_s *h, fio_str_info_s *leftover) {
   if (leftover) {
     intptr_t len =
         handle2pr(h)->buf_len -
@@ -610,10 +610,9 @@ static int http1_on_header(http1_parser_s *parser, char *name, size_t name_len,
   FIOBJ sym;
   FIOBJ obj;
   if (!http1_pr2handle(parser2http(parser)).headers) {
-    fprintf(stderr,
-            "ERROR: (http1 parse ordering error) missing HashMap for header "
-            "%s: %s\n",
-            name, data);
+    FIO_LOG_ERROR("(http1 parse ordering error) missing HashMap for header "
+                  "%s: %s",
+                  name, data);
     http_send_error2(500, parser2http(parser)->p.uuid,
                      parser2http(parser)->p.settings);
     return -1;
@@ -624,8 +623,7 @@ static int http1_on_header(http1_parser_s *parser, char *name, size_t name_len,
       fiobj_hash_count(http1_pr2handle(parser2http(parser)).headers) >
           HTTP_MAX_HEADER_COUNT) {
     if (parser2http(parser)->p.settings->log) {
-      fprintf(stderr,
-              "WARNING: (http security alert) header flood detected.\n");
+      FIO_LOG_WARNING("(HTTP) security alert - header flood detected.");
     }
     http_send_error(&http1_pr2handle(parser2http(parser)), 413);
     return -1;
@@ -745,8 +743,7 @@ static void http1_on_data_first_time(intptr_t uuid, fio_protocol_s *protocol) {
   /* ensure future reads skip this first time HTTP/2.0 test */
   p->p.protocol.on_data = http1_on_data;
   if (i >= 24 && !memcmp(p->buf, "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n", 24)) {
-    fprintf(stderr,
-            "ERROR: unsupported HTTP/2 attempeted using prior knowledge.\n");
+    FIO_LOG_ERROR("unsupported HTTP/2 attempeted using prior knowledge.");
     fio_close(uuid);
     return;
   }
@@ -767,7 +764,7 @@ fio_protocol_s *http1_new(uintptr_t uuid, http_settings_s *settings,
   if (unread_data && unread_length > HTTP_MAX_HEADER_LENGTH)
     return NULL;
   http1pr_s *p = malloc(sizeof(*p) + HTTP_MAX_HEADER_LENGTH);
-  HTTP_ASSERT(p, "HTTP/1.1 protocol allocation failed");
+  FIO_ASSERT_ALLOC(p);
   *p = (http1pr_s){
       .p.protocol =
           {

data/ext/iodine/http_internal.c

@@ -27,8 +27,10 @@ void http_on_request_handler______internal(http_s *h,
   if (1) {
     /* test for Host header and avoid duplicates */
     FIOBJ tmp = fiobj_hash_get2(h->headers, host_hash);
-    if (!tmp)
+    if (!tmp) {
       http_send_error(h, 400);
+      return;
+    }
     if (FIOBJ_TYPE_IS(tmp, FIOBJ_T_ARRAY)) {
       fiobj_hash_set(h->headers, HTTP_HEADER_HOST, fiobj_ary_pop(tmp));
     }
@@ -94,7 +96,7 @@ int http_send_error2(size_t error, intptr_t uuid, http_settings_s *settings) {
     return -1;
   fio_protocol_s *pr = http1_new(uuid, settings, NULL, 0);
   http_s *r = fio_malloc(sizeof(*r));
-  HTTP_ASSERT(pr, "Couldn't allocate response object for error report.")
+  FIO_ASSERT(pr, "Couldn't allocate response object for error report.")
   http_s_new(r, (http_fio_protocol_s *)pr, http1_vtable());
   int ret = http_send_error(r, error);
   fio_close(uuid);
@@ -136,8 +138,15 @@ FIOBJ HTTP_HVALUE_WS_UPGRADE;
 FIOBJ HTTP_HVALUE_WS_VERSION;
 FIOBJ HTTP_HVALUE_SSE_MIME;
 
-static void http_lib_cleanup(void *ignr) {
-  (void)ignr;
+static void http_lib_init(void *ignr_);
+static void http_lib_cleanup(void *ignr_);
+static __attribute__((constructor)) void http_lib_constructor(void) {
+  fio_state_callback_add(FIO_CALL_ON_INITIALIZE, http_lib_init, NULL);
+  fio_state_callback_add(FIO_CALL_AT_EXIT, http_lib_cleanup, NULL);
+}
+
+static void http_lib_cleanup(void *ignr_) {
+  (void)ignr_;
   http_mimetype_clear();
 #define HTTPLIB_RESET(x)                                                       \
   fiobj_free(x);                                                               \
@@ -176,10 +185,10 @@ static void http_lib_cleanup(void *ignr) {
 #undef HTTPLIB_RESET
 }
 
-void http_lib_init(void) {
+static void http_lib_init(void *ignr_) {
+  (void)ignr_;
   if (HTTP_HEADER_ACCEPT_RANGES)
     return;
-  fio_state_callback_add(FIO_CALL_AT_EXIT, http_lib_cleanup, NULL);
   HTTP_HEADER_ACCEPT = fiobj_str_new("accept", 6);
   HTTP_HEADER_ACCEPT_RANGES = fiobj_str_new("accept-ranges", 13);
   HTTP_HEADER_CACHE_CONTROL = fiobj_str_new("cache-control", 13);

data/ext/iodine/http_internal.h

@@ -17,10 +17,6 @@ Feel free to copy, use and enjoy according to the license provided.
 #include <arpa/inet.h>
 #include <errno.h>
 
-/* *****************************************************************************
-Library initialization
-***************************************************************************** */
-void http_lib_init(void);
 /* *****************************************************************************
 Types
 ***************************************************************************** */
@@ -197,10 +193,6 @@ static inline void http_sse_destroy(http_sse_internal_s *sse) {
 Helpers
 ***************************************************************************** */
 
-#define HTTP_ASSERT(x, m)                                                      \
-  if (!x)                                                                      \
-    perror("FATAL ERROR: (http)" m), exit(errno);
-
 /** sets an outgoing header only if it doesn't exist */
 static inline void set_header_if_missing(FIOBJ hash, FIOBJ name, FIOBJ value) {
   FIOBJ old = fiobj_hash_replace(hash, name, value);