@velox0/cerver 0.3.1 → 0.4.1

package/runtime/mime.c

@@ -8,77 +8,76 @@
 #include <ctype.h>
 
 typedef struct {
-    const char *ext;
-    const char *mime;
+  const char* ext;
+  const char* mime;
 } mime_entry_t;
 
 static const mime_entry_t mime_table[] = {
     /* Web essentials */
-    { ".html",  "text/html; charset=utf-8" },
-    { ".htm",   "text/html; charset=utf-8" },
-    { ".css",   "text/css; charset=utf-8" },
-    { ".js",    "application/javascript; charset=utf-8" },
-    { ".mjs",   "application/javascript; charset=utf-8" },
-    { ".json",  "application/json; charset=utf-8" },
-    { ".xml",   "application/xml; charset=utf-8" },
+    {".html", "text/html; charset=utf-8"},
+    {".htm", "text/html; charset=utf-8"},
+    {".css", "text/css; charset=utf-8"},
+    {".js", "application/javascript; charset=utf-8"},
+    {".mjs", "application/javascript; charset=utf-8"},
+    {".json", "application/json; charset=utf-8"},
+    {".xml", "application/xml; charset=utf-8"},
 
     /* Text */
-    { ".txt",   "text/plain; charset=utf-8" },
-    { ".csv",   "text/csv; charset=utf-8" },
-    { ".md",    "text/markdown; charset=utf-8" },
+    {".txt", "text/plain; charset=utf-8"},
+    {".csv", "text/csv; charset=utf-8"},
+    {".md", "text/markdown; charset=utf-8"},
 
     /* Images */
-    { ".png",   "image/png" },
-    { ".jpg",   "image/jpeg" },
-    { ".jpeg",  "image/jpeg" },
-    { ".gif",   "image/gif" },
-    { ".svg",   "image/svg+xml" },
-    { ".ico",   "image/x-icon" },
-    { ".webp",  "image/webp" },
-    { ".avif",  "image/avif" },
+    {".png", "image/png"},
+    {".jpg", "image/jpeg"},
+    {".jpeg", "image/jpeg"},
+    {".gif", "image/gif"},
+    {".svg", "image/svg+xml"},
+    {".ico", "image/x-icon"},
+    {".webp", "image/webp"},
+    {".avif", "image/avif"},
 
     /* Fonts */
-    { ".woff",  "font/woff" },
-    { ".woff2", "font/woff2" },
-    { ".ttf",   "font/ttf" },
-    { ".otf",   "font/otf" },
-    { ".eot",   "application/vnd.ms-fontobject" },
+    {".woff", "font/woff"},
+    {".woff2", "font/woff2"},
+    {".ttf", "font/ttf"},
+    {".otf", "font/otf"},
+    {".eot", "application/vnd.ms-fontobject"},
 
     /* Media */
-    { ".mp4",   "video/mp4" },
-    { ".webm",  "video/webm" },
-    { ".ogg",   "audio/ogg" },
-    { ".mp3",   "audio/mpeg" },
-    { ".wav",   "audio/wav" },
+    {".mp4", "video/mp4"},
+    {".webm", "video/webm"},
+    {".ogg", "audio/ogg"},
+    {".mp3", "audio/mpeg"},
+    {".wav", "audio/wav"},
 
     /* Archives */
-    { ".zip",   "application/zip" },
-    { ".gz",    "application/gzip" },
-    { ".tar",   "application/x-tar" },
+    {".zip", "application/zip"},
+    {".gz", "application/gzip"},
+    {".tar", "application/x-tar"},
 
     /* Documents */
-    { ".pdf",   "application/pdf" },
+    {".pdf", "application/pdf"},
 
     /* Misc */
-    { ".wasm",  "application/wasm" },
-    { ".map",   "application/json" },
+    {".wasm", "application/wasm"},
+    {".map", "application/json"},
 
-    { NULL, NULL }
-};
+    {NULL, NULL}};
 
-const char *cerver_mime_from_path(const char *path) {
-    if (!path) return "application/octet-stream";
+const char* cerver_mime_from_path(const char* path) {
+  if (!path) return "application/octet-stream";
 
-    /* Find the last '.' in the path */
-    const char *dot = strrchr(path, '.');
-    if (!dot) return "application/octet-stream";
+  /* Find the last '.' in the path */
+  const char* dot = strrchr(path, '.');
+  if (!dot) return "application/octet-stream";
 
-    /* Case-insensitive extension match */
-    for (const mime_entry_t *entry = mime_table; entry->ext; entry++) {
-        if (strcasecmp(dot, entry->ext) == 0) {
-            return entry->mime;
-        }
+  /* Case-insensitive extension match */
+  for (const mime_entry_t* entry = mime_table; entry->ext; entry++) {
+    if (strcasecmp(dot, entry->ext) == 0) {
+      return entry->mime;
     }
+  }
 
-    return "application/octet-stream";
+  return "application/octet-stream";
 }

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"
@@ -15,31 +16,55 @@
 /*  Request accessor helpers                                          */
 /* ------------------------------------------------------------------ */
 
-const char *cerver_req_param(const cerver_request_t *req, const char *key) {
-    for (int i = 0; i < req->params_count; i++) {
-        if (strcmp(req->params[i].key, key) == 0) {
-            return req->params[i].value;
-        }
+const char* cerver_req_param(const cerver_request_t* req, const char* key) {
+  for (int i = 0; i < req->params_count; i++) {
+    if (strcmp(req->params[i].key, key) == 0) {
+      return req->params[i].value;
     }
-    return "";
+  }
+  return "";
 }
 
-const char *cerver_req_query(const cerver_request_t *req, const char *key) {
-    for (int i = 0; i < req->query_count; i++) {
-        if (strcmp(req->query[i].key, key) == 0) {
-            return req->query[i].value;
-        }
+const char* cerver_req_query(const cerver_request_t* req, const char* key) {
+  for (int i = 0; i < req->query_count; i++) {
+    if (strcmp(req->query[i].key, key) == 0) {
+      return req->query[i].value;
     }
-    return "";
+  }
+  return "";
 }
 
-const char *cerver_req_header(const cerver_request_t *req, const char *key) {
-    for (int i = 0; i < req->header_count; i++) {
-        if (strcasecmp(req->headers[i].key, key) == 0) {
-            return req->headers[i].value;
-        }
+const char* cerver_req_header(const cerver_request_t* req, const char* key) {
+  for (int i = 0; i < req->header_count; i++) {
+    if (strcasecmp(req->headers[i].key, key) == 0) {
+      return req->headers[i].value;
     }
-    return NULL;
+  }
+  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;
 }
 
 /* ------------------------------------------------------------------ */
@@ -50,101 +75,98 @@ 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 */
-    if (strcmp(route->method, req->method) != 0) {
-        return 0;
-    }
-
-    const char *pattern = route->pattern;
-    const char *path = req->path;
-
-    /* Fast path: exact match */
-    if (strcmp(pattern, path) == 0) {
-        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);
-    }
+int cerver_route_match(const cerver_route_t* route, cerver_request_t* req) {
+  /* Method must match */
+  if (strcmp(route->method, req->method) != 0) {
+    return 0;
+  }
 
-    tok = strtok_r(path_buf, "/", &saveptr);
-    while (tok && path_count < 64) {
-        path_segments[path_count++] = tok;
-        tok = strtok_r(NULL, "/", &saveptr);
-    }
+  const char* pattern = route->pattern;
+  const char* path = req->path;
 
-    /* Segment counts must match */
-    if (pat_count != path_count) {
+  /* Fast path: exact match */
+  if (strcmp(pattern, path) == 0) {
+    return 1;
+  }
+
+  /* No dynamic segments? Then the strcmp above was definitive */
+  if (!strchr(pattern, ':')) {
+    return 0;
+  }
+
+  /* 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;
+
+  /* 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) {
+        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 (pp_len != rp_len || memcmp(pp_seg, rp_seg, pp_len) != 0) {
+        req->params_count = saved_params;
         return 0;
+      }
     }
 
-    /* Match each segment */
-    /* Reset params before populating */
-    int saved_params = req->params_count;
-
-    for (int i = 0; i < pat_count; i++) {
-        if (pat_segments[i][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_count++;
-            }
-        } else {
-            /* Static segment — must match exactly */
-            if (strcmp(pat_segments[i], path_segments[i]) != 0) {
-                /* Restore params on mismatch */
-                req->params_count = saved_params;
-                return 0;
-            }
-        }
-    }
+    /* Skip '/' separator */
+    if (*pp == '/') pp++;
+    if (*rp == '/') rp++;
+  }
 
-    return 1;
+  /* Both must be consumed */
+  if (*pp || *rp) {
+    req->params_count = saved_params;
+    return 0;
+  }
+
+  return 1;
 }
 
 /* ------------------------------------------------------------------ */
 /*  Dispatch: find and return the handler for a request               */
 /* ------------------------------------------------------------------ */
 
-cerver_handler_fn cerver_dispatch(cerver_server_t *srv, cerver_request_t *req) {
-    if (!srv->routes) return NULL;
+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++) {
-        if (cerver_route_match(&srv->routes[i], req)) {
-            return srv->routes[i].handler;
-        }
+  for (int i = 0; i < srv->route_count; i++) {
+    if (cerver_route_match(&srv->routes[i], req)) {
+      return srv->routes[i].handler;
     }
+  }
 
-    return NULL;
+  return NULL;
 }