1 files changed, 116 insertions, 64 deletions

diff --git a/ot_http.c b/ot_http.c
index 6bf343c..2216453 100644
--- a/ot_http.c
+++ b/ot_http.c
@@ -14,9 +14,6 @@
 #include <sys/types.h>
 #include <unistd.h>
 
-/* Libowfat */
-#include "io.h"
-
 /* Opentracker */
 #include "ot_accesslist.h"
 #include "ot_fullscrape.h"
@@ -25,9 +22,12 @@
 #include "ot_ip.h"
 #include "ot_mutex.h"
 #include "ot_scan.h"
+#include "ot_event.h"
 #include "ot_fdstate.h"
+#include "ot_vector.h"
+#include "ot_fmt.h"
 #include "ot_stats.h"
-#include "scan_urlencoded_query.h"
+#include "ot_urlencoded.h"
 #include "trackerlogic.h"
 
 #define OT_MAXMULTISCRAPE_COUNT 64
@@ -43,7 +43,7 @@ static void http_senddata(const int64_t sock, struct ot_workstruct *ws) {
   ssize_t           written_size;
 
   if (!cookie) {
-    io_close(sock);
+    event_del((int)sock), close((int)sock);
     return;
   }
 
@@ -67,7 +67,7 @@ static void http_senddata(const int64_t sock, struct ot_workstruct *ws) {
   if ((written_size < 0) || ((written_size == ws->reply_size) && !ws->keep_alive)) {
     buf_reset(&cookie->request);
     free(cookie);
-    io_close(sock);
+    event_del((int)sock), close((int)sock);
     return;
   }
 
@@ -77,7 +77,7 @@ static void http_senddata(const int64_t sock, struct ot_workstruct *ws) {
     if (!(outbuf = malloc(ws->reply_size - written_size))) {
       buf_reset(&cookie->request);
       free(cookie);
-      io_close(sock);
+      event_del((int)sock), close((int)sock);
       return;
     }
 
@@ -88,7 +88,7 @@ static void http_senddata(const int64_t sock, struct ot_workstruct *ws) {
         free(outbuf);
         buf_reset(&cookie->request);
         free(cookie);
-        io_close(sock);
+        event_del((int)sock), close((int)sock);
         return;
       }
     }
@@ -98,9 +98,9 @@ static void http_senddata(const int64_t sock, struct ot_workstruct *ws) {
     /* writeable short data sockets just have a tcp timeout */
     if (!ws->keep_alive) {
       fdstate_set_expiry(sock, 0);
-      io_dontwantread(sock);
+      http_interest_drop(sock, cookie, EVENT_IN);
     }
-    io_wantwrite(sock);
+    http_interest_add(sock, cookie, EVENT_OUT);
   }
 }
 
@@ -113,6 +113,21 @@ static void http_senddata(const int64_t sock, struct ot_workstruct *ws) {
 #define HTTPERROR_403_IP         return http_issue_error(sock, ws, CODE_HTTPERROR_403_IP)
 #define HTTPERROR_404            return http_issue_error(sock, ws, CODE_HTTPERROR_404)
 #define HTTPERROR_500            return http_issue_error(sock, ws, CODE_HTTPERROR_500)
+static void http_interest(const int64_t sock, struct http_data *cookie, int what) {
+  if (cookie->interest == what)
+    return;
+  cookie->interest = what;
+  event_modify((int)sock, what, fdstate_generation((int)sock));
+}
+
+void http_interest_add(const int64_t sock, struct http_data *cookie, int what) {
+  http_interest(sock, cookie, cookie->interest | what);
+}
+
+void http_interest_drop(const int64_t sock, struct http_data *cookie, int what) {
+  http_interest(sock, cookie, cookie->interest & ~what);
+}
+
 ssize_t http_issue_error(const int64_t sock, struct ot_workstruct *ws, int code) {
   const char *error_code[] = {"302 Found",      "400 Invalid Request", "400 Invalid Request", "400 Invalid Request",      "402 Payment Required",
                         "403 Not Modest", "403 Access Denied",   "404 Not Found",       "500 Internal Server Error"};
@@ -157,7 +172,7 @@ ssize_t http_sendiovecdata(const int64_t sock, struct ot_workstruct *ws, size_t
 
   /* If we came here, wait for the answer is over */
   if (cookie->flag & STRUCT_HTTP_FLAG_WAITINGFORTASK) {
-    io_dontwantread(sock);
+    http_interest_drop(sock, cookie, EVENT_IN);
     cookie->flag &= ~STRUCT_HTTP_FLAG_WAITINGFORTASK;
   }
 
@@ -208,7 +223,7 @@ ssize_t http_sendiovecdata(const int64_t sock, struct ot_workstruct *ws, size_t
   }
 
   fdstate_set_expiry(sock, g_now_seconds + OT_CLIENT_TIMEOUT_SEND);
-  io_wantwrite(sock);
+  http_interest_add(sock, cookie, EVENT_OUT);
   return 0;
 }
 
@@ -219,7 +234,6 @@ static ssize_t http_handle_stats(const int64_t sock, struct ot_workstruct *ws, c
                                               {"scrp", TASK_STATS_SCRAPE},
                                               {"udp4", TASK_STATS_UDP},
                                               {"tcp4", TASK_STATS_TCP},
-                                              {"busy", TASK_STATS_BUSY_NETWORKS},
                                               {"torr", TASK_STATS_TORRENTS},
                                               {"fscr", TASK_STATS_FULLSCRAPE},
                                               {"s24s", TASK_STATS_SLASH24S},
@@ -244,6 +258,7 @@ static ssize_t http_handle_stats(const int64_t sock, struct ot_workstruct *ws, c
                                                 {"txtp", TASK_FULLSCRAPE_TPB_ASCII_PLUS}, {NULL, -3}};
 
   struct http_data *cookie = fdstate_cookie(sock);
+  char             *reply;
   int               mode = TASK_STATS_PEERS, scanon = 1, format = 0;
 
   /* A socket without one is a dead socket, which is what http_sendiovecdata
@@ -257,21 +272,21 @@ static ssize_t http_handle_stats(const int64_t sock, struct ot_workstruct *ws, c
 #endif
 
   while (scanon) {
-    switch (scan_find_keywords(keywords_main, &read_ptr, SCAN_SEARCHPATH_PARAM)) {
+    switch (urlencoded_match_keyword(keywords_main, &read_ptr, SCAN_SEARCHPATH_PARAM)) {
     case -2:
       scanon = 0;
       break; /* TERMINATOR */
     case -1:
       HTTPERROR_400_PARAM; /* PARSE ERROR */
     case -3:
-      scan_urlencoded_skipvalue(&read_ptr);
+      urlencoded_skip_value(&read_ptr);
       break;
     case 1: /* matched "mode" */
-      if ((mode = scan_find_keywords(keywords_mode, &read_ptr, SCAN_SEARCHPATH_VALUE)) <= 0)
+      if ((mode = urlencoded_match_keyword(keywords_mode, &read_ptr, SCAN_SEARCHPATH_VALUE)) <= 0)
         HTTPERROR_400_PARAM;
       break;
     case 2: /* matched "format" */
-      if ((format = scan_find_keywords(keywords_format, &read_ptr, SCAN_SEARCHPATH_VALUE)) <= 0)
+      if ((format = urlencoded_match_keyword(keywords_format, &read_ptr, SCAN_SEARCHPATH_VALUE)) <= 0)
         HTTPERROR_400_PARAM;
       break;
     case 3:
@@ -303,7 +318,7 @@ static ssize_t http_handle_stats(const int64_t sock, struct ot_workstruct *ws, c
     /* Clients waiting for us should not easily timeout */
     fdstate_set_expiry(sock, 0);
     fullscrape_deliver(sock, format);
-    io_dontwantread(sock);
+    http_interest_drop(sock, cookie, EVENT_IN);
     return ws->reply_size = -2;
   }
 #endif
@@ -320,7 +335,9 @@ static ssize_t http_handle_stats(const int64_t sock, struct ot_workstruct *ws, c
   }
 
   /* Simple stats can be answerred immediately */
-  return ws->reply_size = return_stats_for_tracker(ws->reply, mode, 0);
+  reply = ws->reply;
+  return_stats_for_tracker(&reply, ws->outbuf + G_OUTBUF_SIZE, mode, 0);
+  return ws->reply_size = reply - ws->reply;
 }
 
 #ifdef WANT_MODEST_FULLSCRAPES
@@ -396,17 +413,20 @@ static ssize_t http_handle_fullscrape(const int64_t sock, struct ot_workstruct *
   /* Clients waiting for us should not easily timeout */
   fdstate_set_expiry(sock, 0);
   fullscrape_deliver(sock, format);
-  io_dontwantread(sock);
+  http_interest_drop(sock, cookie, EVENT_IN);
   return ws->reply_size = -2;
 }
 #endif
 
+static int compare_hash(const void *left, const void *right) { return memcmp(left, right, sizeof(ot_hash)); }
+
 static ssize_t http_handle_scrape(const int64_t sock, struct ot_workstruct *ws, char *read_ptr) {
   static const ot_keywords keywords_scrape[] = {{"info_hash", 1}, {NULL, -3}};
 
-  ot_hash *multiscrape_buf   = (ot_hash *)ws->request;
-  int      scanon = 1;
-  size_t   numwant = 0;
+  ot_hash *multiscrape_buf = (ot_hash *)ws->request;
+  char    *reply           = ws->reply;
+  int      scanon          = 1;
+  size_t   i, unique, numwant = 0;
 
   /* This is to hack around stupid clients that send "scrape ?info_hash" */
   if (read_ptr[-1] != '?') {
@@ -418,18 +438,18 @@ static ssize_t http_handle_scrape(const int64_t sock, struct ot_workstruct *ws,
   }
 
   while (scanon) {
-    switch (scan_find_keywords(keywords_scrape, &read_ptr, SCAN_SEARCHPATH_PARAM)) {
+    switch (urlencoded_match_keyword(keywords_scrape, &read_ptr, SCAN_SEARCHPATH_PARAM)) {
     case -2:
       scanon = 0;
       break; /* TERMINATOR */
     default:
       HTTPERROR_400_PARAM; /* PARSE ERROR */
     case -3:
-      scan_urlencoded_skipvalue(&read_ptr);
+      urlencoded_skip_value(&read_ptr);
       break;
     case 1: /* matched "info_hash" */
       /* ignore this, when we have less than 20 bytes */
-      if (scan_urlencoded_query(&read_ptr, (char *)(multiscrape_buf + numwant++), SCAN_SEARCHPATH_VALUE) != (ssize_t)sizeof(ot_hash))
+      if (urlencoded_parse(&read_ptr, (char *)(multiscrape_buf + numwant++), SCAN_SEARCHPATH_VALUE) != (ssize_t)sizeof(ot_hash))
         HTTPERROR_400_PARAM;
       break;
     }
@@ -443,8 +463,17 @@ static ssize_t http_handle_scrape(const int64_t sock, struct ot_workstruct *ws,
   if (numwant > OT_MAXMULTISCRAPE_COUNT)
     numwant = OT_MAXMULTISCRAPE_COUNT;
 
+  /* A bencoded dictionary has its keys in order and names each one once, so
+     the answer cannot just follow the order the client asked in */
+  qsort(multiscrape_buf, numwant, sizeof(ot_hash), compare_hash);
+  for (i = unique = 1; i < numwant; ++i)
+    if (memcmp(multiscrape_buf[i], multiscrape_buf[unique - 1], sizeof(ot_hash)))
+      memcpy(multiscrape_buf[unique++], multiscrape_buf[i], sizeof(ot_hash));
+  numwant = unique;
+
   /* Enough for http header + whole scrape string */
-  ws->reply_size = return_tcp_scrape_for_torrent((const ot_hash *)multiscrape_buf, numwant, ws->reply);
+  return_tcp_scrape_for_torrent((const ot_hash *)multiscrape_buf, numwant, &reply, ws->outbuf + G_OUTBUF_SIZE);
+  ws->reply_size = reply - ws->reply;
   stats_issue_event(EVENT_SCRAPE, FLAG_TCP, ws->reply_size);
   return ws->reply_size;
 }
@@ -480,9 +509,20 @@ static ot_keywords keywords_announce[] = {{"port", 1},    {"left", 2}, {"event",
 #endif
                                           {"peer_id", 9}, {NULL, -3}};
 static ot_keywords keywords_announce_event[] = {{"completed", 1}, {"stopped", 2}, {NULL, -3}};
+
+/* For the replies that are one fixed string and nothing else, where the only
+   thing the caller wants back is how long it turned out */
+static ssize_t     reply_literal(struct ot_workstruct *ws, const char *text) {
+  char *reply = ws->reply;
+
+  fmt_bytes(&reply, ws->outbuf + G_OUTBUF_SIZE, text, strlen(text));
+  return reply - ws->reply;
+}
+
 static ssize_t     http_handle_announce(const int64_t sock, struct ot_workstruct *ws, char *read_ptr) {
   size_t            numwant;
-  int               tmp, scanon;
+  int64_t           tmp;
+  int               scanon;
   unsigned short    port = 0;
   char             *write_ptr;
   ssize_t           len;
@@ -501,7 +541,7 @@ static ssize_t     http_handle_announce(const int64_t sock, struct ot_workstruct
   if (accesslist_is_blessed(cookie->ip, OT_PERMISSION_MAY_PROXY)) {
     ot_ip6 proxied_ip;
     char  *fwd = http_header(ws->request, ws->header_size, "x-forwarded-for");
-    if (fwd && ip_scan(fwd, proxied_ip)) {
+    if (fwd && ip_parse(fwd, proxied_ip)) {
       OT_SETIP(ws->peer, proxied_ip);
     } else
       OT_SETIP(ws->peer, cookie->ip);
@@ -518,32 +558,32 @@ static ssize_t     http_handle_announce(const int64_t sock, struct ot_workstruct
   scanon                = 1;
 
   while (scanon) {
-    switch (scan_find_keywords(keywords_announce, &read_ptr, SCAN_SEARCHPATH_PARAM)) {
+    switch (urlencoded_match_keyword(keywords_announce, &read_ptr, SCAN_SEARCHPATH_PARAM)) {
     case -2:
       scanon = 0;
       break; /* TERMINATOR */
     case -1:
       HTTPERROR_400_PARAM; /* PARSE ERROR */
     case -3:
-      scan_urlencoded_skipvalue(&read_ptr);
+      urlencoded_skip_value(&read_ptr);
       break;
     case 1: /* matched "port" */
-      len = scan_urlencoded_query(&read_ptr, write_ptr = read_ptr, SCAN_SEARCHPATH_VALUE);
-      if ((len <= 0) || scan_fixed_int(write_ptr, len, &tmp) || (tmp > 0xffff))
+      len = urlencoded_parse(&read_ptr, write_ptr = read_ptr, SCAN_SEARCHPATH_VALUE);
+      if ((len <= 0) || scan_int(write_ptr, len, &tmp) || (tmp > 0xffff))
         HTTPERROR_400_PARAM;
-      port = htons(tmp);
+      port = htons((uint16_t)tmp);
       OT_SETPORT(&ws->peer, &port);
       break;
     case 2: /* matched "left" */
-      if ((len = scan_urlencoded_query(&read_ptr, write_ptr = read_ptr, SCAN_SEARCHPATH_VALUE)) <= 0)
+      if ((len = urlencoded_parse(&read_ptr, write_ptr = read_ptr, SCAN_SEARCHPATH_VALUE)) <= 0)
         HTTPERROR_400_PARAM;
-      if (scan_fixed_int(write_ptr, len, &tmp))
+      if (scan_int(write_ptr, len, &tmp))
         tmp = 0;
       if (!tmp)
         OT_PEERFLAG(&ws->peer) |= PEER_FLAG_SEEDING;
       break;
     case 3: /* matched "event" */
-      switch (scan_find_keywords(keywords_announce_event, &read_ptr, SCAN_SEARCHPATH_VALUE)) {
+      switch (urlencoded_match_keyword(keywords_announce_event, &read_ptr, SCAN_SEARCHPATH_VALUE)) {
       case -1:
         HTTPERROR_400_PARAM;
       case 1: /* matched "completed" */
@@ -557,18 +597,18 @@ static ssize_t     http_handle_announce(const int64_t sock, struct ot_workstruct
       }
       break;
     case 4: /* matched "numwant" */
-      len = scan_urlencoded_query(&read_ptr, write_ptr = read_ptr, SCAN_SEARCHPATH_VALUE);
-      if ((len <= 0) || scan_fixed_int(write_ptr, len, &tmp))
+      len = urlencoded_parse(&read_ptr, write_ptr = read_ptr, SCAN_SEARCHPATH_VALUE);
+      if ((len <= 0) || scan_int(write_ptr, len, &tmp))
         HTTPERROR_400_PARAM;
       if (tmp < 0)
         tmp = 50;
       if (tmp > 200)
         tmp = 200;
-      numwant = tmp;
+      numwant = (size_t)tmp;
       break;
     case 5: /* matched "compact" */
-      len = scan_urlencoded_query(&read_ptr, write_ptr = read_ptr, SCAN_SEARCHPATH_VALUE);
-      if ((len <= 0) || scan_fixed_int(write_ptr, len, &tmp))
+      len = urlencoded_parse(&read_ptr, write_ptr = read_ptr, SCAN_SEARCHPATH_VALUE);
+      if ((len <= 0) || scan_int(write_ptr, len, &tmp))
         HTTPERROR_400_PARAM;
       if (!tmp)
         HTTPERROR_400_COMPACT;
@@ -577,7 +617,7 @@ static ssize_t     http_handle_announce(const int64_t sock, struct ot_workstruct
       if (ws->hash)
         HTTPERROR_400_DOUBLEHASH;
       /* ignore this, when we have less than 20 bytes */
-      if (scan_urlencoded_query(&read_ptr, write_ptr = read_ptr, SCAN_SEARCHPATH_VALUE) != 20)
+      if (urlencoded_parse(&read_ptr, write_ptr = read_ptr, SCAN_SEARCHPATH_VALUE) != 20)
         HTTPERROR_400_PARAM;
       ws->hash = (ot_hash *)write_ptr;
       break;
@@ -585,9 +625,9 @@ static ssize_t     http_handle_announce(const int64_t sock, struct ot_workstruct
     case 7: /* matched "ip" */
     {
       char *tmp_buf1 = ws->reply, *tmp_buf2 = ws->reply + 16;
-      len           = scan_urlencoded_query(&read_ptr, tmp_buf2, SCAN_SEARCHPATH_VALUE);
+      len           = urlencoded_parse(&read_ptr, tmp_buf2, SCAN_SEARCHPATH_VALUE);
       tmp_buf2[len] = 0;
-      if ((len <= 0) || !ip_scan(tmp_buf2, tmp_buf1))
+      if ((len <= 0) || ip_parse(tmp_buf2, tmp_buf1) != (size_t)len)
         HTTPERROR_400_PARAM;
       OT_SETIP(&ws->peer, tmp_buf1);
     } break;
@@ -601,21 +641,21 @@ static ssize_t     http_handle_announce(const int64_t sock, struct ot_workstruct
       uint64_t     value;
       signed short parsed, bits;
 
-      len          = scan_urlencoded_query(&read_ptr, tmp_buf, SCAN_SEARCHPATH_VALUE);
+      len          = urlencoded_parse(&read_ptr, tmp_buf, SCAN_SEARCHPATH_VALUE);
       tmp_buf[len] = 0;
       if (len <= 0)
         HTTPERROR_400_PARAM;
       if (*tmp_buf == '-') {
         loglist_reset();
-        return ws->reply_size = sprintf(ws->reply, "Successfully removed.\n");
+        return ws->reply_size = reply_literal(ws, "Successfully removed.\n");
       }
-      parsed = ip_scan(tmp_buf, net.address);
+      parsed = ip_parse(tmp_buf, net.address);
       if (!parsed)
         HTTPERROR_400_PARAM;
       if (tmp_buf[parsed++] != '/')
         bits = 128;
       else {
-        parsed = scan_udec(tmp_buf + parsed, &value, 128);
+        parsed = scan_uint(tmp_buf + parsed, &value, 128);
         if (!parsed)
           HTTPERROR_400_PARAM;
         bits = (signed short)value;
@@ -624,13 +664,13 @@ static ssize_t     http_handle_announce(const int64_t sock, struct ot_workstruct
       }
       net.bits = bits;
       loglist_add_network(&net);
-      return ws->reply_size = sprintf(ws->reply, "Successfully added.\n");
+      return ws->reply_size = reply_literal(ws, "Successfully added.\n");
       //}
     } break;
 #endif
     case 9: /* matched "peer_id" */
       /* ignore this, when we have less than 20 bytes */
-      if (scan_urlencoded_query(&read_ptr, write_ptr = read_ptr, SCAN_SEARCHPATH_VALUE) != 20)
+      if (urlencoded_parse(&read_ptr, write_ptr = read_ptr, SCAN_SEARCHPATH_VALUE) != 20)
         HTTPERROR_400_PARAM;
       ws->peer_id = write_ptr;
       break;
@@ -647,7 +687,7 @@ static ssize_t     http_handle_announce(const int64_t sock, struct ot_workstruct
 
   /* Scanned whole query string */
   if (!ws->hash)
-    return ws->reply_size = sprintf(ws->reply, "d14:failure reason80:Your client forgot to send your torrent's info_hash. Please upgrade your client.e");
+    return ws->reply_size = reply_literal(ws, "d14:failure reason80:Your client forgot to send your torrent's info_hash. Please upgrade your client.e");
 
   if (OT_PEERFLAG(&ws->peer) & PEER_FLAG_STOPPED)
     ws->reply_size = remove_peer_from_torrent(FLAG_TCP, ws);
@@ -697,6 +737,24 @@ ssize_t http_handle_request(const int64_t sock, struct ot_workstruct *ws) {
   /* Tell subroutines where to put reply data */
   ws->reply = ws->outbuf + SUCCESS_HTTP_HEADER_LENGTH;
 
+  /* Find out if the client wants to keep this connection alive, before any
+     subroutine gets to answer: an error reply finishes with the connection
+     on its way out, and ws outlives the connection it was serving */
+  ws->keep_alive = 0;
+#ifdef WANT_KEEPALIVE
+  if ((write_ptr = http_header(ws->request, ws->header_size, "connection")) && (*write_ptr == 'K' || *write_ptr == 'k'))
+    ws->keep_alive = 1;
+#endif
+  {
+    struct http_data *connection = fdstate_cookie(sock);
+    if (connection) {
+      if (ws->keep_alive)
+        connection->flag |= STRUCT_HTTP_FLAG_KEEPALIVE;
+      else
+        connection->flag &= ~STRUCT_HTTP_FLAG_KEEPALIVE;
+    }
+  }
+
   /* This one implicitely tests strlen < 5, too -- remember, it is \n terminated */
   if (memcmp(read_ptr, "GET /", 5))
     HTTPERROR_400;
@@ -709,7 +767,7 @@ ssize_t http_handle_request(const int64_t sock, struct ot_workstruct *ws) {
      In reality we abandoned requiring the url to be correct. This now
      only decodes url encoded characters, we check for announces and
      scrapes by looking for "a*" or "sc" */
-  len = scan_urlencoded_query(&read_ptr, write_ptr = read_ptr, SCAN_PATH);
+  len = urlencoded_parse(&read_ptr, write_ptr = read_ptr, SCAN_PATH);
 
   /* If parsing returned an error, leave with not found */
   if (g_redirecturl && (len == -2))
@@ -733,14 +791,6 @@ ssize_t http_handle_request(const int64_t sock, struct ot_workstruct *ws) {
   else
     HTTPERROR_404;
 
-  /* Find out if the client wants to keep this connection alive */
-  ws->keep_alive = 0;
-#ifdef WANT_KEEPALIVE
-  read_ptr = http_header(ws->request, ws->header_size, "connection");
-  if (read_ptr && (*read_ptr == 'K' || *read_ptr == 'k'))
-    ws->keep_alive = 1;
-#endif
-
   /* If routines handled sending themselves, just return */
   if (ws->reply_size == -2)
     return 0;
@@ -758,9 +808,11 @@ ssize_t http_handle_request(const int64_t sock, struct ot_workstruct *ws) {
   reply_off       = SUCCESS_HTTP_SIZE_OFF - snprintf(ws->outbuf, 0, "%zd", ws->reply_size);
   ws->reply       = ws->outbuf + reply_off;
 
-  /* 2. Now we sprintf our header so that sprintf writes its terminating '\0' exactly one byte before content starts. Complete
-     packet size is increased by size of header plus one byte '\n', we will copy over '\0' in next step */
-  ws->reply_size += 1 + sprintf(ws->reply, "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nContent-Length: %zd\r\n\r", ws->reply_size);
+  /* 2. Now we write the header so that its terminating '\0' lands exactly one byte before the content starts. The bound is the
+     space step 1 reserved, so the '\0' falls where step 3 expects it. Complete packet size is increased by size of header plus
+     one byte '\n', we will copy over '\0' in next step */
+  ws->reply_size += 1 + snprintf(ws->reply, (size_t)(SUCCESS_HTTP_HEADER_LENGTH - reply_off),
+                                 "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nContent-Length: %zd\r\n\r", ws->reply_size);
 
   /* 3. Finally we join both blocks neatly */
   ws->outbuf[SUCCESS_HTTP_HEADER_LENGTH - 1] = '\n';