iodine 0.3.6 → 0.4.0

data/ext/iodine/fio_list.h

@@ -24,6 +24,9 @@ static inline __attribute__((unused)) void fio_list_init(fio_list_s *list) {
 /** A macro that evaluates to an initialized list head. */
 #define FIO_LIST_INIT(name)                                                    \
   (fio_list_s) { .next = &(name), .prev = &(name) }
+/** A macro that evaluates to an initialized list head. */
+#define FIO_LIST_INIT_STATIC(name)                                             \
+  { .next = &(name), .prev = &(name) }
 
 /** Adds a list reference to the list at the specified position. */
 static inline __attribute__((unused)) void fio_list_add(fio_list_s *pos,
@@ -44,15 +47,39 @@ fio_list_remove(fio_list_s *item) {
   *item = (fio_list_s){.next = item, .prev = item};
   return item;
 }
+/** Switches two list items. */
+static inline __attribute__((unused)) void fio_list_switch(fio_list_s *item1,
+                                                           fio_list_s *item2) {
+  if (item1 == item2)
+    return;
+  fio_list_s tmp = *item1;
+  *item1 = *item2;
+  *item2 = tmp;
+  if (item1->next == item2)
+    item1->next = item1;
+  else
+    item1->next->prev = item1;
+  if (item1->prev == item2)
+    item1->prev = item1;
+  else
+    item1->prev->next = item1;
+}
+
+#ifndef fio_node2obj
+/** Takes a node pointer (list/hash/dict, etc') and returns it's container. */
+#define fio_node2obj(type, member, ptr)                                        \
+  ((type *)((uintptr_t)(ptr) - (uintptr_t)(&(((type *)0)->member))))
+#endif
 
 /** Takes a list pointer and returns a pointer to it's container. */
-#define fio_list_object(type, member, plist)                                   \
-  ((type *)((uintptr_t)(plist) - (uintptr_t)(&(((type *)0)->member))))
+#define fio_list_object(type, member, plist) fio_node2obj(type, member, (plist))
 
 /** iterates the whole list. */
 #define fio_list_for_each(type, member, var, head)                             \
   for (fio_list_s *pos = (head).next->next;                                    \
-       &((var) = fio_list_object(type, member, pos->prev))->member != &(head); \
+       (&((var) = fio_list_object(type, member, pos->prev))->member !=         \
+        &(head)) ||                                                            \
+       ((var) = NULL);                                                         \
        (var) = fio_list_object(type, member, pos), pos = pos->next)
 
 /** Removes a member from the end of the list. */

data/ext/iodine/http.c

@@ -32,14 +32,19 @@ http_on_finish_func http_get_on_finish_func(http_settings_s *settings) {
   return (http_on_finish_func)route[settings->version];
 }
 
-void http_on_finish(void *set) {
+void http_on_finish(intptr_t uuid, void *set) {
   http_settings_s *settings = set;
   if (http_get_on_finish_func(set))
     http_get_on_finish_func(set)(set);
-  if (settings->private_metaflags & 1)
+
+  if (settings->on_finish)
+    settings->on_finish(uuid, settings->udata);
+
+  if (settings->private_metaflags & 2) {
     free((void *)settings->public_folder);
-  if (settings->private_metaflags & 2)
     free(settings);
+  }
+  (void)uuid;
 }
 
 /**
@@ -83,14 +88,19 @@ int http_listen(const char *port, const char *address,
       memcpy(tmp + home_len, settings->public_folder + 1,
              settings->public_folder_length); // copy also the NULL
       settings->public_folder = tmp;
-      settings->private_metaflags |= 1;
       settings->public_folder_length = strlen(settings->public_folder);
+    } else {
+      settings->public_folder = malloc(settings->public_folder_length + 1);
+      memcpy((void *)settings->public_folder, arg_settings.public_folder,
+             settings->public_folder_length);
+      ((uint8_t *)settings->public_folder)[settings->public_folder_length] = 0;
     }
   }
 
   return facil_listen(.port = port, .address = address,
                       .set_rw_hooks = arg_settings.set_rw_hooks,
                       .rw_udata = arg_settings.rw_udata,
+                      .on_finish_rw = arg_settings.on_finish_rw,
                       .on_finish = http_on_finish, .on_open = on_open_callback,
                       .udata = settings);
 }
@@ -117,7 +127,7 @@ struct tm *http_gmtime(const time_t *timer, struct tm *tmbuf) {
   };
   if (*timer < 0)
     return gmtime_r(timer, tmbuf);
-  ssize_t tmp;
+  ssize_t a, b;
   tmbuf->tm_gmtoff = 0;
   tmbuf->tm_zone = "UTC";
   tmbuf->tm_isdst = 0;
@@ -125,82 +135,83 @@ struct tm *http_gmtime(const time_t *timer, struct tm *tmbuf) {
   tmbuf->tm_mon = 0;
   // for seconds up to weekdays, we build up, as small values clean up larger
   // values.
-  tmp = ((ssize_t)*timer);
-  tmbuf->tm_sec = tmp % 60;
-  tmp = tmp / 60;
-  tmbuf->tm_min = tmp % 60;
-  tmp = tmp / 60;
-  tmbuf->tm_hour = tmp % 24;
-  tmp = tmp / 24;
-  // day of epoch was a thursday. Add + 3 so sunday == 0...
-  tmbuf->tm_wday = (tmp + 3) % 7;
+  a = ((ssize_t)*timer);
+  b = a / 60;
+  tmbuf->tm_sec = a - (b * 60);
+  a = b / 60;
+  tmbuf->tm_min = b - (a * 60);
+  b = a / 24;
+  tmbuf->tm_hour = a - (b * 24);
+  // day of epoch was a thursday. Add + 4 so sunday == 0...
+  tmbuf->tm_wday = (b + 4) % 7;
 // tmp == number of days since epoch
 #define DAYS_PER_400_YEARS ((400 * 365) + 97)
-  while (tmp >= DAYS_PER_400_YEARS) {
+  while (b >= DAYS_PER_400_YEARS) {
     tmbuf->tm_year += 400;
-    tmp -= DAYS_PER_400_YEARS;
+    b -= DAYS_PER_400_YEARS;
   }
 #undef DAYS_PER_400_YEARS
 #define DAYS_PER_100_YEARS ((100 * 365) + 24)
-  while (tmp >= DAYS_PER_100_YEARS) {
+  while (b >= DAYS_PER_100_YEARS) {
     tmbuf->tm_year += 100;
-    tmp -= DAYS_PER_100_YEARS;
+    b -= DAYS_PER_100_YEARS;
     if (((tmbuf->tm_year / 100) & 3) ==
         0) // leap century divisable by 400 => add leap
-      --tmp;
+      --b;
   }
 #undef DAYS_PER_100_YEARS
 #define DAYS_PER_32_YEARS ((32 * 365) + 8)
-  while (tmp >= DAYS_PER_32_YEARS) {
+  while (b >= DAYS_PER_32_YEARS) {
     tmbuf->tm_year += 32;
-    tmp -= DAYS_PER_32_YEARS;
+    b -= DAYS_PER_32_YEARS;
   }
 #undef DAYS_PER_32_YEARS
 #define DAYS_PER_8_YEARS ((8 * 365) + 2)
-  while (tmp >= DAYS_PER_8_YEARS) {
+  while (b >= DAYS_PER_8_YEARS) {
     tmbuf->tm_year += 8;
-    tmp -= DAYS_PER_8_YEARS;
+    b -= DAYS_PER_8_YEARS;
   }
 #undef DAYS_PER_8_YEARS
 #define DAYS_PER_4_YEARS ((4 * 365) + 1)
-  while (tmp >= DAYS_PER_4_YEARS) {
+  while (b >= DAYS_PER_4_YEARS) {
     tmbuf->tm_year += 4;
-    tmp -= DAYS_PER_4_YEARS;
+    b -= DAYS_PER_4_YEARS;
   }
 #undef DAYS_PER_4_YEARS
-  while (tmp >= 365) {
+  while (b >= 365) {
     tmbuf->tm_year += 1;
-    tmp -= 365;
+    b -= 365;
     if ((tmbuf->tm_year & 3) == 0) { // leap year
-      if (tmp > 0) {
-        --tmp;
+      if (b > 0) {
+        --b;
         continue;
       } else {
-        tmp += 365;
+        b += 365;
         --tmbuf->tm_year;
         break;
       }
     }
   }
-  tmbuf->tm_yday = tmp;
+  b++; /* day 1 of the year is 1, not 0. */
+  tmbuf->tm_yday = b;
   if ((tmbuf->tm_year & 3) == 1) {
     // regular year
     for (size_t i = 0; i < 12; i++) {
-      if (tmp < month_len[i])
+      if (b <= month_len[i])
         break;
-      tmp -= month_len[i];
+      b -= month_len[i];
       ++tmbuf->tm_mon;
     }
   } else {
     // leap year
     for (size_t i = 12; i < 24; i++) {
-      if (tmp < month_len[i])
+      if (b <= month_len[i])
         break;
-      tmp -= month_len[i];
+      b -= month_len[i];
       ++tmbuf->tm_mon;
     }
   }
-  tmbuf->tm_mday = tmp;
+  tmbuf->tm_mday = b;
   return tmbuf;
 }
 
@@ -249,6 +260,91 @@ size_t http_date2str(char *target, struct tm *tmbuf) {
   return pos - target;
 }
 
+size_t http_date2rfc2822(char *target, struct tm *tmbuf) {
+  char *pos = target;
+  uint16_t tmp;
+  *(uint32_t *)pos = *((uint32_t *)DAY_NAMES[tmbuf->tm_wday]);
+  pos[3] = ',';
+  pos[4] = ' ';
+  pos += 5;
+  if (tmbuf->tm_mday < 10) {
+    *pos = '0' + tmbuf->tm_mday;
+    ++pos;
+  } else {
+    tmp = tmbuf->tm_mday / 10;
+    pos[0] = '0' + tmp;
+    pos[1] = '0' + (tmbuf->tm_mday - (tmp * 10));
+    pos += 2;
+  }
+  *(pos++) = '-';
+  *(uint32_t *)pos = *((uint32_t *)MONTH_NAMES[tmbuf->tm_mon]);
+  pos += 3;
+  *(pos++) = '-';
+  // write year.
+  pos += http_ul2a(pos, tmbuf->tm_year + 1900);
+  *(pos++) = ' ';
+  tmp = tmbuf->tm_hour / 10;
+  pos[0] = '0' + tmp;
+  pos[1] = '0' + (tmbuf->tm_hour - (tmp * 10));
+  pos[2] = ':';
+  tmp = tmbuf->tm_min / 10;
+  pos[3] = '0' + tmp;
+  pos[4] = '0' + (tmbuf->tm_min - (tmp * 10));
+  pos[5] = ':';
+  tmp = tmbuf->tm_sec / 10;
+  pos[6] = '0' + tmp;
+  pos[7] = '0' + (tmbuf->tm_sec - (tmp * 10));
+  pos += 8;
+  pos[0] = ' ';
+  *((uint32_t *)(pos + 1)) = *((uint32_t *)GMT_STR);
+  pos += 4;
+  return pos - target;
+}
+
+size_t http_date2rfc2109(char *target, struct tm *tmbuf) {
+  char *pos = target;
+  uint16_t tmp;
+  *(uint32_t *)pos = *((uint32_t *)DAY_NAMES[tmbuf->tm_wday]);
+  pos[3] = ',';
+  pos[4] = ' ';
+  pos += 5;
+  if (tmbuf->tm_mday < 10) {
+    *pos = '0' + tmbuf->tm_mday;
+    ++pos;
+  } else {
+    tmp = tmbuf->tm_mday / 10;
+    pos[0] = '0' + tmp;
+    pos[1] = '0' + (tmbuf->tm_mday - (tmp * 10));
+    pos += 2;
+  }
+  *(pos++) = ' ';
+  *(uint32_t *)pos = *((uint32_t *)MONTH_NAMES[tmbuf->tm_mon]);
+  pos += 4;
+  // write year.
+  pos += http_ul2a(pos, tmbuf->tm_year + 1900);
+  *(pos++) = ' ';
+  tmp = tmbuf->tm_hour / 10;
+  pos[0] = '0' + tmp;
+  pos[1] = '0' + (tmbuf->tm_hour - (tmp * 10));
+  pos[2] = ':';
+  tmp = tmbuf->tm_min / 10;
+  pos[3] = '0' + tmp;
+  pos[4] = '0' + (tmbuf->tm_min - (tmp * 10));
+  pos[5] = ':';
+  tmp = tmbuf->tm_sec / 10;
+  pos[6] = '0' + tmp;
+  pos[7] = '0' + (tmbuf->tm_sec - (tmp * 10));
+  pos += 8;
+  *pos++ = ' ';
+  *pos++ = '-';
+  *pos++ = '0';
+  *pos++ = '0';
+  *pos++ = '0';
+  *pos++ = '0';
+  *pos = 0;
+  return pos - target;
+}
+
 /* Credit to Jonathan Leffler for the idea of a unified conditional */
 #define hex_val(c)                                                             \
   (((c) >= '0' && (c) <= '9')                                                  \
@@ -277,7 +373,7 @@ static inline int hex2byte(uint8_t *dest, const uint8_t *source) {
     return -1;
   return 0;
 }
-#undef hex_val_tmp
+
 ssize_t http_decode_url(char *dest, const char *url_data, size_t length) {
   char *pos = dest;
   const char *end = url_data + length;
@@ -320,4 +416,40 @@ ssize_t http_decode_url_unsafe(char *dest, const char *url_data) {
   *pos = 0;
   return pos - dest;
 }
+
+ssize_t http_decode_path(char *dest, const char *url_data, size_t length) {
+  char *pos = dest;
+  const char *end = url_data + length;
+  while (url_data < end) {
+    if (*url_data == '%') {
+      // decode hex value
+      // this is a percent encoded value.
+      if (hex2byte((uint8_t *)pos, (uint8_t *)&url_data[1]))
+        return -1;
+      pos++;
+      url_data += 3;
+    } else
+      *(pos++) = *(url_data++);
+  }
+  *pos = 0;
+  return pos - dest;
+}
+
+ssize_t http_decode_path_unsafe(char *dest, const char *url_data) {
+  char *pos = dest;
+  while (*url_data) {
+    if (*url_data == '%') {
+      // decode hex value
+      // this is a percent encoded value.
+      if (hex2byte((uint8_t *)pos, (uint8_t *)&url_data[1]))
+        return -1;
+      pos++;
+      url_data += 3;
+    } else
+      *(pos++) = *(url_data++);
+  }
+  *pos = 0;
+  return pos - dest;
+}
+
 #undef hex_val

data/ext/iodine/http.h

@@ -28,6 +28,9 @@ typedef struct {
   };
 } http_header_s;
 
+/** Settings typedef */
+typedef struct http_settings_s http_settings_s;
+
 /* *****************************************************************************
 Core include files
 */
@@ -56,14 +59,14 @@ HTTP Core API & data structure
 */
 
 /** Manages protocol settings for the HTTP protocol */
-typedef struct {
+struct http_settings_s {
   /**
   The maximum size of an HTTP request's body (when posting data).
 
   Defaults to ~ 50Mb.
   */
   size_t max_body_size;
-  /** the callback to be performed when requests come in. */
+  /** REQUIRED: the callback to be performed when requests come in. */
   void (*on_request)(http_request_s *request);
   /**
   A public folder for file transfers - allows to circumvent any application
@@ -74,20 +77,28 @@ typedef struct {
   The length of the public_folder string.
   */
   size_t public_folder_length;
-  /** (optional)
+  /** Opaque user data. */
+  void *udata;
+  /** Opaque user data for the optional `set_rw_hooks`. */
+  void *rw_udata;
+  /** (optional) the callback to be performed when the HTTP service closes. */
+  void (*on_finish)(intptr_t uuid, void *udata);
+  /**
    * 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;
+  /**
+   * A cleanup callback for the `rw_udata`.
+   */
+  void (*on_finish_rw)(intptr_t uuid, void *rw_udata);
   /**
   Logging flag - set to TRUE to log static file requests.
 
   Dynamic request logging is always the dynamic application's responsibility.
   */
   uint8_t log_static;
-  /** An HTTP connection timeout. For HTTP/1.1 this defaults to ~5 seconds.*/
+  /** An HTTP/1.x connection timeout. Defaults to ~5 seconds.*/
   uint8_t timeout;
   /**
   The default HTTP version which a new connection will use. At the moment, only
@@ -98,7 +109,7 @@ typedef struct {
   internal flag for library use.
   */
   uint8_t private_metaflags;
-} http_settings_s;
+};
 
 typedef protocol_s *(*http_on_open_func)(intptr_t, void *);
 typedef void (*http_on_finish_func)(void *);
@@ -139,11 +150,16 @@ struct tm *http_gmtime(const time_t *timer, struct tm *tmbuf);
 /**
 Writes an HTTP date string to the `target` buffer.
 
-This requires _____ bytes of space to be available at the target buffer.
+This requires ~32 bytes of space to be available at the target buffer (unless
+it's a super funky year, 32 bytes is about 3 more than you need).
 
 Returns the number of bytes actually written.
 */
 size_t http_date2str(char *target, struct tm *tmbuf);
+/** An alternative, RFC 2109 date representation. Requires */
+size_t http_date2rfc2109(char *target, struct tm *tmbuf);
+/** An alternative, RFC 2822 date representation. */
+size_t http_date2rfc2822(char *target, struct tm *tmbuf);
 
 /**
 A fast, inline alternative to `sprintf(dest, "%lu", num)`.
@@ -155,7 +171,7 @@ A NULL terminating byte is written.
 
 Returns the number of bytes actually written (excluding the NULL byte).
 */
-inline size_t http_ul2a(char *dest, size_t num) {
+static inline size_t http_ul2a(char *dest, size_t num) {
   uint8_t digits = 1;
   size_t tmp = num;
   while ((tmp /= 10))
@@ -174,7 +190,14 @@ inline size_t http_ul2a(char *dest, size_t num) {
 /** Decodes a URL encoded string, no buffer overflow protection. */
 ssize_t http_decode_url_unsafe(char *dest, const char *url_data);
 
-/** Decodes a URL encoded string. */
+/** Decodes a URL encoded string (i.e., the "query" part of a request). */
 ssize_t http_decode_url(char *dest, const char *url_data, size_t length);
 
+/** Decodes the "path" part of a request, no buffer overflow protection. */
+ssize_t http_decode_path_unsafe(char *dest, const char *url_data);
+
+/** Decodes the "path" part of an HTTP request, no buffer overflow protection.
+ */
+ssize_t http_decode_path(char *dest, const char *url_data, size_t length);
+
 #endif