@velox0/cerver 0.4.0 → 0.4.2

package/runtime/mime.c

@@ -5,80 +5,80 @@
 #include "cerver.h"
 
 #include <string.h>
+#include <strings.h>
 #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

@@ -11,36 +11,37 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <strings.h>
 
 /* ------------------------------------------------------------------ */
 /*  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;
 }
 
 /* ------------------------------------------------------------------ */
@@ -51,20 +52,20 @@ const char *cerver_req_header(const cerver_request_t *req, const char *key) {
  * 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;
+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;
+void cerver_set_dispatch(cerver_server_t* srv, cerver_dispatch_fn fn) {
+  srv->dispatch_override = fn;
 }
 
 /* ------------------------------------------------------------------ */
@@ -77,96 +78,96 @@ void cerver_set_dispatch(cerver_server_t *srv, cerver_dispatch_fn fn) {
  *
  * 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;
-    }
+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;
+  const char* pattern = route->pattern;
+  const char* path    = req->path;
 
-    /* Fast path: exact match */
-    if (strcmp(pattern, path) == 0) {
-        return 1;
-    }
+  /* Fast path: exact match */
+  if (strcmp(pattern, path) == 0) {
+    return 1;
+  }
 
-    /* No dynamic segments? Then the strcmp above was definitive */
-    if (!strchr(pattern, ':')) {
+  /* 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;
+      }
     }
 
-    /* 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 '/' */
+    /* Skip '/' separator */
     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;
-            }
-        }
-
-        /* Skip '/' separator */
-        if (*pp == '/') pp++;
-        if (*rp == '/') rp++;
-    }
-
-    /* Both must be consumed */
-    if (*pp || *rp) {
-        req->params_count = saved_params;
-        return 0;
-    }
+  /* Both must be consumed */
+  if (*pp || *rp) {
+    req->params_count = saved_params;
+    return 0;
+  }
 
-    return 1;
+  return 1;
 }
 
 /* ------------------------------------------------------------------ */
 /*  Dispatch: find and return the handler for a request               */
 /* ------------------------------------------------------------------ */
 
-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;
-    }
+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;
+  /* 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;
 }