@velox0/cerver 0.3.1 → 0.4.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++) {