@velox0/cerver 0.3.0 → 0.4.0

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"
@@ -48,59 +49,65 @@ static void url_decode(char *str) {
 }
 
 /* ------------------------------------------------------------------ */
-/*  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);
+    /* Parse directly on the buffer — no strdup needed */
+    char *p = qs;
 
-    while (pair && req->query_count < CERVER_MAX_QUERY) {
-        char *eq = strchr(pair, '=');
+    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;
+            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;
+            req->query[req->query_count].key = pair_start;
             req->query[req->query_count].value = "";
         }
         req->query_count++;
-        pair = strtok_r(NULL, "&", &saveptr);
     }
 }
 
 /* ------------------------------------------------------------------ */
-/*  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;
+    /*
+     * 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) {
-        free(buf);
-        return -1;
-    }
+    if (!line_end) return -1;
     *line_end = '\0';
 
     /* Method */
     char *sp1 = strchr(buf, ' ');
-    if (!sp1) { free(buf); return -1; }
+    if (!sp1) return -1;
     *sp1 = '\0';
 
     size_t method_len = (size_t)(sp1 - buf);
@@ -117,8 +124,16 @@ int cerver_parse_request(const char *raw, size_t len, cerver_request_t *req) {
     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';
+        /* 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 */
@@ -132,17 +147,6 @@ int cerver_parse_request(const char *raw, size_t len, cerver_request_t *req) {
         req->path[plen - 1] = '\0';
     }
 
-    /* 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;

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,6 +11,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
+#include <sys/uio.h>
 
 /* ------------------------------------------------------------------ */
 /*  Status text lookup                                                */
@@ -29,15 +31,16 @@ static const char *status_text(int code) {
         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) {
+int cerver_write_response(int fd, const cerver_response_t *res, int keepalive) {
     /* Build the response header */
     char header[4096];
     int hlen = 0;
@@ -63,9 +66,14 @@ int cerver_write_response(int fd, const cerver_response_t *res) {
                          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");
+    /* 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,
@@ -74,18 +82,41 @@ int cerver_write_response(int fd, const cerver_response_t *res) {
     /* End of headers */
     hlen += snprintf(header + hlen, sizeof(header) - (size_t)hlen, "\r\n");
 
-    /* Write header */
-    ssize_t written = write(fd, header, (size_t)hlen);
-    if (written < 0) return -1;
-
-    /* Write body */
+    /*
+     * 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) {
-        size_t total = 0;
-        while (total < res->body_len) {
-            ssize_t n = write(fd, res->body + total, res->body_len - total);
+        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;
-            total += (size_t)n;
+            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;
+            }
         }
+    } else {
+        /* No body — just send header */
+        ssize_t written = write(fd, header, (size_t)hlen);
+        if (written < 0) return -1;
     }
 
     return 0;

package/runtime/router.c

@@ -3,6 +3,7 @@
  *
  * Matches incoming requests against registered route patterns.
  * Supports static paths and dynamic segments (:param).
+ * Supports dispatch override for compile-time generated dispatch.
  */
 
 #include "cerver.h"
@@ -42,6 +43,30 @@ const char *cerver_req_header(const cerver_request_t *req, const char *key) {
     return NULL;
 }
 
+/* ------------------------------------------------------------------ */
+/*  Connection lifecycle helpers                                      */
+/* ------------------------------------------------------------------ */
+
+/*
+ * Returns 1 if the client sent "Connection: close" or is HTTP/1.0
+ * without an explicit "Connection: keep-alive".
+ */
+int cerver_req_wants_close(const cerver_request_t *req) {
+    const char *conn = cerver_req_header(req, "Connection");
+    if (conn && strcasecmp(conn, "close") == 0) return 1;
+    /* HTTP/1.0 without explicit keep-alive → close */
+    /* (We don't track HTTP version separately, so default keep-alive for 1.1) */
+    return 0;
+}
+
+/* ------------------------------------------------------------------ */
+/*  Server configuration helpers                                      */
+/* ------------------------------------------------------------------ */
+
+void cerver_set_dispatch(cerver_server_t *srv, cerver_dispatch_fn fn) {
+    srv->dispatch_override = fn;
+}
+
 /* ------------------------------------------------------------------ */
 /*  Pattern matching with dynamic segment extraction                  */
 /* ------------------------------------------------------------------ */
@@ -50,11 +75,7 @@ const char *cerver_req_header(const cerver_request_t *req, const char *key) {
  * Match a route pattern against a request path.
  * Pattern segments starting with ':' are dynamic and extract values.
  *
- * Examples:
- *   pattern="/items/:id"  path="/items/123"  → match, id="123"
- *   pattern="/"          path="/"             → match
- *   pattern="/api/data"  path="/api/data"     → match
- *   pattern="/api/data"  path="/api/other"    → no match
+ * Uses manual segment iteration instead of strtok_r for speed.
  */
 int cerver_route_match(const cerver_route_t *route, cerver_request_t *req) {
     /* Method must match */
@@ -70,64 +91,58 @@ int cerver_route_match(const cerver_route_t *route, cerver_request_t *req) {
         return 1;
     }
 
-    /* Segment-by-segment matching */
-    /* We'll work with copies so we can tokenize */
-    char pat_buf[CERVER_MAX_PATH];
-    char path_buf[CERVER_MAX_PATH];
-    strncpy(pat_buf, pattern, sizeof(pat_buf) - 1);
-    pat_buf[sizeof(pat_buf) - 1] = '\0';
-    strncpy(path_buf, path, sizeof(path_buf) - 1);
-    path_buf[sizeof(path_buf) - 1] = '\0';
-
-    /* Split into segments */
-    char *pat_segments[64];
-    char *path_segments[64];
-    int pat_count = 0;
-    int path_count = 0;
-
-    char *saveptr;
-    char *tok;
-
-    tok = strtok_r(pat_buf, "/", &saveptr);
-    while (tok && pat_count < 64) {
-        pat_segments[pat_count++] = tok;
-        tok = strtok_r(NULL, "/", &saveptr);
-    }
-
-    tok = strtok_r(path_buf, "/", &saveptr);
-    while (tok && path_count < 64) {
-        path_segments[path_count++] = tok;
-        tok = strtok_r(NULL, "/", &saveptr);
-    }
-
-    /* Segment counts must match */
-    if (pat_count != path_count) {
+    /* No dynamic segments? Then the strcmp above was definitive */
+    if (!strchr(pattern, ':')) {
         return 0;
     }
 
-    /* Match each segment */
-    /* Reset params before populating */
+    /* Segment-by-segment matching without strtok_r */
+    const char *pp = pattern;  /* pattern pointer */
+    const char *rp = path;     /* request path pointer */
+
     int saved_params = req->params_count;
 
-    for (int i = 0; i < pat_count; i++) {
-        if (pat_segments[i][0] == ':') {
+    /* Skip leading '/' */
+    if (*pp == '/') pp++;
+    if (*rp == '/') rp++;
+
+    while (*pp && *rp) {
+        /* Extract pattern segment */
+        const char *pp_seg = pp;
+        while (*pp && *pp != '/') pp++;
+        size_t pp_len = (size_t)(pp - pp_seg);
+
+        /* Extract path segment */
+        const char *rp_seg = rp;
+        while (*rp && *rp != '/') rp++;
+        size_t rp_len = (size_t)(rp - rp_seg);
+
+        if (pp_seg[0] == ':') {
             /* Dynamic segment — extract parameter */
             if (req->params_count < CERVER_MAX_PARAMS) {
-                /* The key is the segment name without ':' */
-                /* We need stable storage — use the request's internal structures.
-                   Since we're in the request's lifetime, we can use strdup. */
-                req->params[req->params_count].key = pat_segments[i] + 1;
-                req->params[req->params_count].value = path_segments[i];
+                req->params[req->params_count].key = pp_seg + 1;
+                /* Temporarily NUL-terminate the key at the slash */
+                /* The key points into the route pattern (static/const) */
+                req->params[req->params_count].value = rp_seg;
                 req->params_count++;
             }
         } else {
             /* Static segment — must match exactly */
-            if (strcmp(pat_segments[i], path_segments[i]) != 0) {
-                /* Restore params on mismatch */
+            if (pp_len != rp_len || memcmp(pp_seg, rp_seg, pp_len) != 0) {
                 req->params_count = saved_params;
                 return 0;
             }
         }
+
+        /* Skip '/' separator */
+        if (*pp == '/') pp++;
+        if (*rp == '/') rp++;
+    }
+
+    /* Both must be consumed */
+    if (*pp || *rp) {
+        req->params_count = saved_params;
+        return 0;
     }
 
     return 1;
@@ -138,6 +153,13 @@ int cerver_route_match(const cerver_route_t *route, cerver_request_t *req) {
 /* ------------------------------------------------------------------ */
 
 cerver_handler_fn cerver_dispatch(cerver_server_t *srv, cerver_request_t *req) {
+    /* Try the generated compile-time dispatch first */
+    if (srv->dispatch_override) {
+        cerver_handler_fn h = srv->dispatch_override(req);
+        if (h) return h;
+    }
+
+    /* Fall back to generic route table scan */
     if (!srv->routes) return NULL;
 
     for (int i = 0; i < srv->route_count; i++) {