@velox0/cerver 0.3.1 → 0.4.1

package/runtime/http_parser.c

@@ -2,7 +2,8 @@
  * http_parser.c — Minimal HTTP/1.1 request parser.
  *
  * Parses method, path, query string, and headers from a raw HTTP request.
- * No external dependencies.
+ * All parsing is done IN-PLACE on the caller's buffer — no copies are made.
+ * The caller must keep the buffer alive for the lifetime of the request.
  */
 
 #include "cerver.h"
@@ -17,179 +18,182 @@
 /* ------------------------------------------------------------------ */
 
 static int hex_val(char c) {
-    if (c >= '0' && c <= '9') return c - '0';
-    if (c >= 'a' && c <= 'f') return c - 'a' + 10;
-    if (c >= 'A' && c <= 'F') return c - 'A' + 10;
-    return -1;
+  if (c >= '0' && c <= '9') return c - '0';
+  if (c >= 'a' && c <= 'f') return c - 'a' + 10;
+  if (c >= 'A' && c <= 'F') return c - 'A' + 10;
+  return -1;
 }
 
-static void url_decode(char *str) {
-    char *src = str;
-    char *dst = str;
-
-    while (*src) {
-        if (*src == '%' && src[1] && src[2]) {
-            int hi = hex_val(src[1]);
-            int lo = hex_val(src[2]);
-            if (hi >= 0 && lo >= 0) {
-                *dst++ = (char)((hi << 4) | lo);
-                src += 3;
-                continue;
-            }
-        }
-        if (*src == '+') {
-            *dst++ = ' ';
-            src++;
-            continue;
-        }
-        *dst++ = *src++;
+static void url_decode(char* str) {
+  char* src = str;
+  char* dst = str;
+
+  while (*src) {
+    if (*src == '%' && src[1] && src[2]) {
+      int hi = hex_val(src[1]);
+      int lo = hex_val(src[2]);
+      if (hi >= 0 && lo >= 0) {
+        *dst++ = (char)((hi << 4) | lo);
+        src += 3;
+        continue;
+      }
+    }
+    if (*src == '+') {
+      *dst++ = ' ';
+      src++;
+      continue;
     }
-    *dst = '\0';
+    *dst++ = *src++;
+  }
+  *dst = '\0';
 }
 
 /* ------------------------------------------------------------------ */
-/*  Parse query string: "a=1&b=2" → key-value pairs                  */
+/*  Parse query string IN-PLACE: "a=1&b=2" → key-value pairs         */
 /* ------------------------------------------------------------------ */
 
-static void parse_query_string(char *qs, cerver_request_t *req) {
-    if (!qs || !*qs) return;
-
-    char *saveptr = NULL;
-    char *pair = strtok_r(qs, "&", &saveptr);
-
-    while (pair && req->query_count < CERVER_MAX_QUERY) {
-        char *eq = strchr(pair, '=');
-        if (eq) {
-            *eq = '\0';
-            req->query[req->query_count].key = pair;
-            req->query[req->query_count].value = eq + 1;
-            url_decode((char *)req->query[req->query_count].key);
-            url_decode((char *)req->query[req->query_count].value);
-        } else {
-            req->query[req->query_count].key = pair;
-            req->query[req->query_count].value = "";
-        }
-        req->query_count++;
-        pair = strtok_r(NULL, "&", &saveptr);
+static void parse_query_string(char* qs, cerver_request_t* req) {
+  if (!qs || !*qs) return;
+
+  /* Parse directly on the buffer — no strdup needed */
+  char* p = qs;
+
+  while (*p && req->query_count < CERVER_MAX_QUERY) {
+    char* pair_start = p;
+
+    /* Find end of pair (& or NUL) */
+    while (*p && *p != '&') p++;
+    if (*p == '&') *p++ = '\0';
+
+    char* eq = strchr(pair_start, '=');
+    if (eq) {
+      *eq = '\0';
+      req->query[req->query_count].key = pair_start;
+      req->query[req->query_count].value = eq + 1;
+      url_decode((char*)req->query[req->query_count].key);
+      url_decode((char*)req->query[req->query_count].value);
+    } else {
+      req->query[req->query_count].key = pair_start;
+      req->query[req->query_count].value = "";
     }
+    req->query_count++;
+  }
 }
 
 /* ------------------------------------------------------------------ */
-/*  Parse the HTTP request                                            */
+/*  Parse the HTTP request IN-PLACE                                   */
 /* ------------------------------------------------------------------ */
 
-int cerver_parse_request(const char *raw, size_t len, cerver_request_t *req) {
-    if (!raw || len == 0) return -1;
-
-    /* We need a mutable copy because we'll be inserting NUL terminators */
-    char *buf = malloc(len + 1);
-    if (!buf) return -1;
-    memcpy(buf, raw, len);
-    buf[len] = '\0';
-
-    req->_raw_buf = buf;
-    req->_raw_len = len;
-
-    /* ---- Request line: METHOD PATH HTTP/1.x ---- */
-    char *line_end = strstr(buf, "\r\n");
-    if (!line_end) {
-        free(buf);
-        return -1;
-    }
-    *line_end = '\0';
-
-    /* Method */
-    char *sp1 = strchr(buf, ' ');
-    if (!sp1) { free(buf); return -1; }
-    *sp1 = '\0';
-
-    size_t method_len = (size_t)(sp1 - buf);
-    if (method_len >= sizeof(req->method)) method_len = sizeof(req->method) - 1;
-    memcpy(req->method, buf, method_len);
-    req->method[method_len] = '\0';
-
-    /* Path (and maybe query string) */
-    char *path_start = sp1 + 1;
-    char *sp2 = strchr(path_start, ' ');
-    if (sp2) *sp2 = '\0';
-
-    /* Split path and query string */
-    char *qmark = strchr(path_start, '?');
-    if (qmark) {
-        *qmark = '\0';
-        strncpy(req->query_string, qmark + 1, sizeof(req->query_string) - 1);
-        req->query_string[sizeof(req->query_string) - 1] = '\0';
-    }
-
-    /* Decode and store path */
-    url_decode(path_start);
-    strncpy(req->path, path_start, sizeof(req->path) - 1);
-    req->path[sizeof(req->path) - 1] = '\0';
-
-    /* Normalize trailing slash: "/foo/" → "/foo" (but keep "/" as is) */
-    size_t plen = strlen(req->path);
-    if (plen > 1 && req->path[plen - 1] == '/') {
-        req->path[plen - 1] = '\0';
+int cerver_parse_request(const char* raw, size_t len, cerver_request_t* req) {
+  if (!raw || len == 0) return -1;
+
+  /*
+   * We parse in-place: the caller gives us a mutable buffer (cast away
+   * const — the caller's read_full_request already owns a mutable buffer).
+   * All internal pointers (headers, query, body) reference this buffer.
+   * The caller must keep it alive for the request's lifetime.
+   */
+  char* buf = (char*)raw;
+  buf[len] = '\0'; /* caller ensures buf has capacity for len+1 */
+
+  /* We no longer allocate _raw_buf — the read buffer IS the raw buffer */
+  req->_raw_buf = NULL;
+  req->_raw_len = len;
+
+  /* ---- Request line: METHOD PATH HTTP/1.x ---- */
+  char* line_end = strstr(buf, "\r\n");
+  if (!line_end) return -1;
+  *line_end = '\0';
+
+  /* Method */
+  char* sp1 = strchr(buf, ' ');
+  if (!sp1) return -1;
+  *sp1 = '\0';
+
+  size_t method_len = (size_t)(sp1 - buf);
+  if (method_len >= sizeof(req->method)) method_len = sizeof(req->method) - 1;
+  memcpy(req->method, buf, method_len);
+  req->method[method_len] = '\0';
+
+  /* Path (and maybe query string) */
+  char* path_start = sp1 + 1;
+  char* sp2 = strchr(path_start, ' ');
+  if (sp2) *sp2 = '\0';
+
+  /* Split path and query string */
+  char* qmark = strchr(path_start, '?');
+  if (qmark) {
+    *qmark = '\0';
+    /* Point query_string directly into the buffer */
+    char* qs_start = qmark + 1;
+    size_t qs_len = strlen(qs_start);
+    if (qs_len >= sizeof(req->query_string)) qs_len = sizeof(req->query_string) - 1;
+    memcpy(req->query_string, qs_start, qs_len);
+    req->query_string[qs_len] = '\0';
+
+    /* Parse query params in-place from query_string
+     * (we copied to req->query_string so params point into req memory) */
+    parse_query_string(req->query_string, req);
+  }
+
+  /* Decode and store path */
+  url_decode(path_start);
+  strncpy(req->path, path_start, sizeof(req->path) - 1);
+  req->path[sizeof(req->path) - 1] = '\0';
+
+  /* Normalize trailing slash: "/foo/" → "/foo" (but keep "/" as is) */
+  size_t plen = strlen(req->path);
+  if (plen > 1 && req->path[plen - 1] == '/') {
+    req->path[plen - 1] = '\0';
+  }
+
+  /* ---- Headers ---- */
+  char* hdr_start = line_end + 2; /* skip \r\n */
+  size_t content_length = 0;
+
+  while (hdr_start < buf + len) {
+    char* hdr_end = strstr(hdr_start, "\r\n");
+    if (!hdr_end) break;
+
+    /* Empty line = end of headers */
+    if (hdr_end == hdr_start) {
+      hdr_start = hdr_end + 2;
+      break;
     }
 
-    /* Parse query string */
-    if (req->query_string[0]) {
-        /* We need a mutable copy for strtok */
-        char *qs_copy = strdup(req->query_string);
-        if (qs_copy) {
-            parse_query_string(qs_copy, req);
-            /* Note: keys/values point into qs_copy which we leak intentionally
-               since the request's lifetime is short (one connection). */
-        }
-    }
-
-    /* ---- Headers ---- */
-    char *hdr_start = line_end + 2; /* skip \r\n */
-    size_t content_length = 0;
-
-    while (hdr_start < buf + len) {
-        char *hdr_end = strstr(hdr_start, "\r\n");
-        if (!hdr_end) break;
+    *hdr_end = '\0';
 
-        /* Empty line = end of headers */
-        if (hdr_end == hdr_start) {
-            hdr_start = hdr_end + 2;
-            break;
-        }
-
-        *hdr_end = '\0';
-
-        if (req->header_count < CERVER_MAX_HEADERS) {
-            char *colon = strchr(hdr_start, ':');
-            if (colon) {
-                *colon = '\0';
-                char *val = colon + 1;
-                while (*val == ' ') val++;
+    if (req->header_count < CERVER_MAX_HEADERS) {
+      char* colon = strchr(hdr_start, ':');
+      if (colon) {
+        *colon = '\0';
+        char* val = colon + 1;
+        while (*val == ' ') val++;
 
-                req->headers[req->header_count].key = hdr_start;
-                req->headers[req->header_count].value = val;
-                req->header_count++;
+        req->headers[req->header_count].key = hdr_start;
+        req->headers[req->header_count].value = val;
+        req->header_count++;
 
-                /* Track content-length */
-                if (strcasecmp(hdr_start, "Content-Length") == 0) {
-                    content_length = (size_t)atol(val);
-                }
-            }
+        /* Track content-length */
+        if (strcasecmp(hdr_start, "Content-Length") == 0) {
+          content_length = (size_t)atol(val);
         }
-
-        hdr_start = hdr_end + 2;
+      }
     }
 
-    /* ---- Body (for POST etc.) ---- */
-    if (content_length > 0 && hdr_start < buf + len) {
-        req->body = hdr_start;
-        req->body_len = content_length;
-        /* Ensure we don't read past the buffer */
-        size_t remaining = (size_t)(buf + len - hdr_start);
-        if (req->body_len > remaining) {
-            req->body_len = remaining;
-        }
+    hdr_start = hdr_end + 2;
+  }
+
+  /* ---- Body (for POST etc.) ---- */
+  if (content_length > 0 && hdr_start < buf + len) {
+    req->body = hdr_start;
+    req->body_len = content_length;
+    /* Ensure we don't read past the buffer */
+    size_t remaining = (size_t)(buf + len - hdr_start);
+    if (req->body_len > remaining) {
+      req->body_len = remaining;
     }
+  }
 
-    return 0;
+  return 0;
 }

package/runtime/http_writer.c

@@ -1,7 +1,8 @@
 /*
  * http_writer.c — HTTP/1.1 response writer.
  *
- * Formats a cerver_response_t into raw HTTP bytes and writes to a socket fd.
+ * Uses writev() for zero-copy header+body writes.
+ * Supports keep-alive and Connection: close signaling.
  */
 
 #include "cerver.h"
@@ -10,128 +11,168 @@
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
+#include <sys/uio.h>
 
 /* ------------------------------------------------------------------ */
 /*  Status text lookup                                                */
 /* ------------------------------------------------------------------ */
 
-static const char *status_text(int code) {
-    switch (code) {
-        case 200: return "OK";
-        case 201: return "Created";
-        case 204: return "No Content";
-        case 301: return "Moved Permanently";
-        case 302: return "Found";
-        case 304: return "Not Modified";
-        case 400: return "Bad Request";
-        case 401: return "Unauthorized";
-        case 403: return "Forbidden";
-        case 404: return "Not Found";
-        case 405: return "Method Not Allowed";
-        case 500: return "Internal Server Error";
-        default:  return "Unknown";
-    }
+static const char* status_text(int code) {
+  switch (code) {
+    case 200:
+      return "OK";
+    case 201:
+      return "Created";
+    case 204:
+      return "No Content";
+    case 301:
+      return "Moved Permanently";
+    case 302:
+      return "Found";
+    case 304:
+      return "Not Modified";
+    case 400:
+      return "Bad Request";
+    case 401:
+      return "Unauthorized";
+    case 403:
+      return "Forbidden";
+    case 404:
+      return "Not Found";
+    case 405:
+      return "Method Not Allowed";
+    case 500:
+      return "Internal Server Error";
+    case 503:
+      return "Service Unavailable";
+    default:
+      return "Unknown";
+  }
 }
 
 /* ------------------------------------------------------------------ */
-/*  Write the full response to fd                                     */
+/*  Write the full response to fd using writev                        */
 /* ------------------------------------------------------------------ */
 
-int cerver_write_response(int fd, const cerver_response_t *res) {
-    /* Build the response header */
-    char header[4096];
-    int hlen = 0;
-
-    /* Status line */
-    hlen += snprintf(header + hlen, sizeof(header) - (size_t)hlen,
-                     "HTTP/1.1 %d %s\r\n", res->status, status_text(res->status));
-
-    /* Content-Type */
-    if (res->content_type) {
-        hlen += snprintf(header + hlen, sizeof(header) - (size_t)hlen,
-                         "Content-Type: %s\r\n", res->content_type);
+int cerver_write_response(int fd, const cerver_response_t* res, int keepalive) {
+  /* Build the response header */
+  char header[4096];
+  int hlen = 0;
+
+  /* Status line */
+  hlen += snprintf(header + hlen, sizeof(header) - (size_t)hlen, "HTTP/1.1 %d %s\r\n", res->status,
+                   status_text(res->status));
+
+  /* Content-Type */
+  if (res->content_type) {
+    hlen += snprintf(header + hlen, sizeof(header) - (size_t)hlen, "Content-Type: %s\r\n",
+                     res->content_type);
+  }
+
+  /* Content-Length */
+  hlen += snprintf(header + hlen, sizeof(header) - (size_t)hlen, "Content-Length: %zu\r\n",
+                   res->body_len);
+
+  /* Extra headers */
+  for (int i = 0; i < res->header_count; i++) {
+    hlen += snprintf(header + hlen, sizeof(header) - (size_t)hlen, "%s: %s\r\n",
+                     res->headers[i].key, res->headers[i].value);
+  }
+
+  /* Connection header — honor keep-alive state */
+  if (keepalive && !res->_force_close) {
+    hlen += snprintf(header + hlen, sizeof(header) - (size_t)hlen, "Connection: keep-alive\r\n");
+  } else {
+    hlen += snprintf(header + hlen, sizeof(header) - (size_t)hlen, "Connection: close\r\n");
+  }
+
+  /* Server header */
+  hlen += snprintf(header + hlen, sizeof(header) - (size_t)hlen, "Server: cerver\r\n");
+
+  /* End of headers */
+  hlen += snprintf(header + hlen, sizeof(header) - (size_t)hlen, "\r\n");
+
+  /*
+   * Use writev() to send header + body in a single syscall.
+   * This avoids Nagle interaction and reduces context switches.
+   */
+  if (res->body && res->body_len > 0) {
+    struct iovec iov[2];
+    iov[0].iov_base = header;
+    iov[0].iov_len = (size_t)hlen;
+    iov[1].iov_base = (void*)res->body;
+    iov[1].iov_len = res->body_len;
+
+    size_t total = iov[0].iov_len + iov[1].iov_len;
+    size_t written = 0;
+
+    while (written < total) {
+      ssize_t n = writev(fd, iov, 2);
+      if (n < 0) return -1;
+      written += (size_t)n;
+
+      /* Adjust iov for partial writes */
+      if (written < iov[0].iov_len) {
+        iov[0].iov_base = header + written;
+        iov[0].iov_len -= (size_t)n;
+      } else {
+        /* Header fully sent, adjust body iov */
+        size_t body_sent = written - (size_t)hlen;
+        iov[0].iov_len = 0;
+        iov[1].iov_base = (void*)(res->body + body_sent);
+        iov[1].iov_len = res->body_len - body_sent;
+      }
     }
-
-    /* Content-Length */
-    hlen += snprintf(header + hlen, sizeof(header) - (size_t)hlen,
-                     "Content-Length: %zu\r\n", res->body_len);
-
-    /* Extra headers */
-    for (int i = 0; i < res->header_count; i++) {
-        hlen += snprintf(header + hlen, sizeof(header) - (size_t)hlen,
-                         "%s: %s\r\n",
-                         res->headers[i].key, res->headers[i].value);
-    }
-
-    /* Connection: close (we don't do keep-alive in v0.1) */
-    hlen += snprintf(header + hlen, sizeof(header) - (size_t)hlen,
-                     "Connection: close\r\n");
-
-    /* Server header */
-    hlen += snprintf(header + hlen, sizeof(header) - (size_t)hlen,
-                     "Server: cerver\r\n");
-
-    /* End of headers */
-    hlen += snprintf(header + hlen, sizeof(header) - (size_t)hlen, "\r\n");
-
-    /* Write header */
+  } else {
+    /* No body — just send header */
     ssize_t written = write(fd, header, (size_t)hlen);
     if (written < 0) return -1;
+  }
 
-    /* Write body */
-    if (res->body && res->body_len > 0) {
-        size_t total = 0;
-        while (total < res->body_len) {
-            ssize_t n = write(fd, res->body + total, res->body_len - total);
-            if (n < 0) return -1;
-            total += (size_t)n;
-        }
-    }
-
-    return 0;
+  return 0;
 }
 
 /* ------------------------------------------------------------------ */
 /*  Response helper functions                                         */
 /* ------------------------------------------------------------------ */
 
-void cerver_res_text(cerver_response_t *res, int status, const char *text) {
-    res->status = status;
-    res->content_type = "text/plain; charset=utf-8";
-    res->body = text;
-    res->body_len = strlen(text);
-    res->_body_owned = 0;
+void cerver_res_text(cerver_response_t* res, int status, const char* text) {
+  res->status = status;
+  res->content_type = "text/plain; charset=utf-8";
+  res->body = text;
+  res->body_len = strlen(text);
+  res->_body_owned = 0;
 }
 
-void cerver_res_json(cerver_response_t *res, int status, const char *json) {
-    res->status = status;
-    res->content_type = "application/json; charset=utf-8";
-    res->body = json;
-    res->body_len = strlen(json);
-    res->_body_owned = 0;
+void cerver_res_json(cerver_response_t* res, int status, const char* json) {
+  res->status = status;
+  res->content_type = "application/json; charset=utf-8";
+  res->body = json;
+  res->body_len = strlen(json);
+  res->_body_owned = 0;
 }
 
-void cerver_res_html(cerver_response_t *res, int status, const char *html) {
-    res->status = status;
-    res->content_type = "text/html; charset=utf-8";
-    res->body = html;
-    res->body_len = strlen(html);
-    res->_body_owned = 0;
+void cerver_res_html(cerver_response_t* res, int status, const char* html) {
+  res->status = status;
+  res->content_type = "text/html; charset=utf-8";
+  res->body = html;
+  res->body_len = strlen(html);
+  res->_body_owned = 0;
 }
 
-void cerver_res_file(cerver_response_t *res, int status, const char *mime,
-                     const unsigned char *data, size_t len) {
-    res->status = status;
-    res->content_type = mime;
-    res->body = (const char *)data;
-    res->body_len = len;
-    res->_body_owned = 0;
+void cerver_res_file(cerver_response_t* res, int status, const char* mime,
+                     const unsigned char* data, size_t len) {
+  res->status = status;
+  res->content_type = mime;
+  res->body = (const char*)data;
+  res->body_len = len;
+  res->_body_owned = 0;
 }
 
-void cerver_res_header(cerver_response_t *res, const char *key, const char *val) {
-    if (res->header_count < CERVER_MAX_HEADERS) {
-        res->headers[res->header_count].key = key;
-        res->headers[res->header_count].value = val;
-        res->header_count++;
-    }
+void cerver_res_header(cerver_response_t* res, const char* key, const char* val) {
+  if (res->header_count < CERVER_MAX_HEADERS) {
+    res->headers[res->header_count].key = key;
+    res->headers[res->header_count].value = val;
+    res->header_count++;
+  }
 }