iodine 0.1.21 → 0.2.0

data/ext/iodine/http_response.h

@@ -0,0 +1,393 @@
+#ifndef HTTP_RESPONSE
+/**
+The HttpResponse library
+========================
+
+This library helps us to write HTTP valid responses, even when we do not know
+the internals of the HTTP protocol.
+
+The response object allows us to easily update the response status (all
+responses start with the default 200 "OK" status code), write headers and cookie
+data to the header buffer and send the response's body.
+
+The response object also allows us to easily update the body size and send body
+data or open files (which will be automatically closed once sending is done).
+
+As example flow for the response could be:
+
+     ; // get an initialized HttpRequest object
+     struct HttpRequest * response = HttpResponse.create(request);
+     ; // ... write headers and body, i.e.
+     HttpResponse.write_header_cstr(response, "X-Data", "my data");
+     HttpResponse.write_body(response, "Hello World!\r\n", 14);
+     ; // release the object
+     HttpResponse.destroy(response);
+
+
+--
+Thread-safety:
+
+The response object and it's API are NOT thread-safe (it is assumed that no two
+threads handle the same response at the same time).
+
+Also, the response object will link itself to a libsock buffer packet, so it
+should be created and dispatched during the same event - `sock_packet_s` objects
+shouldn't be held across events or for a period of time... In other words:
+
+**Create the response object only when you are ready to send a response**.
+
+---
+Misc notes:
+The response header's buffer size is limited and too many headers will fail the
+response.
+
+The response object allows us to easily update the response status (all
+responses start with the default 200 "OK" status code), write headers and write
+cookie data to the header buffer.
+
+The response object also allows us to easily update the body size and send body
+data or open files (which will be automatically closed once sending is done).
+
+The response does NOT support chuncked encoding.
+
+The following is the response API container, use:
+
+     struct HttpRequest * response = HttpResponse.create(request);
+
+
+---
+Performance:
+
+A note about using this library with the HTTP/1 protocol family (if this library
+supports HTTP/2, in the future, the use of the response object will be required,
+as it might not be possible to handle the response manually):
+
+Since this library safeguards against certain mistakes and manages an
+internal header buffer, it comes at a performance cost (it adds a layer of data
+copying to the headers).
+
+This cost is mitigated by the optional use of a response object pool, so that it
+actually saves us from using `malloc` for the headers - for some cases this is
+faster.
+
+In my performance tests, the greatest issue is this: spliting the headers from
+the body means that the socket's buffer is under-utilized on the first call to
+`send`, while sending the headers. While other operations incure minor costs,
+this is the actual reason for degraded performance when using this library.
+
+The order of performance should be considered as follows:
+
+1. Destructive: Overwriting the request's header buffer with both the response
+headers and the response data (small responses). Sending the data through the
+socket using the `Server.write` function.
+
+2. Using malloc to allocate enough memory for both the response's headers AND
+it's body.  Sending the data through the socket using the `Server.write_move`
+function.
+
+3. Using the HttpResponse object to send the response.
+
+Network issues and response properties might influence the order of performant
+solutions.
+*/
+#define HTTP_RESPONSE
+#include "http.h"
+#include "http_request.h"
+
+typedef struct {
+  /**
+The body's response length.
+
+If this isn't set manually, the first call to
+`HttpResponse.write_body` (and friends) will set the length to the length
+being written (which might be less then the total data sent, if the sending is
+fragmented).
+
+Set the value to -1 to force the HttpResponse not to write nor automate the
+`Content-Length` header.
+*/
+  ssize_t content_length;
+  /**
+  The HTTP date for the response (in seconds since epoche).
+
+  Defaults to now (approximately, not exactly, uses cached data).
+
+  The date will be automatically formatted to match the HTTP protocol
+  specifications. It is better to avoid setting the "Date" header manualy.
+  */
+  time_t date;
+  /**
+  The HTTP date for the response (in seconds since epoche).
+
+  Defaults to now (approximately, not exactly, uses cached data).
+
+  The date will be automatically formatted to match the HTTP protocol
+  specifications. It is better to avoid setting the "Date" header manualy.
+  */
+  time_t last_modified;
+  /**
+  The response status
+  */
+  uint16_t status;
+  /**
+  Metadata about the response's state - don't edit this data (except the opaque
+  data, if needed).
+  */
+  struct {
+    /**
+    The request object to which this response is "responding".
+    */
+    http_request_s *request;
+    /**
+    The libsock fd UUID.
+    */
+    intptr_t fd;
+    /**
+    A `libsock` buffer packet used for header data (to avoid double copy).
+    */
+    sock_packet_s *packet;
+    /**
+    A pointer to the header's writing position.
+    */
+    char *headers_pos;
+    /**
+    Internally used by the logging API.
+    */
+    clock_t clock_start;
+    /**
+    HTTP protocol version identifier.
+    */
+    uint8_t version;
+    /**
+    Set to true once the headers were sent.
+    */
+    unsigned headers_sent : 1;
+    /**
+    Set to true when the "Date" header is written to the buffer.
+    */
+    unsigned date_written : 1;
+    /**
+    Set to true when the "Connection" header is written to the buffer.
+    */
+    unsigned connection_written : 1;
+    /**
+    Set to true when the "Content-Length" header is written to the buffer.
+    */
+    unsigned content_length_written : 1;
+    /**
+    Set to true in order to close the connection once the response was sent.
+    */
+    unsigned should_close : 1;
+    /**
+    Internally used by the logging API.
+    */
+    unsigned logged : 1;
+    /**
+    Reserved for future use.
+    */
+    unsigned rsrv : 2;
+
+  } metadata;
+
+} http_response_s;
+
+/**
+The struct HttpCookie is a helper for seting cookie data.
+
+This struct is used together with the `HttpResponse.set_cookie`. i.e.:
+
+      HttpResponse.set_cookie(response, (struct HttpCookie){
+        .name = "my_cookie",
+        .value = "data"
+      });
+
+*/
+typedef struct {
+  /** The cookie's name (key). */
+  char *name;
+  /** The cookie's value (leave blank to delete cookie). */
+  char *value;
+  /** The cookie's domain (optional). */
+  char *domain;
+  /** The cookie's path (optional). */
+  char *path;
+  /** The cookie name's size in bytes or a terminating NULL will be assumed.*/
+  size_t name_len;
+  /** The cookie value's size in bytes or a terminating NULL will be assumed.*/
+  size_t value_len;
+  /** The cookie domain's size in bytes or a terminating NULL will be assumed.*/
+  size_t domain_len;
+  /** The cookie path's size in bytes or a terminating NULL will be assumed.*/
+  size_t path_len;
+  /** Max Age (how long should the cookie persist), in seconds (0 == session).*/
+  int max_age;
+  /** Limit cookie to secure connections.*/
+  unsigned secure : 1;
+  /** Limit cookie to HTTP (intended to prevent javascript access/hijacking).*/
+  unsigned http_only : 1;
+} http_cookie_s;
+
+/**
+Initializes a response object with the request object. This function assumes the
+response object memory is garbage and might have been stack-allocated.
+
+Notice that the `http_request_s` pointer must point at a valid request object
+and that the request object must remain valid until the response had been
+completed.
+
+Hangs on failuer (waits for available resources).
+*/
+http_response_s http_response_init(http_request_s *request);
+/**
+Releases any resources held by the response object (doesn't release the response
+object itself, which might have been allocated on the stack).
+
+This function assumes the response object might have been stack-allocated.
+*/
+void http_response_destroy(http_response_s *response);
+/** Gets a response status, as a string. */
+const char *http_response_status_str(uint16_t status);
+/** Gets the mime-type string (C string) associated with the file extension. */
+const char *http_response_ext2mime(const char *ext);
+/**
+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 http_response_write_header(http_response_s *, http_headers_s header);
+#define http_response_write_header(response, ...)                              \
+  http_response_write_header(response, (http_headers_s){__VA_ARGS__})
+
+/**
+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 http_response_set_cookie(http_response_s *, http_cookie_s);
+#define http_response_set_cookie(response, ...)                                \
+  http_response_set_cookie(response, (http_cookie_s){__VA_ARGS__})
+
+/**
+Indicates that any pending data (i.e. unsent headers) should be sent and that no
+more use of the response object will be made. This will also release any
+resources aquired when the response object was initialized, similar to the
+`http_response_destroy` function.
+
+If logging was initiated and hadn't been performed, it will be performed.
+
+If the connection was already closed, the function will return -1. On success,
+the function returns 0.
+*/
+void http_response_finish(http_response_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 http_response_write_body(http_response_s *, const char *body,
+                             size_t length);
+
+// /**
+// REVIEW: IS THIS APPLICABLE FOR HTTP/2 AS WELL? this must be a unified API.
+//
+// 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 body and free it's
+// memory using `free` once the data was sent.
+//
+// If the connection was already closed, the function will return -1. On
+// success,
+// the function returns 0.
+// */
+// int http_response_write_body_move(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 `fclose` once the data was sent.
+
+If the connection was already closed, the function will return -1. On success,
+the function returns 0.
+*/
+int http_response_sendfile(http_response_s *, int source_fd, off_t offset,
+                           size_t length);
+/**
+Attempts to send the file requested using an **optional** response object (if no
+response object is pointed to, a temporary response object will be created).
+
+If a `file_path_unsafe` is provided, it will be appended to the `file_path_safe`
+(if any) and URL decoded before attempting to locate and open the file. Any
+insecure path manipulations in the `file_path_unsafe` (i.e. `..` or `//`) will
+cause the function to fail.
+
+`file_path_unsafe` MUST begine with a `/`, or it will be appended to
+`file_path_safe` as part of the last folder's name. if `file_path_safe` ends
+with a `/`, it will be trancated.
+
+If the `log` flag is set, response logging will be performed.
+
+If the path ends with a backslash ('/'), the string `"index.html"` will be
+appended (a default file name for when serving a folder). No automatic folder
+indexing is supported.
+
+This function will honor Ranged requests by setting the byte range
+appropriately.
+
+On failure, the function will return -1 (no response will be sent).
+
+On success, the function returns 0.
+*/
+int http_response_sendfile2(http_response_s *response, http_request_s *request,
+                            const char *file_path_safe, size_t path_safe_len,
+                            const char *file_path_unsafe,
+                            size_t path_unsafe_len, uint8_t log);
+/**
+Starts counting miliseconds for log results.
+*/
+void http_response_log_start(http_response_s *);
+/**
+prints out the log to stderr.
+*/
+void http_response_log_finish(http_response_s *);
+
+#endif

data/ext/iodine/http_response_http1.h

@@ -0,0 +1,374 @@
+#ifndef HTTP1_RESPONSE_FORMATTER
+#define HTTP1_RESPONSE_FORMATTER
+
+#include "http_response.h"
+#include "libsock.h"
+
+#ifndef __unused
+#define __unused __attribute__((unused))
+#endif
+
+/* *****************************************************************************
+Helpers
+***************************************************************************** */
+
+/**
+The padding for the status line (62 + 2 for the extra \r\n after the headers).
+*/
+#define H1P_HEADER_START 80
+#define H1P_OVERFLOW_PADDING 512
+
+/** checks for overflow */
+#define overflowing(response)                                                  \
+  (((response)->metadata.headers_pos -                                         \
+    (char *)((response)->metadata.packet->buffer)) >=                          \
+   (BUFFER_PACKET_SIZE - H1P_OVERFLOW_PADDING))
+
+#define HEADERS_FINISHED(response)                                             \
+  ((response)->metadata.packet == NULL || (response)->metadata.headers_sent)
+
+#define invalid_cookie_char(c)                                                 \
+  ((c) < '!' || (c) > '~' || (c) == '=' || (c) == ' ' || (c) == ',' ||         \
+   (c) == ';')
+
+#define h1p_validate_hpos(response)                                            \
+  {                                                                            \
+    if ((response)->metadata.headers_pos == 0) {                               \
+      (response)->metadata.headers_pos =                                       \
+          (response)->metadata.packet->buffer + H1P_HEADER_START;              \
+    }                                                                          \
+  }
+static inline int h1p_protected_copy(http_response_s *response,
+                                     const char *data, size_t data_len) {
+  if (data_len > 0 && data_len < H1P_OVERFLOW_PADDING) {
+    memcpy(response->metadata.headers_pos, data, data_len);
+    response->metadata.headers_pos += data_len;
+  } else {
+    while (*data) {
+      if (overflowing(response))
+        return -1;
+      *(response->metadata.headers_pos++) = *(data++);
+    }
+  }
+  return overflowing(response);
+}
+
+/* this function assume the padding in `h1p_protected_copy` saved enough room
+ * for the data to be safely written.*/
+__unused static inline sock_packet_s *
+h1p_finalize_headers(http_response_s *response) {
+  if (HEADERS_FINISHED(response))
+    return NULL;
+  h1p_validate_hpos(response);
+
+  sock_packet_s *headers = response->metadata.packet;
+  response->metadata.packet = NULL;
+  const char *status = http_response_status_str(response->status);
+  if (!status) {
+    response->status = 500;
+    status = http_response_status_str(response->status);
+  }
+
+  /* write the keep-alive (connection) header, if missing */
+  if (!response->metadata.connection_written) {
+    if (response->metadata.should_close) {
+      h1p_protected_copy(response, "Connection:close\r\n", 18);
+    } else {
+      h1p_protected_copy(response, "Connection:keep-alive\r\n"
+                                   "Keep-Alive:timeout=2\r\n",
+                         45);
+    }
+  }
+  /* write the content length header, unless forced not to (<0) */
+  if (response->metadata.content_length_written == 0 &&
+      !(response->content_length < 0) && response->status >= 200 &&
+      response->status != 204 && response->status != 304) {
+    h1p_protected_copy(response, "Content-Length:", 15);
+    response->metadata.headers_pos +=
+        http_ul2a(response->metadata.headers_pos, response->content_length);
+    /* write the header seperator (`\r\n`) */
+    *(response->metadata.headers_pos++) = '\r';
+    *(response->metadata.headers_pos++) = '\n';
+  }
+  /* write the date, if missing */
+  if (!response->metadata.date_written) {
+    if (response->date < response->last_modified)
+      response->date = response->last_modified;
+    struct tm t;
+    /* date header */
+    http_gmtime(&response->date, &t);
+    h1p_protected_copy(response, "Date:", 5);
+    response->metadata.headers_pos +=
+        http_date2str(response->metadata.headers_pos, &t);
+    *(response->metadata.headers_pos++) = '\r';
+    *(response->metadata.headers_pos++) = '\n';
+    /* last-modified header */
+    http_gmtime(&response->last_modified, &t);
+    h1p_protected_copy(response, "Last-Modified:", 14);
+    response->metadata.headers_pos +=
+        http_date2str(response->metadata.headers_pos, &t);
+    *(response->metadata.headers_pos++) = '\r';
+    *(response->metadata.headers_pos++) = '\n';
+  }
+  /* write the headers completion marker (empty line - `\r\n`) */
+  *(response->metadata.headers_pos++) = '\r';
+  *(response->metadata.headers_pos++) = '\n';
+
+  /* write the status string is "HTTP/1.1 xxx <...>\r\n" length == 15 +
+   * strlen(status) */
+
+  size_t tmp = strlen(status);
+  int start = H1P_HEADER_START - (15 + tmp);
+  memcpy(headers->buffer + start, "HTTP/1.1 ### ", 13);
+  memcpy(headers->buffer + start + 13, status, tmp);
+  ((char *)headers->buffer)[H1P_HEADER_START - 1] = '\n';
+  ((char *)headers->buffer)[H1P_HEADER_START - 2] = '\r';
+  tmp = response->status / 10;
+  *((char *)headers->buffer + start + 11) =
+      '0' + (response->status - (10 * tmp));
+  *((char *)headers->buffer + start + 10) = '0' + (tmp - (10 * (tmp / 10)));
+  *((char *)headers->buffer + start + 9) = '0' + (response->status / 100);
+
+  headers->buffer = (char *)headers->buffer + start;
+  headers->length = response->metadata.headers_pos - (char *)headers->buffer;
+  return headers;
+}
+
+static int h1p_send_headers(http_response_s *response, sock_packet_s *packet) {
+  if (packet == NULL)
+    return -1;
+  /* mark headers as sent */
+  response->metadata.headers_sent = 1;
+  response->metadata.packet = NULL;
+  response->metadata.headers_pos = (char *)packet->length;
+  /* write data to network */
+  return sock_send_packet(response->metadata.fd, packet);
+};
+
+/* *****************************************************************************
+Implementation
+***************************************************************************** */
+
+__unused static inline int h1p_response_write_header(http_response_s *response,
+                                                     http_headers_s header) {
+  if (HEADERS_FINISHED(response) || header.name == NULL)
+    return -1;
+
+  h1p_validate_hpos(response);
+
+  if (h1p_protected_copy(response, header.name, header.name_length))
+    return -1;
+  *(response->metadata.headers_pos++) = ':';
+  /*  *(response->metadata.headers_pos++) = ' '; -- better leave out */
+  if (header.value != NULL &&
+      h1p_protected_copy(response, header.value, header.value_length))
+    return -1;
+  *(response->metadata.headers_pos++) = '\r';
+  *(response->metadata.headers_pos++) = '\n';
+  return 0;
+}
+
+/**
+Set / Delete a cookie using this helper function.
+*/
+__unused static int h1p_response_set_cookie(http_response_s *response,
+                                            http_cookie_s cookie) {
+  if (HEADERS_FINISHED(response) || cookie.name == NULL ||
+      overflowing(response))
+    return -1; /* must have a cookie name. */
+  h1p_validate_hpos(response);
+
+  /* write the header's name to the buffer */
+  if (h1p_protected_copy(response, "Set-Cookie:", 11))
+    return -1;
+
+  /* we won't use h1p_protected_copy because we'll be testing the name and value
+   *  for illegal characters. */
+
+  /* write the cookie name */
+  if (cookie.name_len && cookie.name_len < H1P_OVERFLOW_PADDING) {
+    for (size_t i = 0; i < cookie.name_len; i++) {
+      if (invalid_cookie_char(*cookie.name) == 0) {
+        *(response->metadata.headers_pos++) = *(cookie.name++);
+        continue;
+      } else {
+        fprintf(stderr, "Invalid cookie name cookie name character: %c\n",
+                *cookie.name);
+        return -1;
+      }
+    }
+  } else {
+    while (*cookie.name && overflowing(response) == 0) {
+      if (invalid_cookie_char(*cookie.name) == 0) {
+        *(response->metadata.headers_pos++) = *(cookie.name++);
+        continue;
+      } else {
+        fprintf(stderr, "Invalid cookie name cookie name character: %c\n",
+                *cookie.name);
+        return -1;
+      }
+    }
+  }
+  if (overflowing(response))
+    return -1;
+  /* seperate name from value */
+  *(response->metadata.headers_pos++) = '=';
+  /* write the cookie value, if any */
+  if (cookie.value) {
+    if (cookie.value_len && cookie.value_len < H1P_OVERFLOW_PADDING) {
+      for (size_t i = 0; i < cookie.value_len; i++) {
+        if (invalid_cookie_char(*cookie.value) == 0) {
+          *(response->metadata.headers_pos++) = *(cookie.value++);
+          continue;
+        } else {
+          fprintf(stderr, "Invalid cookie value cookie name character: %c\n",
+                  *cookie.value);
+          return -1;
+        }
+      }
+    } else {
+      while (*cookie.value && overflowing(response) == 0) {
+        if (invalid_cookie_char(*cookie.value) == 0) {
+          *(response->metadata.headers_pos++) = *(cookie.value++);
+          continue;
+        } else {
+          fprintf(stderr, "Invalid cookie value cookie name character: %c\n",
+                  *cookie.value);
+          return -1;
+        }
+      }
+    }
+    if (overflowing(response))
+      return -1;
+  } else {
+    cookie.max_age = -1;
+  }
+  /* complete value data */
+  *(response->metadata.headers_pos++) = ';';
+  if (cookie.max_age) {
+    response->metadata.headers_pos +=
+        sprintf(response->metadata.headers_pos, "Max-Age=%d;", cookie.max_age);
+  }
+  if (cookie.domain) {
+    memcpy(response->metadata.headers_pos, "domain=", 7);
+    response->metadata.headers_pos += 7;
+    if (h1p_protected_copy(response, cookie.domain, cookie.domain_len))
+      return -1;
+    *(response->metadata.headers_pos++) = ';';
+  }
+  if (cookie.path) {
+    memcpy(response->metadata.headers_pos, "path=", 5);
+    response->metadata.headers_pos += 5;
+    if (h1p_protected_copy(response, cookie.path, cookie.path_len))
+      return -1;
+    *(response->metadata.headers_pos++) = ';';
+  }
+  if (cookie.http_only) {
+    memcpy(response->metadata.headers_pos, "HttpOnly;", 9);
+    response->metadata.headers_pos += 9;
+  }
+  if (cookie.secure) {
+    memcpy(response->metadata.headers_pos, "secure;", 7);
+    response->metadata.headers_pos += 7;
+  }
+  *(response->metadata.headers_pos++) = '\r';
+  *(response->metadata.headers_pos++) = '\n';
+  return 0;
+}
+
+/**
+Sends the headers (if unsent) and sends the body.
+*/
+__unused static inline int h1p_response_write_body(http_response_s *response,
+                                                   const char *body,
+                                                   size_t length) {
+  if (!response->content_length)
+    response->content_length = length;
+  sock_packet_s *headers = h1p_finalize_headers(response);
+  if (headers != NULL) { /* we haven't sent the headers yet */
+    ssize_t i_read =
+        ((BUFFER_PACKET_SIZE - H1P_HEADER_START) - headers->length);
+    if (i_read > 1024) {
+      /* we can fit at least some of the data inside the response buffer. */
+      if (i_read > length) {
+        i_read = length;
+        /* we can fit the data inside the response buffer. */
+        memcpy(response->metadata.headers_pos, body, i_read);
+        response->metadata.headers_pos += i_read;
+        headers->length += i_read;
+        return h1p_send_headers(response, headers);
+      }
+      memcpy(response->metadata.headers_pos, body, i_read);
+      response->metadata.headers_pos += i_read;
+      headers->length += i_read;
+      length -= i_read;
+      body += i_read;
+    }
+    /* we need to send the (rest of the) body seperately. */
+    if (h1p_send_headers(response, headers))
+      return -1;
+  }
+  response->metadata.headers_pos += length;
+  return sock_write(response->metadata.fd, (void *)body, length);
+}
+/**
+Sends the headers (if unsent) and schedules the file to be sent.
+*/
+__unused static inline int h1p_response_sendfile(http_response_s *response,
+                                                 int source_fd, off_t offset,
+                                                 size_t length) {
+  if (!response->content_length)
+    response->content_length = length;
+
+  sock_packet_s *headers = h1p_finalize_headers(response);
+
+  if (headers != NULL) { /* we haven't sent the headers yet */
+    if (headers->length < (BUFFER_PACKET_SIZE - H1P_HEADER_START)) {
+      /* we can fit at least some of the data inside the response buffer. */
+      ssize_t i_read = pread(
+          source_fd, response->metadata.headers_pos,
+          ((BUFFER_PACKET_SIZE - H1P_HEADER_START) - headers->length), offset);
+      if (i_read > 0) {
+        if (i_read >= length) {
+          headers->length += length;
+          close(source_fd);
+          return h1p_send_headers(response, headers);
+        } else {
+          headers->length += i_read;
+          length -= i_read;
+          offset += i_read;
+        }
+      }
+    }
+    /* we need to send the rest seperately. */
+    if (h1p_send_headers(response, headers)) {
+      close(source_fd);
+      return -1;
+    }
+  }
+  response->metadata.headers_pos += length;
+  return sock_sendfile(response->metadata.fd, source_fd, offset, length);
+}
+
+__unused static inline int h1p_response_finish(http_response_s *response) {
+  sock_packet_s *headers = h1p_finalize_headers(response);
+  if (headers) {
+    return h1p_send_headers(response, headers);
+  }
+  if (response->metadata.should_close) {
+    sock_close(response->metadata.fd);
+  }
+
+  return 0;
+}
+
+/* *****************************************************************************
+Cleanup
+***************************************************************************** */
+
+/* clear any used definitions */
+#undef overflowing
+#undef HEADERS_FINISHED
+#undef invalid_cookie_char
+#undef h1p_validate_hpos
+#endif