iodine 0.2.17 → 0.3.0

data/ext/iodine/http1_response.h

@@ -0,0 +1,90 @@
+#ifndef H_HTTP1_RESPONSE_H
+#define H_HTTP1_RESPONSE_H
+
+#include "http1.h"
+
+/* *****************************************************************************
+Initialization
+***************************************************************************** */
+
+/** Creates / allocates a protocol version's response object. */
+http_response_s *http1_response_create(http_request_s *request);
+/** Destroys the response object. No data is sent.*/
+void http1_response_destroy(http_response_s *);
+/** Sends the data and destroys the response object.*/
+void http1_response_finish(http_response_s *);
+
+/* *****************************************************************************
+Writing data to the response object
+***************************************************************************** */
+
+/**
+Writes a header to the response. This function writes only the requested
+number of bytes from the header name and the requested number of bytes from
+the header value. It can be used even when the header name and value don't
+contain NULL terminating bytes by passing the `.name_len` or `.value_len` data
+in the `http_headers_s` structure.
+
+If the header buffer is full or the headers were already sent (new headers
+cannot be sent), the function will return -1.
+
+On success, the function returns 0.
+*/
+int http1_response_write_header_fn(http_response_s *, http_header_s header);
+
+/**
+Set / Delete a cookie using this helper function.
+
+To set a cookie, use (in this example, a session cookie):
+
+    http_response_set_cookie(response,
+            .name = "my_cookie",
+            .value = "data");
+
+To delete a cookie, use:
+
+    http_response_set_cookie(response,
+            .name = "my_cookie",
+            .value = NULL);
+
+This function writes a cookie header to the response. Only the requested
+number of bytes from the cookie value and name are written (if none are
+provided, a terminating NULL byte is assumed).
+
+Both the name and the value of the cookie are checked for validity (legal
+characters), but other properties aren't reviewed (domain/path) - please make
+sure to use only valid data, as HTTP imposes restrictions on these things.
+
+If the header buffer is full or the headers were already sent (new headers
+cannot be sent), the function will return -1.
+
+On success, the function returns 0.
+*/
+int http1_response_set_cookie(http_response_s *, http_cookie_s);
+
+/**
+Sends the headers (if they weren't previously sent) and writes the data to the
+underlying socket.
+
+The body will be copied to the server's outgoing buffer.
+
+If the connection was already closed, the function will return -1. On success,
+the function returns 0.
+*/
+int http1_response_write_body(http_response_s *, const char *body,
+                              size_t length);
+
+/**
+Sends the headers (if they weren't previously sent) and writes the data to the
+underlying socket.
+
+The server's outgoing buffer will take ownership of the file and close it
+using `close` once the data was sent.
+
+If the connection was already closed, the function will return -1. On success,
+the function returns 0.
+*/
+int http1_response_sendfile(http_response_s *, int source_fd, off_t offset,
+                            size_t length);
+
+#endif

data/ext/iodine/http1_simple_parser.c

@@ -4,7 +4,10 @@ license: MIT
 
 Feel free to copy, use and enjoy according to the license provided.
 */
+#define _GNU_SOURCE
 #include "http1_simple_parser.h"
+#include <stdlib.h>
+#include <string.h>
 #include <strings.h>
 
 #ifdef __has_include
@@ -24,15 +27,17 @@ Feel free to copy, use and enjoy according to the license provided.
 Useful macros an helpers
 */
 
+/*
 #define a2i(a)                                                                 \
   (((a) >= '0' && a <= '9') ? ((a) - '0') : ({                                 \
     return -1;                                                                 \
     0;                                                                         \
   }))
+*/
 
 #define CHECK_END()                                                            \
   {                                                                            \
-    request->metadata.next = pos;                                              \
+    request->udata = pos;                                                      \
     if (pos >= end) {                                                          \
       return -2;                                                               \
     }                                                                          \
@@ -45,6 +50,12 @@ Useful macros an helpers
     if (*pos == '\n' || *pos == 0)                                             \
       *(pos++) = 0;                                                            \
   }
+#undef EAT_EOL
+#define EAT_EOL()                                                              \
+  {                                                                            \
+    *(pos++) = 0;                                                              \
+    *(pos++) = 0;                                                              \
+  }
 
 static inline char *seek_to_char(char *start, char *end, char tok) {
   while (start < end) {
@@ -84,96 +95,89 @@ static inline char *seek_to_2eol(char *start, char *end) {
 
 /* reviews the latest header and updates any required data in the request
  * structure. */
-static inline ssize_t review_header_data(http_request_s *request, char *tmp) {
-  //  if (request->headers[request->headers_count].name_length == 4 &&
-  //      strncmp(request->headers[request->headers_count].name, HOST, 4) == 0)
-  //      {
-  //    request->host = (void*)tmp;
-  //    request->host_len =
-  //    request->headers[request->headers_count].value_length;
-  //  } else
-  if (request->headers[request->headers_count].name_length == 4 &&
-      *((uint32_t *)request->headers[request->headers_count].name) ==
-          *((uint32_t *)HOST)) { // exact match
-    request->host = (void *)tmp;
-    request->host_len = request->headers[request->headers_count].value_length;
-  } else if (request->headers[request->headers_count].name_length == 12 &&
-             *((uint64_t *)(request->headers[request->headers_count].name +
-                            3)) ==
+static inline ssize_t review_header_data(http_request_s *request,
+                                         http_header_s *header) {
+  if (header->name_len == 4 &&
+      *((uint32_t *)header->name) == *((uint32_t *)HOST)) { // exact match
+    request->host = (void *)header->data;
+    request->host_len = header->data_len;
+  } else if (header->name_len == 12 &&
+             *((uint64_t *)(header->name + 3)) ==
                  *((uint64_t *)(CONTENT_TYPE + 3))) { // almost
-    request->content_type = (void *)tmp;
-    request->content_type_len =
-        request->headers[request->headers_count].value_length;
-  } else if (request->headers[request->headers_count].name_length == 14 &&
-             *((uint64_t *)(request->headers[request->headers_count].name +
-                            3)) ==
+    request->content_type = (void *)header->data;
+    request->content_type_len = header->data_len;
+  } else if (header->name_len == 14 &&
+             *((uint64_t *)(header->name + 3)) ==
                  *((uint64_t *)(CONTENT_LENGTH + 3))) { // close match
     // tmp still holds a pointer to the value
     size_t c_len = 0;
+    char *tmp = (char *)header->data;
     while (*tmp) {
-      c_len = (c_len * 10) + a2i(*tmp);
+      if ((*tmp) >= '0' && (*tmp) <= '9')
+        c_len = (c_len * 10) + ((*tmp) - '0');
+      else
+        return -1;
       ++tmp;
     };
     request->content_length = c_len;
-  } else if (request->headers[request->headers_count].name_length == 7 &&
-             *((uint64_t *)request->headers[request->headers_count].name) ==
-                 *((uint64_t *)UPGRADE)) { // matches also the NULL character
-    request->upgrade = (void *)tmp;
-    request->upgrade_len =
-        request->headers[request->headers_count].value_length;
-  } else if (request->headers[request->headers_count].name_length == 10 &&
-             *((uint64_t *)request->headers[request->headers_count].name) ==
+  } else if (header->name_len == 7 &&
+             *((uint64_t *)header->name) ==
+                 *((uint64_t *)UPGRADE)) { // matches also the NUL character
+    request->upgrade = (void *)header->data;
+    request->upgrade_len = header->data_len;
+  } else if (header->name_len == 10 &&
+             *((uint64_t *)header->name) ==
                  *((uint64_t *)CONNECTION)) { // a close enough match
-    request->connection = (void *)tmp;
-    request->connection_len =
-        request->headers[request->headers_count].value_length;
+    request->connection = (void *)header->data;
+    request->connection_len = header->data_len;
   }
   return 0;
 }
 
 #else
 /* unknown header case */
+#define to_lower(c)
 
 static inline ssize_t review_header_data(http_request_s *request,
-                                         uint8_t *tmp) {
-  if (request->headers[request->headers_count].name_length == 4 &&
-      strncasecmp(request->headers[request->headers_count].name, HOST, 4) ==
-          0) {
-    request->host = (void *)tmp;
-    request->host_len = request->headers[request->headers_count].value_length;
-  } else if (request->headers[request->headers_count].name_length == 12 &&
-             strncasecmp(request->headers[request->headers_count].name,
-                         CONTENT_TYPE, 12) == 0) {
-    request->content_type = (void *)tmp;
-    request->content_type_len =
-        request->headers[request->headers_count].value_length;
-  } else if (request->headers[request->headers_count].name_length == 14 &&
-             strncasecmp(request->headers[request->headers_count].name,
-                         CONTENT_LENGTH, 14) == 0) {
+                                         http_header_s *header) {
+  if (header->name_len == 4 &&
+      strncasecmp((char *)header->name, HOST, 4) == 0) {
+    request->host = (void *)header->data;
+    request->host_len = header->data_len;
+  } else if (header->name_len == 12 &&
+             strncasecmp((char *)header->name, CONTENT_TYPE, 12) == 0) {
+    request->content_type = (void *)header->data;
+    request->content_type_len = header->data_len;
+  } else if (header->name_len == 14 &&
+             strncasecmp((char *)header->name, CONTENT_LENGTH, 14) == 0) {
     // tmp still holds a pointer to the value
     size_t c_len = 0;
+    char *tmp = (char *)header->data;
     while (*tmp) {
-      c_len = (c_len * 10) + a2i(*tmp);
+      if ((*tmp) >= '0' && (*tmp) <= '9')
+        c_len = (c_len * 10) + ((*tmp) - '0');
+      else
+        return -1;
       ++tmp;
     };
     request->content_length = c_len;
-  } else if (request->headers[request->headers_count].name_length == 7 &&
-             strncasecmp(request->headers[request->headers_count].name, UPGRADE,
-                         7) == 0) {
-    request->upgrade = (void *)tmp;
-    request->upgrade_len =
-        request->headers[request->headers_count].value_length;
-  } else if (request->headers[request->headers_count].name_length == 10 &&
-             strncasecmp(request->headers[request->headers_count].name,
-                         CONNECTION, 10) == 0) {
-    request->connection = (void *)tmp;
-    request->connection_len =
-        request->headers[request->headers_count].value_length;
+  } else if (header->name_len == 7 &&
+             strncasecmp((char *)header->name, UPGRADE, 7) == 0) {
+    request->upgrade = (void *)header->data;
+    request->upgrade_len = header->data_len;
+  } else if (header->name_len == 10 &&
+             strncasecmp((char *)header->name, CONNECTION, 10) == 0) {
+    request->connection = (void *)header->data;
+    request->connection_len = header->data_len;
   }
   return 0;
 }
 #endif
 
+static void no_on_header_found(http_request_s *request, http_header_s *header) {
+  (void)request;
+  (void)header;
+}
 /* *****************************************************************************
 The (public) parsing
 */
@@ -194,33 +198,40 @@ buffer
 and the same `http_request_s` should be returned to the parsed on the "next
 round", only the `len` argument is expected to grow.
 */
-ssize_t http1_parse_request_headers(void *buffer, size_t len,
-                                    http_request_s *request) {
-  if (request == NULL || buffer == NULL || request->metadata.max_headers == 0)
+ssize_t http1_parse_request_headers(
+    void *buffer, size_t len, http_request_s *request,
+    void (*on_header_found)(http_request_s *request, http_header_s *header)) {
+  if (request == NULL || buffer == NULL)
     return -1;
+  if (!on_header_found)
+    on_header_found = no_on_header_found;
   if (request->body_str || request->body_file > 0)
     return 0;
   if (len == 0)
     return -2;
-  char *pos = buffer;
-  char *end = buffer + len;
+  http_header_s header;
+  char *pos = (char *)buffer;
+  char *end = (char *)buffer + len;
   char *next, *tmp;
   // collect method and restart parser if already collected
   if (request->method == NULL) {
     // eat empty spaces
     while ((*pos == '\n' || *pos == '\r') && pos < end)
       ++pos;
+    CHECK_END();
     request->method = (char *)pos;
     next = seek_to_char(pos, end, ' ');
-    if (next == NULL)
-      return -1; /* there should be a limit to all fragmentations. */
+    if (next == NULL) {
+      request->method = NULL;
+      return -2;
+    }
     request->method_len = (uintptr_t)next - (uintptr_t)pos;
     pos = next;
     *(pos++) = 0;
     CHECK_END();
   } else {
-    /* use the `next` pointer to store current position in the buffer */
-    pos = request->metadata.next;
+    /* use the `udata` pointer to store current position in the buffer */
+    pos = request->udata;
     CHECK_END();
   }
   // collect path
@@ -252,14 +263,16 @@ ssize_t http1_parse_request_headers(void *buffer, size_t len,
     EAT_EOL();
     CHECK_END();
   }
+
   // collect headers
-  while (pos < end && *pos != '\n' && *pos != '\r' &&
-         *pos != 0) { /* NUL as term? */
-    if (request->headers_count >= request->metadata.max_headers)
+  while (pos < end && *pos != 0) { /* NUL as term */
+    if (request->headers_count >= HTTP1_MAX_HEADER_COUNT)
       return -1;
     next = seek_to_2eol(pos, end);
     if (next == NULL)
       return -2;
+    if (next == pos) /*headers finished */
+      break;
 #if defined(HTTP_HEADERS_LOWERCASE) && HTTP_HEADERS_LOWERCASE == 1
     tmp = pos;
     while (tmp < next && *tmp != ':') {
@@ -273,29 +286,29 @@ ssize_t http1_parse_request_headers(void *buffer, size_t len,
     if (!tmp)
       return -1;
 #endif
-    request->headers[request->headers_count].name = (void *)pos;
-    request->headers[request->headers_count].name_length = tmp - pos;
+    header.name = (void *)pos;
+    header.name_len = (uintptr_t)(tmp - pos);
     *(tmp++) = 0;
     if (*tmp == ' ')
       *(tmp++) = 0;
-    request->headers[request->headers_count].value = (char *)tmp;
-    request->headers[request->headers_count].value_length = next - tmp;
+    header.data = (void *)tmp;
+    header.data_len = (uintptr_t)(next - tmp);
     // eat EOL before content-length processing.
     pos = next;
     EAT_EOL();
     // print debug info
-    // fprintf(stderr, "Got header %s (%u): %s (%u)\n",
-    //         request->headers[request->headers_count].name,
-    //         request->headers[request->headers_count].name_length,
-    //         request->headers[request->headers_count].value,
-    //         request->headers[request->headers_count].value_length);
+    // fprintf(stderr, "Got header %s (%u): %s (%u)\n", header.name,
+    //         header.name_len, header.data, header.data_len);
     // check special headers and assign value.
-    review_header_data(request, tmp);
-    // advance header position
+    review_header_data(request, &header);
     request->headers_count += 1;
+    on_header_found(request, &header);
+    // advance header position
     CHECK_END();
   }
-  // check if the body is contained within the buffer
+  // Did we break because there's no more data or end of headers?
+  CHECK_END();
+  // "eat" the end of headers line and finish processing.
   EAT_EOL();
   if (request->content_length &&
       (end - pos) >= (ssize_t)request->content_length) {
@@ -308,9 +321,8 @@ ssize_t http1_parse_request_headers(void *buffer, size_t len,
     //         request->body_str);
     return (ssize_t)(pos - (char *)buffer) + request->content_length;
   }
-
   // we're done.
-  return pos - (char *)buffer;
+  return (ssize_t)(pos - (char *)buffer);
 }
 
 /**
@@ -347,28 +359,26 @@ ssize_t http1_parse_request_body(void *buffer, size_t len,
     if (request->body_file == -1)
       return -1;
     // use the `next` field to store parser state.
-    uintptr_t *tmp = (uintptr_t *)(&request->metadata.next);
+    uintptr_t *tmp = (uintptr_t *)(&request->udata);
     *tmp = 0;
   }
   // make sure we have anything to read. This might be an initializing call.
   if (len == 0)
-    return ((uintptr_t)(request->metadata.next)) >= request->content_length
-               ? 0
-               : (-2);
+    return ((uintptr_t)(request->udata)) >= request->content_length ? 0 : (-2);
   // Calculate how much of the buffer should be read.
   ssize_t to_read =
-      ((request->content_length - ((uintptr_t)request->metadata.next)) < len)
-          ? (request->content_length - ((uintptr_t)request->metadata.next))
+      ((request->content_length - ((uintptr_t)request->udata)) < len)
+          ? (request->content_length - ((uintptr_t)request->udata))
           : len;
   // write the data to the temporary file.
   if (write(request->body_file, buffer, to_read) < to_read)
     return -1;
   // update the `next` field data with the received content length
-  uintptr_t *tmp = (uintptr_t *)(&request->metadata.next);
+  uintptr_t *tmp = (uintptr_t *)(&request->udata);
   *tmp += to_read; // request->metadata.next += to_read;
 
   // check the state and return.
-  if (((uintptr_t)request->metadata.next) >= request->content_length) {
+  if (((uintptr_t)request->udata) >= request->content_length) {
     lseek(request->body_file, 0, SEEK_SET);
     return to_read;
   }
@@ -377,9 +387,11 @@ ssize_t http1_parse_request_body(void *buffer, size_t len,
 
 #if defined(DEBUG) && DEBUG == 1
 
+// #include "http1_request.h"
+
 #include <time.h>
 
-void http_parser_test(void) {
+void http1_parser_test(void) {
   char request_text[] = "GET /?a=b HTTP/1.1\r\n"
                         "Host: local\r\n"
                         "Upgrade: websocket\r\n"
@@ -388,11 +400,9 @@ void http_parser_test(void) {
                         "\r\n"
                         "Hello World!\r\n";
   size_t request_length = sizeof(request_text) - 1;
-  uint8_t request_mem[HTTP_REQUEST_SIZE(24)] = {};
-  http_request_s *request = (void *)request_mem;
-  *request = (http_request_s){.metadata.max_headers = 24};
+  http_request_s *request = http_request_create(HTTP_V1);
   ssize_t ret =
-      http1_parse_request_headers(request_text, request_length, request);
+      http1_parse_request_headers(request_text, request_length, request, NULL);
   if (ret == -1) {
     fprintf(stderr, "* Parser FAILED -1.\n");
   } else if (ret == -2) {
@@ -436,7 +446,12 @@ void http_parser_test(void) {
                            "Connection: close\r\n"
                            "\r\n"
                            "Hello World!\r\n";
-    http1_parse_request_headers(request_text2, request_length, request);
+    if (http1_parse_request_headers(request_text2, request_length, request,
+                                    NULL) <= 0 ||
+        (request->upgrade_len != 9)) {
+      fprintf(stderr, "* HTTP/1.1 simple_parser unknown error\n");
+      return;
+    }
     http_request_clear(request);
   }
   end = clock();
@@ -450,16 +465,17 @@ void http_parser_test(void) {
                          "\r\n"
                          "Hello World!\r\n";
   fprintf(stderr, "start\n");
-  if (http1_parse_request_headers(request_text2, 7, request) != -2)
+  if (http1_parse_request_headers(request_text2, 7, request, NULL) != -2)
     fprintf(stderr, "Fragmented Parsing FAILED\n");
   fprintf(stderr, "step\n");
-  if (http1_parse_request_headers(request_text2, 27, request) != -2)
+  if (http1_parse_request_headers(request_text2, 27, request, NULL) != -2)
     fprintf(stderr, "Fragmented Parsing FAILED\n");
   fprintf(stderr, "step\n");
-  if (http1_parse_request_headers(request_text2, 38, request) != -2)
+  if (http1_parse_request_headers(request_text2, 38, request, NULL) != -2)
     fprintf(stderr, "Fragmented Parsing FAILED\n");
   fprintf(stderr, "step\n");
-  if ((ret = http1_parse_request_headers(request_text2, 98, request)) != 94)
+  if ((ret = http1_parse_request_headers(request_text2, 98, request, NULL)) !=
+      94)
     fprintf(stderr, "Fragmented Parsing (some body) FAILED\n");
   fprintf(stderr, "read: %lu\n", ret);
   if ((ret += http1_parse_request_body(request_text2 + ret,
@@ -474,7 +490,7 @@ void http_parser_test(void) {
     perror("Couldn't read temporary file");
   fprintf(stderr, "Body:\n%.*s\n", (int)request->content_length, request_text);
 
-  http_request_clear(request);
+  http_request_destroy(request);
 }
 
 #endif