iodine 0.4.19 → 0.5.0

data/ext/iodine/http_internal.h

@@ -0,0 +1,226 @@
+/*
+Copyright: Boaz Segev, 2016-2018
+License: MIT
+
+Feel free to copy, use and enjoy according to the license provided.
+*/
+#ifndef H_HTTP_INTERNAL_H
+#define H_HTTP_INTERNAL_H
+
+#include "spnlock.inc"
+
+#include "fio_llist.h"
+#include "http.h"
+#include "pubsub.h"
+
+#include "fiobj4sock.h"
+
+#include <arpa/inet.h>
+#include <errno.h>
+
+/* *****************************************************************************
+Types
+***************************************************************************** */
+
+typedef struct http_protocol_s http_protocol_s;
+typedef struct http_vtable_s http_vtable_s;
+
+struct http_vtable_s {
+  /** Should send existing headers and data */
+  int (*const http_send_body)(http_s *h, void *data, uintptr_t length);
+  /** Should send existing headers and file */
+  int (*const http_sendfile)(http_s *h, int fd, uintptr_t length,
+                             uintptr_t offset);
+  /** Should send existing headers and data and prepare for streaming */
+  int (*const http_stream)(http_s *h, void *data, uintptr_t length);
+  /** Should send existing headers or complete streaming */
+  void (*const http_finish)(http_s *h);
+  /** Push for data. */
+  int (*const http_push_data)(http_s *h, void *data, uintptr_t length,
+                              FIOBJ mime_type);
+  /** Upgrades a connection to Websockets. */
+  int (*const http2websocket)(websocket_settings_s *arg);
+  /** Push for files. */
+  int (*const http_push_file)(http_s *h, FIOBJ filename, FIOBJ mime_type);
+  /** Pauses the request / response handling. */
+  void (*http_on_pause)(http_s *, http_protocol_s *);
+
+  /** Resumes a request / response handling. */
+  void (*http_on_resume)(http_s *, http_protocol_s *);
+  /** hijacks the socket aaway from the protocol. */
+  intptr_t (*http_hijack)(http_s *h, fio_cstr_s *leftover);
+
+  /** Upgrades an HTTP connection to an EventSource (SSE) connection. */
+  int (*http_upgrade2sse)(http_s *h, http_sse_s *sse);
+  /** Writes data to an EventSource (SSE) connection. MUST free the FIOBJ. */
+  int (*http_sse_write)(http_sse_s *sse, FIOBJ str);
+  /** Closes an EventSource (SSE) connection. */
+  int (*http_sse_close)(http_sse_s *sse);
+};
+
+struct http_protocol_s {
+  protocol_s protocol;       /* facil.io protocol */
+  intptr_t uuid;             /* socket uuid */
+  http_settings_s *settings; /* pointer to HTTP settings */
+};
+
+#define http2protocol(h) ((http_protocol_s *)h->private_data.flag)
+
+/* *****************************************************************************
+Constants that shouldn't be accessed by the users (`fiobj_dup` required).
+***************************************************************************** */
+
+extern FIOBJ HTTP_HEADER_ACCEPT_RANGES;
+extern FIOBJ HTTP_HEADER_WS_SEC_CLIENT_KEY;
+extern FIOBJ HTTP_HEADER_WS_SEC_KEY;
+extern FIOBJ HTTP_HVALUE_BYTES;
+extern FIOBJ HTTP_HVALUE_CLOSE;
+extern FIOBJ HTTP_HVALUE_CONTENT_TYPE_DEFAULT;
+extern FIOBJ HTTP_HVALUE_GZIP;
+extern FIOBJ HTTP_HVALUE_KEEP_ALIVE;
+extern FIOBJ HTTP_HVALUE_MAX_AGE;
+extern FIOBJ HTTP_HVALUE_NO_CACHE;
+extern FIOBJ HTTP_HVALUE_SSE_MIME;
+extern FIOBJ HTTP_HVALUE_WEBSOCKET;
+extern FIOBJ HTTP_HVALUE_WS_SEC_VERSION;
+extern FIOBJ HTTP_HVALUE_WS_UPGRADE;
+extern FIOBJ HTTP_HVALUE_WS_VERSION;
+
+/* *****************************************************************************
+HTTP request/response object management
+***************************************************************************** */
+
+static inline void http_s_new(http_s *h, http_protocol_s *owner,
+                              http_vtable_s *vtbl) {
+  *h = (http_s){
+      .private_data =
+          {
+              .vtbl = vtbl,
+              .flag = (uintptr_t)owner,
+              .out_headers = fiobj_hash_new(),
+          },
+      .headers = fiobj_hash_new(),
+      .received_at = facil_last_tick(),
+      .status = 200,
+  };
+}
+
+static inline void http_s_destroy(http_s *h, uint8_t log) {
+  if (log && h->status && !h->status_str) {
+    http_write_log(h);
+  }
+  fiobj_free(h->method);
+  fiobj_free(h->status_str);
+  fiobj_free(h->private_data.out_headers);
+  fiobj_free(h->headers);
+  fiobj_free(h->version);
+  fiobj_free(h->query);
+  fiobj_free(h->path);
+  fiobj_free(h->cookies);
+  fiobj_free(h->body);
+  fiobj_free(h->params);
+
+  *h = (http_s){
+      .private_data.vtbl = h->private_data.vtbl,
+      .private_data.flag = h->private_data.flag,
+  };
+}
+
+static inline void http_s_clear(http_s *h, uint8_t log) {
+  http_s_destroy(h, log);
+  http_s_new(h, (http_protocol_s *)h->private_data.flag, h->private_data.vtbl);
+}
+
+/** tests handle validity */
+#define HTTP_INVALID_HANDLE(h)                                                 \
+  (!(h) || (!(h)->method && !(h)->status_str && (h)->status))
+
+/* *****************************************************************************
+Request / Response Handlers
+***************************************************************************** */
+
+/** Use this function to handle HTTP requests.*/
+void http_on_request_handler______internal(http_s *h,
+                                           http_settings_s *settings);
+
+void http_on_response_handler______internal(http_s *h,
+                                            http_settings_s *settings);
+int http_send_error2(size_t error, intptr_t uuid, http_settings_s *settings);
+
+/* *****************************************************************************
+EventSource Support (SSE)
+***************************************************************************** */
+
+typedef struct http_sse_internal_s {
+  http_sse_s sse;         /* the user SSE settings */
+  intptr_t uuid;          /* the socket's uuid */
+  http_vtable_s *vtable;  /* the protocol's vtable */
+  uintptr_t id;           /* the SSE identifier */
+  fio_ls_s subscriptions; /* Subscription List */
+  spn_lock_i lock;        /* Subscription List lock */
+  size_t ref;             /* reference count */
+} http_sse_internal_s;
+
+static inline void http_sse_init(http_sse_internal_s *sse, intptr_t uuid,
+                                 http_vtable_s *vtbl, http_sse_s *args) {
+  *sse = (http_sse_internal_s){
+      .sse = *args,
+      .uuid = uuid,
+      .subscriptions = FIO_LS_INIT(sse->subscriptions),
+      .vtable = vtbl,
+      .ref = 1,
+  };
+}
+
+static inline void http_sse_try_free(http_sse_internal_s *sse) {
+  if (spn_sub(&sse->ref, 1))
+    return;
+  free(sse);
+}
+
+static inline void http_sse_destroy(http_sse_internal_s *sse) {
+  while (fio_ls_any(&sse->subscriptions)) {
+    void *sub = fio_ls_pop(&sse->subscriptions);
+    pubsub_unsubscribe(sub);
+  }
+  sse->uuid = -1;
+  http_sse_try_free(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);
+  if (!old)
+    return;
+  fiobj_hash_replace(hash, name, old);
+  fiobj_free(value);
+}
+
+/** sets an outgoing header, collecting duplicates in an Array (i.e. cookies)
+ */
+static inline void set_header_add(FIOBJ hash, FIOBJ name, FIOBJ value) {
+  FIOBJ old = fiobj_hash_replace(hash, name, value);
+  if (!old)
+    return;
+  if (!value) {
+    fiobj_free(old);
+    return;
+  }
+  if (!FIOBJ_TYPE_IS(old, FIOBJ_T_ARRAY)) {
+    FIOBJ tmp = fiobj_ary_new();
+    fiobj_ary_push(tmp, old);
+    old = tmp;
+  }
+  fiobj_ary_push(old, value);
+  fiobj_hash_replace(hash, name, old);
+}
+
+#endif /* H_HTTP_INTERNAL_H */

data/ext/iodine/http_mime_parser.h

@@ -0,0 +1,341 @@
+/*
+Copyright: Boaz Segev, 2018
+License: MIT
+
+Feel free to copy, use and enjoy according to the license provided.
+*/
+#ifndef H_HTTP_MIME_PARSER_H
+#define H_HTTP_MIME_PARSER_H
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* *****************************************************************************
+The HTTP MIME Multipart Form Parser Type
+***************************************************************************** */
+
+/** all data id read-only / for internal use */
+typedef struct {
+  char *boundary;
+  size_t boundary_len;
+  uint8_t in_obj;
+  uint8_t done;
+  uint8_t error;
+} http_mime_parser_s;
+
+/* *****************************************************************************
+Callbacks to be implemented.
+***************************************************************************** */
+
+/** Called when all the data is available at once. */
+static void http_mime_parser_on_data(http_mime_parser_s *parser, void *name,
+                                     size_t name_len, void *filename,
+                                     size_t filename_len, void *mimetype,
+                                     size_t mimetype_len, void *value,
+                                     size_t value_len);
+
+/** Called when the data didn't fit in the buffer. Data will be streamed. */
+static void http_mime_parser_on_partial_start(
+    http_mime_parser_s *parser, void *name, size_t name_len, void *filename,
+    size_t filename_len, void *mimetype, size_t mimetype_len);
+
+/** Called when partial data is available. */
+static void http_mime_parser_on_partial_data(http_mime_parser_s *parser,
+                                             void *value, size_t value_len);
+
+/** Called when the partial data is complete. */
+static void http_mime_parser_on_partial_end(http_mime_parser_s *parser);
+
+/**
+ * Called when URL decoding is required.
+ *
+ * Should support inplace decoding (`dest == encoded`).
+ *
+ * Should return the length of the decoded string.
+ */
+static size_t http_mime_decode_url(char *dest, const char *encoded,
+                                   size_t length);
+
+/* *****************************************************************************
+API
+***************************************************************************** */
+
+/**
+ * Takes the HTTP Content-Type header and initializes the parser data.
+ *
+ * Note: the Content-Type header should persist in memory while the parser is in
+ * use.
+ */
+static int http_mime_parser_init(http_mime_parser_s *parser, char *content_type,
+                                 size_t len);
+
+/**
+ * Consumes data from a streaming buffer.
+ *
+ * The data might be partially consumed, in which case the unconsumed data
+ * should be resent to the parser as more data becomes available.
+ *
+ * Note: test the `parser->done` and `parser->error` flags between iterations.
+ */
+static size_t http_mime_parse(http_mime_parser_s *parser, void *buffer,
+                              size_t length);
+
+/* *****************************************************************************
+Implementations
+***************************************************************************** */
+
+/** takes the HTTP Content-Type header and initializes the parser data. */
+static int http_mime_parser_init(http_mime_parser_s *parser, char *content_type,
+                                 size_t len) {
+  *parser = (http_mime_parser_s){.done = 0};
+  if (len < 14 || strncasecmp("multipart/form", content_type, 14))
+    return -1;
+  char *cut = memchr(content_type, ';', len);
+  while (cut) {
+    ++cut;
+    len -= (size_t)(cut - content_type);
+    while (len && cut[0] == ' ') {
+      --len;
+      ++cut;
+    }
+    if (len <= 9)
+      return -1;
+    if (strncasecmp("boundary=", cut, 9)) {
+      content_type = cut;
+      cut = memchr(cut, ';', len);
+      continue;
+    }
+    cut += 9;
+    len -= 9;
+    content_type = cut;
+    parser->boundary = content_type;
+    if ((cut = memchr(content_type, ';', len)))
+      parser->boundary_len = (size_t)(cut - content_type);
+    else
+      parser->boundary_len = len;
+    return 0;
+  }
+  return -1;
+}
+
+/**
+ * Consumes data from a streaming buffer.
+ *
+ * The data might be partially consumed, in which case the unconsumed data
+ * should be resent to the parser as more data becomes available.
+ *
+ * Note: test the `parser->done` and `parser->error` flags between iterations.
+ */
+static size_t http_mime_parse(http_mime_parser_s *parser, void *buffer,
+                              size_t length) {
+  int first_run = 1;
+  char *pos = buffer;
+  const char *stop = pos + length;
+  if (!length)
+    goto end_of_data;
+consume_partial:
+  if (parser->in_obj) {
+    /* we're in an object longer than the buffer */
+    char *start = pos;
+    char *end = start;
+    do {
+      end = memchr(end, '\n', (size_t)(stop - end));
+    } while (end && ++end &&
+             (size_t)(stop - end) >= (4 + parser->boundary_len) &&
+             (end[0] != '-' || end[1] != '-' ||
+              memcmp(end + 2, parser->boundary, parser->boundary_len)));
+    if (!end) {
+      end = (char *)stop;
+      pos = end;
+      if (end - start)
+        http_mime_parser_on_partial_data(parser, start, (size_t)(end - start));
+      goto end_of_data;
+    } else if (end + 4 + parser->boundary_len >= stop) {
+      end -= 2;
+      if (end[0] == '\r')
+        --end;
+      pos = end;
+      if (end - start)
+        http_mime_parser_on_partial_data(parser, start, (size_t)(end - start));
+      goto end_of_data;
+    }
+    size_t len = (end - start) - 1;
+    if (start[len - 1] == '\r')
+      --len;
+    if (len)
+      http_mime_parser_on_partial_data(parser, start, len);
+    http_mime_parser_on_partial_end(parser);
+    pos = end;
+    parser->in_obj = 0;
+    first_run = 0;
+  } else if (length < (4 + parser->boundary_len) || pos[0] != '-' ||
+             pos[1] != '-' ||
+             memcmp(pos + 2, parser->boundary, parser->boundary_len))
+    goto error;
+  /* We're at a boundary */
+  while (pos < stop) {
+    char *start;
+    char *end;
+    char *name = NULL;
+    uint32_t name_len = 0;
+    char *value = NULL;
+    uint32_t value_len = 0;
+    char *filename = NULL;
+    uint32_t filename_len = 0;
+    char *mime = NULL;
+    uint32_t mime_len = 0;
+    uint8_t header_count = 0;
+    /* test for ending */
+    if (pos[2 + parser->boundary_len] == '-' &&
+        pos[3 + parser->boundary_len] == '-') {
+      pos += 5 + parser->boundary_len;
+      if (pos > stop)
+        pos = (char *)stop;
+      else if (pos < stop && pos[0] == '\n')
+        ++pos;
+      goto done;
+    }
+    start = pos + 3 + parser->boundary_len;
+    if (start[0] == '\n') {
+      /* should be true, unless new line marker was just '\n' */
+      ++start;
+    }
+    /* consume headers */
+    while (start + 4 < stop && start[0] != '\n' && start[1] != '\n') {
+      end = memchr(start, '\n', (size_t)(stop - start));
+      if (!end) {
+        if (first_run)
+          goto error;
+        goto end_of_data;
+      }
+      if (end - start > 29 && !strncasecmp(start, "content-disposition:", 20)) {
+        /* content-disposition header */
+        start = memchr(start + 20, ';', end - (start + 20));
+        // if (!start)
+        //   start = end + 1;
+        while (start) {
+          ++start;
+          if (start[0] == ' ')
+            ++start;
+          if (start + 6 < end && !strncasecmp(start, "name=", 5)) {
+            name = start + 5;
+            if (name[0] == '"')
+              ++name;
+            start = memchr(name, ';', (size_t)(end - start));
+            if (!start) {
+              name_len = (size_t)(end - name);
+              if (name[name_len - 1] == '\r')
+                --name_len;
+            } else {
+              name_len = (size_t)(start - name);
+            }
+            if (name[name_len - 1] == '"')
+              --name_len;
+          } else if (start + 9 < end && !strncasecmp(start, "filename", 8)) {
+            uint8_t encoded = 0;
+            start += 8;
+            if (start[0] == '*') {
+              encoded = 1;
+              ++start;
+            }
+            if (start[0] != '=')
+              goto error;
+            ++start;
+            if (start[0] == ' ')
+              ++start;
+            if (start[0] == '"')
+              ++start;
+            if (filename && !encoded) {
+              /* prefer URL encoded version */
+              start = memchr(filename, ';', (size_t)(end - start));
+              continue;
+            }
+            filename = start;
+            start = memchr(filename, ';', (size_t)(end - start));
+            if (!start) {
+              filename_len = (size_t)((end - filename));
+              if (filename[filename_len - 1] == '\r') {
+                --filename_len;
+              }
+            } else {
+              filename_len = (size_t)(start - filename);
+            }
+            if (filename[filename_len - 1] == '"')
+              --filename_len;
+            if (encoded) {
+              ssize_t new_len =
+                  http_mime_decode_url(filename, filename, filename_len);
+              if (new_len > 0)
+                filename_len = new_len;
+            }
+          } else {
+            start = memchr(start, ';', (size_t)(end - start));
+          }
+        }
+      } else if (end - start > 14 && !strncasecmp(start, "content-type:", 13)) {
+        /* content-type header */
+        start += 13;
+        if (start[0] == ' ')
+          ++start;
+        mime = start;
+        start = memchr(start, ';', (size_t)(end - start));
+        if (!start) {
+          mime_len = (size_t)(end - mime);
+          if (mime[mime_len - 1] == '\r')
+            --mime_len;
+        } else {
+          mime_len = (size_t)(start - mime);
+        }
+      }
+      start = end + 1;
+      if (header_count++ > 4)
+        goto error;
+    }
+    if (!name) {
+      if (start + 4 >= stop)
+        goto end_of_data;
+      goto error;
+    }
+
+    /* advance to end of boundry */
+    ++start;
+    if (start[0] == '\n')
+      ++start;
+    value = start;
+    end = start;
+    do {
+      end = memchr(end, '\n', (size_t)(stop - end));
+    } while (end && ++end &&
+             (size_t)(stop - end) >= (4 + parser->boundary_len) &&
+             (end[0] != '-' || end[1] != '-' ||
+              memcmp(end + 2, parser->boundary, parser->boundary_len)));
+    if (!end || end + 4 + parser->boundary_len >= stop) {
+      if (first_run) {
+        http_mime_parser_on_partial_start(parser, name, name_len, filename,
+                                          filename_len, mime, mime_len);
+        parser->in_obj = 1;
+        pos = value;
+        goto consume_partial;
+      }
+      goto end_of_data;
+    }
+    value_len = (size_t)((end - value) - 1);
+    if (value[value_len - 1] == '\r')
+      --value_len;
+    pos = end;
+    http_mime_parser_on_data(parser, name, name_len, filename, filename_len,
+                             mime, mime_len, value, value_len);
+    first_run = 0;
+  }
+end_of_data:
+  return (size_t)((uintptr_t)pos - (uintptr_t)buffer);
+done:
+  parser->done = 1;
+  parser->error = 0;
+  return (size_t)((uintptr_t)pos - (uintptr_t)buffer);
+error:
+  parser->done = 0;
+  parser->error = 1;
+  return (size_t)((uintptr_t)pos - (uintptr_t)buffer);
+}
+#endif