iodine 0.4.7 → 0.4.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 481aeb644c0f6d2b38f2c00bc98412cc867e77d5
-  data.tar.gz: bd3eebc92151a3f2d4f41456c6d9402e7cc005fb
+  metadata.gz: '08f011b1bc43d3c47d266fc0e2dab7379708e5de'
+  data.tar.gz: 1197234946e68f0515ce51d3f8858d948a0a77ef
 SHA512:
-  metadata.gz: 4f31a4c09c7cbfe4df0a9f1df10c9c12004c7e92e3a2cbe1b513afff12c4c5670a457e0f4f6e8cf710ae5cb677d6b3c319f30baac802aefac054f8c8ccda058b
-  data.tar.gz: 9332123f1197af323c1b1af3a5fb1c5bbce7619b6586c1fb6ca049d220d9ebe6780637f5212588b55552e1bf17a07823cf5aedd1062dbf072095b1418df71cd5
+  metadata.gz: aab2abfb29dea3efd0041c31abfbe93b3aac2fa21cf48fa48629263d58d6b636ff054d43acc33b3c7e24904a7240e42ef6e865218b1530bce530bf785adc4ef6
+  data.tar.gz: 4ed2825719fc986132ecbdb28d3c56c2bc23e752f1d67df794a92fc12c5f89c84c0b914ef7ad49bece19d2f01ac3790ddce73b858fe024a1fffaeab985eba6aa

data/CHANGELOG.md

@@ -6,6 +6,14 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ## Changes:
 
+#### Change log v.0.4.8
+
+**Change**: (`facil.io`) the internal HTTP parser was replaced with something easier to read, for maintainability reasons. Performance seems to be unaffected.
+
+**Fix**: HTTP request logging included an extra info line which was a debug/testing message inherited from `facil.io` v.0.5.3-pre-release. This is now removed.
+
+**Performance**: The `now` HTTP Date string is now cached for up to 2 seconds, improving performance for `Date`, `Last-Modified` and Iodine logging messages that relate to the current time. However, it's likely that Rack will write it's own date string, masking this feature.
+
 #### Change log v.0.4.7
 
 **Update**: Now using `facil.io` edge (stripped down v.0.5.3).

data/README.md

@@ -399,7 +399,7 @@ Yes, please, here are some thoughts:
 
 * If we can write a Java wrapper for [the `facil.io` C framework](https://github.com/boazsegev/facil.io), it would be nice... but it could be as big a project as the whole gem, as a lot of minor details are implemented within the bridge between these two languages.
 
-* PRs or issues related to [the `facil.io` C framework](https://github.com/boazsegev/facil.io) would be better placed in [the `facil.io` repository](https://github.com/boazsegev/facil.io).
+* PRs or issues related to [the `facil.io` C framework](https://github.com/boazsegev/facil.io) should be placed in [the `facil.io` repository](https://github.com/boazsegev/facil.io).
 
 * Bug reports and pull requests are welcome on GitHub at https://github.com/boazsegev/iodine.
 

data/ext/iodine/http.c

@@ -121,7 +121,7 @@ struct tm *http_gmtime(const time_t *timer, struct tm *tmbuf) {
   // static char * Months = {  "Jan", "Feb", "Mar", "Apr", "May", "Jun",
   // "Jul",
   // "Aug", "Sep", "Oct", "Nov", "Dec"};
-  static uint8_t month_len[] = {
+  static const uint8_t month_len[] = {
       31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, // nonleap year
       31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31  // leap year
   };
@@ -215,9 +215,11 @@ struct tm *http_gmtime(const time_t *timer, struct tm *tmbuf) {
   return tmbuf;
 }
 
-static char *DAY_NAMES[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
-static char *MONTH_NAMES[] = {"Jan ", "Feb ", "Mar ", "Apr ", "May ", "Jun ",
-                              "Jul ", "Aug ", "Sep ", "Oct ", "Nov ", "Dec "};
+static const char *DAY_NAMES[] = {"Sun", "Mon", "Tue", "Wed",
+                                  "Thu", "Fri", "Sat"};
+static const char *MONTH_NAMES[] = {"Jan ", "Feb ", "Mar ", "Apr ",
+                                    "May ", "Jun ", "Jul ", "Aug ",
+                                    "Sep ", "Oct ", "Nov ", "Dec "};
 static const char *GMT_STR = "GMT";
 
 size_t http_date2str(char *target, struct tm *tmbuf) {
@@ -345,6 +347,34 @@ size_t http_date2rfc2109(char *target, struct tm *tmbuf) {
   return pos - target;
 }
 
+/**
+ * Prints Unix time to a HTTP time formatted string.
+ *
+ * This variation implements chached results for faster processeing, at the
+ * price of a less accurate string.
+ */
+size_t http_time2str(char *target, const time_t t) {
+  /* pre-print time every 1 or 2 seconds or so. */
+  static __thread time_t cached_tick;
+  static __thread char cached_httpdate[48];
+  static __thread size_t chached_len;
+  time_t last_tick = facil_last_tick();
+  if ((t | 7) < last_tick) {
+    /* this is a custom time, not "now", pass through */
+    struct tm tm;
+    http_gmtime(&t, &tm);
+    return http_date2str(target, &tm);
+  }
+  if (last_tick > cached_tick) {
+    struct tm tm;
+    cached_tick = last_tick | 1;
+    http_gmtime(&last_tick, &tm);
+    chached_len = http_date2str(cached_httpdate, &tm);
+  }
+  memcpy(target, cached_httpdate, chached_len);
+  return chached_len;
+}
+
 /* Credit to Jonathan Leffler for the idea of a unified conditional */
 #define hex_val(c)                                                             \
   (((c) >= '0' && (c) <= '9')                                                  \

data/ext/iodine/http.h

@@ -164,6 +164,14 @@ size_t http_date2rfc2109(char *target, struct tm *tmbuf);
 /** An alternative, RFC 2822 date representation. */
 size_t http_date2rfc2822(char *target, struct tm *tmbuf);
 
+/**
+ * Prints Unix time to a HTTP time formatted string.
+ *
+ * This variation implements chached results for faster processeing, at the
+ * price of a less accurate string.
+ */
+size_t http_time2str(char *target, const time_t t);
+
 /**
 A fast, inline alternative to `sprintf(dest, "%lu", num)`.
 

data/ext/iodine/http1.c

@@ -7,34 +7,35 @@ Feel free to copy, use and enjoy according to the license provided.
 #include "spnlock.inc"
 
 #include "http.h"
-#include "http1.h"
+#include "http1_parser.h"
 #include "http1_request.h"
-#include "http1_simple_parser.h"
 
 #include <fcntl.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/stat.h>
 
-char *HTTP1_Protocol_String = "facil_http/1.1_protocol";
+char *HTTP11_Protocol_String = "facil_http/1.1_protocol";
 /* *****************************************************************************
 HTTP/1.1 data structures
-*/
+***************************************************************************** */
 
 typedef struct http1_protocol_s {
   protocol_s protocol;
   http_settings_s *settings;
+  http1_parser_s parser;
   void (*on_request)(http_request_s *request);
   struct http1_protocol_s *next;
   http1_request_s request;
-  ssize_t len; /* used as a persistent socket `read` indication. */
+  size_t len;     /* used as a persistent socket `read` indication. */
+  size_t refresh; /* a flag indicating a request callback was called. */
 } http1_protocol_s;
 
 static void http1_on_data(intptr_t uuid, http1_protocol_s *protocol);
 
 /* *****************************************************************************
 HTTP/1.1 pool
-*/
+***************************************************************************** */
 
 static struct {
   spn_lock_i lock;
@@ -63,7 +64,8 @@ static inline void http1_set_protocol_data(http1_protocol_s *pr) {
       .on_data = (void (*)(intptr_t, protocol_s *))http1_on_data,
       .on_close = (void (*)(intptr_t uuid, protocol_s *))http1_free};
   pr->request.request = (http_request_s){.fd = 0, .http_version = HTTP_V1};
-  pr->request.header_pos = pr->request.buffer_pos = pr->len = 0;
+  pr->refresh = pr->request.header_pos = pr->request.buffer_pos = pr->len = 0;
+  pr->parser = (http1_parser_s){.udata = pr};
 }
 
 static http1_protocol_s *http1_alloc(void) {
@@ -100,188 +102,295 @@ initialize:
 }
 
 /* *****************************************************************************
-HTTP callbacks
-*/
-#define HTTP_BODY_CHUNK_SIZE 3072 // 4096
+HTTP/1.1 parsre callbacks
+***************************************************************************** */
 
-static void http1_on_header_found(http_request_s *request,
-                                  http_header_s *header) {
-  ((http1_request_s *)request)
-      ->headers[((http1_request_s *)request)->header_pos] = *header;
-  ((http1_request_s *)request)->header_pos += 1;
-}
+#define HTTP_BODY_CHUNK_SIZE 4096
 
-/* parse and call callback */
-static void http1_on_data(intptr_t uuid, http1_protocol_s *pr) {
-  ssize_t result;
-  char buff[HTTP_BODY_CHUNK_SIZE];
-  http1_request_s *request = &pr->request;
-  char *buffer = request->buffer;
-  // handle requests with no file data
-  if (request->request.body_file <= 0) {
-    // request headers parsing
-    if (pr->len == 0) {
-      buffer = request->buffer;
-      // make sure headers don't overflow
-      pr->len = sock_read(uuid, buffer + request->buffer_pos,
-                          HTTP1_MAX_HEADER_SIZE - request->buffer_pos);
-      // update buffer read position.
-      request->buffer_pos += pr->len;
-      // if (len > 0) {
-      //   fprintf(stderr, "\n----\nRead from socket, %lu bytes, total
-      //   %lu:\n",
-      //           len, request->buffer_pos);
-      //   for (size_t i = 0; i < request->buffer_pos; i++) {
-      //     fprintf(stderr, "%c", buffer[i] ? buffer[i] : '-');
-      //   }
-      //   fprintf(stderr, "\n");
-      // }
-    }
-    if (pr->len <= 0)
-      goto finished_reading;
-
-    // parse headers
-    result = http1_parse_request_headers(
-        buffer, request->buffer_pos, &request->request, http1_on_header_found);
-    // review result
-    if (result >= 0) { // headers comeplete
-      // are we done?
-      if (request->request.content_length == 0 || request->request.body_str) {
-        goto handle_request;
-      }
-      if (request->request.content_length > pr->settings->max_body_size) {
-        goto body_to_big;
-      }
-      // initialize or submit body data
-      result = http1_parse_request_body(buffer + result, pr->len - result,
-                                        (http_request_s *)request);
-      if (result >= 0) {
-        request->buffer_pos += result;
-        goto handle_request;
-      } else if (result == -1) // parser error
-        goto parser_error;
-      goto parse_body;
-    } else if (result == -1) // parser error
-      goto parser_error;
-    // assume incomplete (result == -2), even if wrong, we're right.
-    pr->len = 0;
-    goto postpone;
-  }
-  if (request->request.body_file > 0) {
-  // fprintf(stderr, "Body File\n");
-  parse_body:
-    buffer = buff;
-    // request body parsing
-    pr->len = sock_read(uuid, buffer, HTTP_BODY_CHUNK_SIZE);
-    if (pr->len <= 0)
-      goto finished_reading;
-    result = http1_parse_request_body(buffer, pr->len, &request->request);
-    if (result >= 0) {
-      goto handle_request;
-    } else if (result == -1) // parser error
-      goto parser_error;
-    if (pr->len < HTTP_BODY_CHUNK_SIZE) // pause parser for more data
-      goto finished_reading;
-    goto parse_body;
-  }
-  goto postpone;
-handle_request:
-  // review required headers / data
-  if (request->request.host == NULL)
+/** called when a request was received. */
+static int http1_on_request(http1_parser_s *parser) {
+  http1_protocol_s *pr = parser->udata;
+  if (!pr)
+    return -1;
+  if (pr->request.request.host == NULL) {
     goto bad_request;
+  }
   http_settings_s *settings = pr->settings;
-  request->request.settings = settings;
+  pr->request.request.settings = settings;
   // make sure udata to NULL, making it available for the user
-  request->request.udata = NULL;
-  // call request callback
-  if (pr && settings &&
-      (request->request.upgrade || settings->public_folder == NULL ||
-       http_response_sendfile2(NULL, &request->request, settings->public_folder,
-                               settings->public_folder_length,
-                               request->request.path, request->request.path_len,
-                               settings->log_static))) {
-    pr->on_request(&request->request);
-    // fprintf(stderr, "Called on_request\n");
+  pr->request.request.udata = NULL;
+  // static file service or call request callback
+  if (pr->request.request.upgrade || settings->public_folder == NULL ||
+      http_response_sendfile2(
+          NULL, &pr->request.request, settings->public_folder,
+          settings->public_folder_length, pr->request.request.path,
+          pr->request.request.path_len, settings->log_static)) {
+    pr->on_request(&pr->request.request);
   }
-  // rotate buffer for HTTP pipelining
-  if ((ssize_t)request->buffer_pos <= result) {
-    pr->len = 0;
-    // fprintf(stderr, "\n----\nAll data consumed.\n");
-  } else {
-    memmove(request->buffer, buffer + result, request->buffer_pos - result);
-    pr->len = request->buffer_pos - result;
-    // fprintf(stderr, "\n----\ndata after move, %lu long:\n%.*s\n", len,
-    //         (int)len, request->buffer);
-  }
-  // fprintf(stderr, "data in buffer, %lu long:\n%.*s\n", len, (int)len,
-  //         request->buffer);
-  // clear request state
-  http1_request_clear(&request->request);
-  request->buffer_pos = pr->len;
-  // make sure to use the correct buffer.
-  buffer = request->buffer;
-/* prevent this connection from hogging the thread by pipelining endless
- * requests.
- */
-postpone:
-  facil_force_event(uuid, FIO_EVENT_ON_DATA);
-  return;
-parser_error:
-  if (request->request.headers_count >= HTTP1_MAX_HEADER_COUNT)
-    goto too_big;
+  pr->refresh = 1;
+  return 0;
 bad_request:
   /* handle generally bad requests */
   {
-    http_response_s *response = http_response_create(&request->request);
+    http_response_s *response = http_response_create(&pr->request.request);
+    if (pr->settings->log_static)
+      http_response_log_start(response);
     response->status = 400;
     if (!pr->settings->public_folder ||
-        http_response_sendfile2(response, &request->request,
+        http_response_sendfile2(response, &pr->request.request,
                                 pr->settings->public_folder,
                                 pr->settings->public_folder_length, "400.html",
                                 8, pr->settings->log_static)) {
+      response->should_close = 1;
       http_response_write_body(response, "Bad Request", 11);
       http_response_finish(response);
     }
-    sock_close(uuid);
-    request->buffer_pos = 0;
-    goto finished_reading;
+    sock_close(pr->request.request.fd);
+    pr->request.buffer_pos = 0;
+  }
+  return -1;
+}
+/** called when a response was received. */
+static int http1_on_response(http1_parser_s *parser) {
+  return -1;
+  (void)parser;
+}
+/** called when a request method is parsed. */
+static int http1_on_method(http1_parser_s *parser, char *method,
+                           size_t method_len) {
+  http1_protocol_s *pr = parser->udata;
+  if (!pr)
+    return -1;
+  pr->request.request.method = method;
+  pr->request.request.method_len = method_len;
+  return 0;
+}
+
+/** called when a response status is parsed. the status_str is the string
+ * without the prefixed numerical status indicator.*/
+static int http1_on_status(http1_parser_s *parser, size_t status,
+                           char *status_str, size_t len) {
+  return -1;
+  (void)parser;
+  (void)status;
+  (void)status_str;
+  (void)len;
+}
+
+/** called when a request path (excluding query) is parsed. */
+static int http1_on_path(http1_parser_s *parser, char *path, size_t path_len) {
+  http1_protocol_s *pr = parser->udata;
+  if (!pr)
+    return -1;
+  pr->request.request.path = path;
+  pr->request.request.path_len = path_len;
+  return 0;
+}
+
+/** called when a request path (excluding query) is parsed. */
+static int http1_on_query(http1_parser_s *parser, char *query,
+                          size_t query_len) {
+  http1_protocol_s *pr = parser->udata;
+  if (!pr)
+    return -1;
+  pr->request.request.query = query;
+  pr->request.request.query_len = query_len;
+  return 0;
+}
+
+/** called when a the HTTP/1.x version is parsed. */
+static int http1_on_http_version(http1_parser_s *parser, char *version,
+                                 size_t len) {
+  http1_protocol_s *pr = parser->udata;
+  if (!pr)
+    return -1;
+  pr->request.request.version = version;
+  pr->request.request.version_len = len;
+  return 0;
+}
+
+/** called when a header is parsed. */
+static int http1_on_header(http1_parser_s *parser, char *name, size_t name_len,
+                           char *data, size_t data_len) {
+  http1_protocol_s *pr = parser->udata;
+  if (!pr || pr->request.header_pos >= HTTP1_MAX_HEADER_COUNT - 1)
+    goto too_big;
+
+/** test for special headers that should be easily accessible **/
+#if HTTP_HEADERS_LOWERCASE
+  if (name_len == 4 && *((uint32_t *)name) == *((uint32_t *)"host")) {
+    pr->request.request.host = data;
+    pr->request.request.host_len = data_len;
+  } else if (name_len == 12 && *((uint32_t *)name) == *((uint32_t *)"cont") &&
+             *((uint64_t *)(name + 4)) == *((uint64_t *)"ent-type")) {
+    pr->request.request.content_type = data;
+    pr->request.request.content_type_len = data_len;
+  } else if (name_len == 7 && *((uint64_t *)name) == *((uint64_t *)"upgrade")) {
+    pr->request.request.upgrade = data;
+    pr->request.request.upgrade_len = data_len;
+  } else if (name_len == 10 && *((uint32_t *)name) == *((uint32_t *)"conn") &&
+             *((uint64_t *)(name + 2)) == *((uint64_t *)"nnection")) {
+    pr->request.request.connection = data;
+    pr->request.request.connection_len = data_len;
   }
+#else
+  if (name_len == 4 && HEADER_NAME_IS_EQ(name, "host", name_len)) {
+    pr->request.request.host = data;
+    pr->request.request.host_len = data_len;
+  } else if (name_len == 12 &&
+             HEADER_NAME_IS_EQ(name, "content-type", name_len)) {
+    pr->request.request.content_type = data;
+    pr->request.request.content_type_len = data_len;
+  } else if (name_len == 7 && HEADER_NAME_IS_EQ(name, "upgrade", name_len)) {
+    pr->request.request.upgrade = data;
+    pr->request.request.upgrade_len = data_len;
+  } else if (name_len == 10 &&
+             HEADER_NAME_IS_EQ(name, "connection", name_len)) {
+    pr->request.request.connection = data;
+    pr->request.request.connection_len = data_len;
+  }
+#endif
+  pr->request.headers[pr->request.header_pos].name = name;
+  pr->request.headers[pr->request.header_pos].name_len = name_len;
+  pr->request.headers[pr->request.header_pos].data = data;
+  pr->request.headers[pr->request.header_pos].data_len = data_len;
+  pr->request.header_pos++;
+  pr->request.request.headers_count++;
+  return 0;
 too_big:
   /* handle oversized headers */
   {
-    http_response_s *response = http_response_create(&request->request);
+    http_response_s *response = http_response_create(&pr->request.request);
+    if (pr->settings->log_static)
+      http_response_log_start(response);
     response->status = 431;
     if (!pr->settings->public_folder ||
-        http_response_sendfile2(response, &request->request,
+        http_response_sendfile2(response, &pr->request.request,
                                 pr->settings->public_folder,
                                 pr->settings->public_folder_length, "431.html",
                                 8, pr->settings->log_static)) {
       http_response_write_body(response, "Request Header Fields Too Large", 31);
       http_response_finish(response);
     }
-    sock_close(uuid);
-    request->buffer_pos = 0;
-    goto finished_reading;
-  body_to_big:
-    /* handle oversized body */
-    {
-      http_response_s *response = http_response_create(&request->request);
-      response->status = 413;
-      if (!pr->settings->public_folder ||
-          http_response_sendfile2(response, &request->request,
-                                  pr->settings->public_folder,
-                                  pr->settings->public_folder_length,
-                                  "413.html", 8, pr->settings->log_static)) {
-        http_response_write_body(response, "Payload Too Large", 17);
-        http_response_finish(response);
-      }
-      sock_close(uuid);
-      request->buffer_pos = 0;
-      goto finished_reading;
+  }
+  return -1;
+}
+
+/** called when a body chunk is parsed. */
+static int http1_on_body_chunk(http1_parser_s *parser, char *data,
+                               size_t data_len) {
+  http1_protocol_s *pr = parser->udata;
+  if (!pr)
+    return -1;
+  if (!parser->state.read) {
+    if (parser->state.content_length > pr->settings->max_body_size)
+      return -1;
+    pr->request.request.content_length = parser->state.content_length;
+    if (pr->request.buffer_pos + parser->state.content_length <
+        HTTP1_MAX_HEADER_SIZE) {
+      pr->request.request.body_str = data;
+    } else {
+// create a temporary file to contain the data.
+#ifdef P_tmpdir
+#if defined(__linux__) /* linux doesn't end with a divider */
+      char template[] = P_tmpdir "/http_request_body_XXXXXXXX";
+#else
+      char template[] = P_tmpdir "http_request_body_XXXXXXXX";
+#endif
+#else
+      char template[] = "/tmp/http_request_body_XXXXXXXX";
+#endif
+      pr->request.request.body_file = mkstemp(template);
+      if (pr->request.request.body_file == -1)
+        return -1;
     }
   }
-finished_reading:
-  pr->len = 0;
+  if (pr->request.request.body_file) {
+    if (write(pr->request.request.body_file, data, data_len) !=
+        (ssize_t)data_len)
+      return -1;
+  } else {
+    /* nothing to do... the parser and `on_data` are doing all the work */
+  }
+  return 0;
+}
+
+/** called when a protocol error occured. */
+static int http1_on_error(http1_parser_s *parser) {
+  http1_protocol_s *pr = parser->udata;
+  if (!pr)
+    return -1;
+  sock_close(pr->request.request.fd);
+  http1_request_clear(&pr->request.request);
+  return 0;
+}
+
+/* *****************************************************************************
+HTTP/1.1 protocol callbacks
+***************************************************************************** */
+
+/* parse and call callback */
+static void http1_on_data(intptr_t uuid, http1_protocol_s *pr) {
+  size_t consumed;
+  char buff[HTTP_BODY_CHUNK_SIZE];
+  http1_request_s *request = &pr->request;
+  char *buffer = request->buffer;
+  ssize_t tmp = 0;
+  // handle requests with no file data
+  if (request->request.body_file <= 0) {
+    // read into the request buffer.
+    tmp = sock_read(uuid, request->buffer + request->buffer_pos,
+                    HTTP1_MAX_HEADER_SIZE - request->buffer_pos);
+    if (tmp > 0) {
+      request->buffer_pos += tmp;
+      pr->len += tmp;
+    } else
+      tmp = 0;
+    buffer = request->buffer + request->buffer_pos - pr->len;
+  } else {
+    buffer = buff;
+    tmp = sock_read(uuid, buffer, HTTP_BODY_CHUNK_SIZE);
+    if (tmp > 0) {
+      request->buffer_pos += tmp;
+      pr->len += tmp;
+    } else
+      tmp = 0;
+  }
+
+  if (pr->len == 0)
+    return;
+
+  // parse HTTP data
+  consumed =
+      http1_fio_parser(.parser = &pr->parser, .buffer = buffer,
+                       .length = pr->len, .on_request = http1_on_request,
+                       .on_response = http1_on_response,
+                       .on_method = http1_on_method,
+                       .on_status = http1_on_status, .on_path = http1_on_path,
+                       .on_query = http1_on_query,
+                       .on_http_version = http1_on_http_version,
+                       .on_header = http1_on_header,
+                       .on_body_chunk = http1_on_body_chunk,
+                       .on_error = http1_on_error);
+
+  // handle leftovers, if any
+  if (pr->refresh) {
+    pr->refresh = 0;
+    if (pr->len > consumed) {
+      memmove(request->buffer, buffer + consumed, pr->len - consumed);
+      pr->len = pr->len - consumed;
+      http1_request_clear(&request->request);
+      request->buffer_pos = pr->len;
+      facil_force_event(uuid, FIO_EVENT_ON_DATA);
+      return;
+    }
+    http1_request_clear(&request->request);
+    pr->len = 0;
+  } else {
+    pr->len = pr->len - consumed;
+  }
+  if (tmp)
+    facil_force_event(uuid, FIO_EVENT_ON_DATA);
 }
 
 /* *****************************************************************************
@@ -353,8 +462,8 @@ is_busy:
 
 busy_no_file:
   sock_write(fd,
-             "HTTP/1.1 503 Service Unavailable\r\nContent-Length: "
-             "13\r\n\r\nServer Busy.",
+             "HTTP/1.1 503 Service Unavailable\r\n"
+             "Content-Length: 13\r\n\r\nServer Busy.",
              68);
   sock_close(fd);
   return NULL;