@velox0/cerver 0.4.1 → 0.4.2

package/runtime/cerver.h

@@ -6,6 +6,16 @@
  * the route dispatch interface.
  */
 
+/*
+ * Feature test macros for POSIX/GNU APIs used by the runtime.
+ * Must be defined before any system headers.
+ */
+#if defined(__linux__)
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+#endif
+
 #ifndef CERVER_H
 #define CERVER_H
 
@@ -69,22 +79,22 @@ typedef struct {
 
   /* Parsed query parameters */
   cerver_kv_t query[CERVER_MAX_QUERY];
-  int query_count;
+  int         query_count;
 
   /* Route parameters (from dynamic segments like :key) */
   cerver_kv_t params[CERVER_MAX_PARAMS];
-  int params_count;
+  int         params_count;
 
   /* Request headers */
   cerver_kv_t headers[CERVER_MAX_HEADERS];
-  int header_count;
+  int         header_count;
 
   /* Request body (for POST) */
   const char* body;
-  size_t body_len;
+  size_t      body_len;
 
   /* Internal: raw buffer ownership (NULL if in-place parsing used) */
-  char* _raw_buf;
+  char*  _raw_buf;
   size_t _raw_len;
 } cerver_request_t;
 
@@ -93,16 +103,16 @@ typedef struct {
 /* ------------------------------------------------------------------ */
 
 typedef struct {
-  int status;
+  int         status;
   const char* content_type;
 
   /* Response body — can be heap-allocated or static */
   const char* body;
-  size_t body_len;
+  size_t      body_len;
 
   /* Extra headers */
   cerver_kv_t headers[CERVER_MAX_HEADERS];
-  int header_count;
+  int         header_count;
 
   /* Internal flag: was body malloc'd? */
   int _body_owned;
@@ -137,8 +147,8 @@ int cerver_req_wants_close(const cerver_request_t* req);
 typedef void (*cerver_handler_fn)(cerver_request_t* req, cerver_response_t* res);
 
 typedef struct {
-  const char* method;  /* "GET", "POST" */
-  const char* pattern; /* "/", "/art/:key", "/api/projects" */
+  const char*       method;  /* "GET", "POST" */
+  const char*       pattern; /* "/", "/groups/:group_id", "/api/items" */
   cerver_handler_fn handler;
 } cerver_route_t;
 
@@ -147,20 +157,20 @@ typedef struct {
 /* ------------------------------------------------------------------ */
 
 typedef struct {
-  const char* path;      /* e.g. "/index.html" */
-  const char* mime_type; /* e.g. "text/html" */
+  const char*          path;      /* e.g. "/index.html" */
+  const char*          mime_type; /* e.g. "text/html" */
   const unsigned char* data;
-  size_t data_len;
+  size_t               data_len;
 
   /* Pre-compressed variants (NULL if not available) */
   const unsigned char* data_gz;
-  size_t data_gz_len;
+  size_t               data_gz_len;
   const unsigned char* data_br;
-  size_t data_br_len;
+  size_t               data_br_len;
 
   /* Pre-computed response header (NULL if not generated) */
   const char* prebuilt_header;
-  size_t prebuilt_header_len;
+  size_t      prebuilt_header_len;
 } cerver_asset_t;
 
 /* ------------------------------------------------------------------ */
@@ -168,16 +178,16 @@ typedef struct {
 /* ------------------------------------------------------------------ */
 
 typedef struct {
-  char path[CERVER_MAX_PATH];
+  char   path[CERVER_MAX_PATH];
   size_t file_size;
   time_t mtime;
   time_t cached_at;
-  int valid;
+  int    valid;
 } cerver_stat_entry_t;
 
 typedef struct {
   cerver_stat_entry_t entries[CERVER_STAT_CACHE_SIZE];
-  pthread_mutex_t lock;
+  pthread_mutex_t     lock;
 } cerver_stat_cache_t;
 
 /* ------------------------------------------------------------------ */
@@ -193,11 +203,11 @@ typedef cerver_handler_fn (*cerver_dispatch_fn)(cerver_request_t* req);
 typedef struct cerver_server cerver_server_t;
 
 typedef struct {
-  int id;
-  int event_fd;  /* kqueue or epoll fd */
-  int listen_fd; /* per-worker on Linux, shared on macOS */
+  int              id;
+  int              event_fd;  /* kqueue or epoll fd */
+  int              listen_fd; /* per-worker on Linux, shared on macOS */
   cerver_server_t* srv;
-  pthread_t thread;
+  pthread_t        thread;
 } cerver_worker_t;
 
 /* ------------------------------------------------------------------ */
@@ -205,14 +215,14 @@ typedef struct {
 /* ------------------------------------------------------------------ */
 
 struct cerver_server {
-  int port;
-  int sock_fd;
+  int             port;
+  int             sock_fd;
   cerver_route_t* routes;
-  int route_count;
+  int             route_count;
   cerver_asset_t* assets;
-  int asset_count;
-  const char* public_dir; /* NULL if embedded mode */
-  volatile int running;
+  int             asset_count;
+  const char*     public_dir; /* NULL if embedded mode */
+  volatile int    running;
 
   /* Generated dispatch override (faster than generic router) */
   cerver_dispatch_fn dispatch_override;
@@ -221,17 +231,17 @@ struct cerver_server {
   cerver_stat_cache_t stat_cache;
 
   /* Worker pool */
-  int worker_count;
+  int              worker_count;
   cerver_worker_t* workers;
 };
 
 /* Server lifecycle */
-int cerver_init(cerver_server_t* srv, int port, int threads);
-int cerver_add_routes(cerver_server_t* srv, cerver_route_t* routes, int count);
-int cerver_set_assets(cerver_server_t* srv, cerver_asset_t* assets, int count);
+int  cerver_init(cerver_server_t* srv, int port, int threads);
+int  cerver_add_routes(cerver_server_t* srv, cerver_route_t* routes, int count);
+int  cerver_set_assets(cerver_server_t* srv, cerver_asset_t* assets, int count);
 void cerver_set_public_dir(cerver_server_t* srv, const char* dir);
 void cerver_set_dispatch(cerver_server_t* srv, cerver_dispatch_fn fn);
-int cerver_listen(cerver_server_t* srv);
+int  cerver_listen(cerver_server_t* srv);
 void cerver_shutdown(cerver_server_t* srv);
 
 /* ------------------------------------------------------------------ */
@@ -250,7 +260,7 @@ int cerver_write_response(int fd, const cerver_response_t* res, int keepalive);
 /*  Router (internal)                                                 */
 /* ------------------------------------------------------------------ */
 
-int cerver_route_match(const cerver_route_t* route, cerver_request_t* req);
+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);
 
 /* ------------------------------------------------------------------ */
@@ -270,7 +280,7 @@ int cerver_serve_static(cerver_server_t* srv, cerver_request_t* req, cerver_resp
 /* ------------------------------------------------------------------ */
 
 void cerver_stat_cache_init(cerver_stat_cache_t* cache);
-int cerver_stat_cache_lookup(cerver_stat_cache_t* cache, const char* path, size_t* file_size);
+int  cerver_stat_cache_lookup(cerver_stat_cache_t* cache, const char* path, size_t* file_size);
 void cerver_stat_cache_store(cerver_stat_cache_t* cache, const char* path, size_t file_size,
                              time_t mtime);
 

package/runtime/http_parser.c

@@ -11,6 +11,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <strings.h>
 #include <ctype.h>
 
 /* ------------------------------------------------------------------ */
@@ -67,13 +68,13 @@ static void parse_query_string(char* qs, cerver_request_t* req) {
 
     char* eq = strchr(pair_start, '=');
     if (eq) {
-      *eq = '\0';
-      req->query[req->query_count].key = pair_start;
+      *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].key   = pair_start;
       req->query[req->query_count].value = "";
     }
     req->query_count++;
@@ -94,7 +95,7 @@ int cerver_parse_request(const char* raw, size_t len, cerver_request_t* req) {
    * 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 */
+  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;
@@ -117,7 +118,7 @@ int cerver_parse_request(const char* raw, size_t len, cerver_request_t* req) {
 
   /* Path (and maybe query string) */
   char* path_start = sp1 + 1;
-  char* sp2 = strchr(path_start, ' ');
+  char* sp2        = strchr(path_start, ' ');
   if (sp2) *sp2 = '\0';
 
   /* Split path and query string */
@@ -125,8 +126,8 @@ int cerver_parse_request(const char* raw, size_t len, cerver_request_t* req) {
   if (qmark) {
     *qmark = '\0';
     /* Point query_string directly into the buffer */
-    char* qs_start = qmark + 1;
-    size_t qs_len = strlen(qs_start);
+    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';
@@ -148,7 +149,7 @@ int cerver_parse_request(const char* raw, size_t len, cerver_request_t* req) {
   }
 
   /* ---- Headers ---- */
-  char* hdr_start = line_end + 2; /* skip \r\n */
+  char*  hdr_start      = line_end + 2; /* skip \r\n */
   size_t content_length = 0;
 
   while (hdr_start < buf + len) {
@@ -166,11 +167,11 @@ int cerver_parse_request(const char* raw, size_t len, cerver_request_t* req) {
     if (req->header_count < CERVER_MAX_HEADERS) {
       char* colon = strchr(hdr_start, ':');
       if (colon) {
-        *colon = '\0';
+        *colon    = '\0';
         char* val = colon + 1;
         while (*val == ' ') val++;
 
-        req->headers[req->header_count].key = hdr_start;
+        req->headers[req->header_count].key   = hdr_start;
         req->headers[req->header_count].value = val;
         req->header_count++;
 
@@ -186,7 +187,7 @@ int cerver_parse_request(const char* raw, size_t len, cerver_request_t* req) {
 
   /* ---- Body (for POST etc.) ---- */
   if (content_length > 0 && hdr_start < buf + len) {
-    req->body = hdr_start;
+    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);

package/runtime/http_writer.c

@@ -57,7 +57,7 @@ static const char* status_text(int code) {
 int cerver_write_response(int fd, const cerver_response_t* res, int keepalive) {
   /* Build the response header */
   char header[4096];
-  int hlen = 0;
+  int  hlen = 0;
 
   /* Status line */
   hlen += snprintf(header + hlen, sizeof(header) - (size_t)hlen, "HTTP/1.1 %d %s\r\n", res->status,
@@ -99,11 +99,11 @@ int cerver_write_response(int fd, const cerver_response_t* res, int keepalive) {
   if (res->body && res->body_len > 0) {
     struct iovec iov[2];
     iov[0].iov_base = header;
-    iov[0].iov_len = (size_t)hlen;
+    iov[0].iov_len  = (size_t)hlen;
     iov[1].iov_base = (void*)res->body;
-    iov[1].iov_len = res->body_len;
+    iov[1].iov_len  = res->body_len;
 
-    size_t total = iov[0].iov_len + iov[1].iov_len;
+    size_t total   = iov[0].iov_len + iov[1].iov_len;
     size_t written = 0;
 
     while (written < total) {
@@ -118,9 +118,9 @@ int cerver_write_response(int fd, const cerver_response_t* res, int keepalive) {
       } 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;
+        iov[0].iov_len   = 0;
+        iov[1].iov_base  = (void*)(res->body + body_sent);
+        iov[1].iov_len   = res->body_len - body_sent;
       }
     }
   } else {
@@ -137,41 +137,41 @@ int cerver_write_response(int fd, const cerver_response_t* res, int keepalive) {
 /* ------------------------------------------------------------------ */
 
 void cerver_res_text(cerver_response_t* res, int status, const char* text) {
-  res->status = status;
+  res->status       = status;
   res->content_type = "text/plain; charset=utf-8";
-  res->body = text;
-  res->body_len = strlen(text);
-  res->_body_owned = 0;
+  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->status       = status;
   res->content_type = "application/json; charset=utf-8";
-  res->body = json;
-  res->body_len = strlen(json);
-  res->_body_owned = 0;
+  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->status       = status;
   res->content_type = "text/html; charset=utf-8";
-  res->body = html;
-  res->body_len = strlen(html);
-  res->_body_owned = 0;
+  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->status       = status;
   res->content_type = mime;
-  res->body = (const char*)data;
-  res->body_len = len;
-  res->_body_owned = 0;
+  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].key   = key;
     res->headers[res->header_count].value = val;
     res->header_count++;
   }

package/runtime/mime.c

@@ -5,6 +5,7 @@
 #include "cerver.h"
 
 #include <string.h>
+#include <strings.h>
 #include <ctype.h>
 
 typedef struct {

package/runtime/router.c

@@ -11,6 +11,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <strings.h>
 
 /* ------------------------------------------------------------------ */
 /*  Request accessor helpers                                          */
@@ -84,7 +85,7 @@ int cerver_route_match(const cerver_route_t* route, cerver_request_t* req) {
   }
 
   const char* pattern = route->pattern;
-  const char* path = req->path;
+  const char* path    = req->path;
 
   /* Fast path: exact match */
   if (strcmp(pattern, path) == 0) {