@velox0/cerver 0.4.0 → 0.4.2

package/runtime/static.c

@@ -25,30 +25,30 @@
 /*  FNV-1a hash for fast asset lookup                                 */
 /* ------------------------------------------------------------------ */
 
-static uint32_t fnv1a(const char *str) {
-    uint32_t hash = 2166136261u;
-    while (*str) {
-        hash ^= (uint8_t)*str++;
-        hash *= 16777619u;
-    }
-    return hash;
+static uint32_t fnv1a(const char* str) {
+  uint32_t hash = 2166136261u;
+  while (*str) {
+    hash ^= (uint8_t)*str++;
+    hash *= 16777619u;
+  }
+  return hash;
 }
 
 /* ------------------------------------------------------------------ */
 /*  Path safety: prevent directory traversal                          */
 /* ------------------------------------------------------------------ */
 
-static int path_is_safe(const char *path) {
-    /* Reject paths with ".." */
-    if (strstr(path, "..")) return 0;
+static int path_is_safe(const char* path) {
+  /* Reject paths with ".." */
+  if (strstr(path, "..")) return 0;
 
-    /* Reject paths with null bytes */
-    if (memchr(path, '\0', strlen(path))) return 0;
+  /* Reject paths with null bytes */
+  if (memchr(path, '\0', strlen(path))) return 0;
 
-    /* Must start with "/" */
-    if (path[0] != '/') return 0;
+  /* Must start with "/" */
+  if (path[0] != '/') return 0;
 
-    return 1;
+  return 1;
 }
 
 /* ------------------------------------------------------------------ */
@@ -56,220 +56,211 @@ static int path_is_safe(const char *path) {
 /* ------------------------------------------------------------------ */
 
 typedef struct {
-    int accepts_gzip;
-    int accepts_br;
+  int accepts_gzip;
+  int accepts_br;
 } encoding_prefs_t;
 
-static encoding_prefs_t parse_accept_encoding(const cerver_request_t *req) {
-    encoding_prefs_t prefs = { 0, 0 };
-    const char *ae = cerver_req_header(req, "Accept-Encoding");
-    if (!ae) return prefs;
+static encoding_prefs_t parse_accept_encoding(const cerver_request_t* req) {
+  encoding_prefs_t prefs = {0, 0};
+  const char*      ae    = cerver_req_header(req, "Accept-Encoding");
+  if (!ae) return prefs;
 
-    if (strstr(ae, "br")) prefs.accepts_br = 1;
-    if (strstr(ae, "gzip")) prefs.accepts_gzip = 1;
+  if (strstr(ae, "br")) prefs.accepts_br = 1;
+  if (strstr(ae, "gzip")) prefs.accepts_gzip = 1;
 
-    return prefs;
+  return prefs;
 }
 
 /* ------------------------------------------------------------------ */
 /*  Cache header helper                                               */
 /* ------------------------------------------------------------------ */
 
-static void add_cache_headers(cerver_response_t *res, const char *path) {
-    /* Hashed/versioned assets (in /static/) get long cache */
-    if (strstr(path, "/static/") || strstr(path, "/assets/")) {
-        cerver_res_header(res, "Cache-Control", "public, max-age=31536000, immutable");
-    } else {
-        /* HTML and other top-level files get short cache with revalidation */
-        cerver_res_header(res, "Cache-Control", "public, max-age=3600, must-revalidate");
-    }
+static void add_cache_headers(cerver_response_t* res, const char* path) {
+  /* Hashed/versioned assets (in /static/) get long cache */
+  if (strstr(path, "/static/") || strstr(path, "/assets/")) {
+    cerver_res_header(res, "Cache-Control", "public, max-age=31536000, immutable");
+  } else {
+    /* HTML and other top-level files get short cache with revalidation */
+    cerver_res_header(res, "Cache-Control", "public, max-age=3600, must-revalidate");
+  }
 }
 
 /* ------------------------------------------------------------------ */
 /*  Serve from embedded assets — hash-accelerated lookup              */
 /* ------------------------------------------------------------------ */
 
-static int serve_embedded(cerver_server_t *srv, cerver_request_t *req,
-                          cerver_response_t *res) {
-    if (!srv->assets || srv->asset_count == 0) return -1;
+static int serve_embedded(cerver_server_t* srv, cerver_request_t* req, cerver_response_t* res) {
+  if (!srv->assets || srv->asset_count == 0) return -1;
 
-    const char *path = req->path;
-    const cerver_asset_t *found = NULL;
+  const char*           path  = req->path;
+  const cerver_asset_t* found = NULL;
 
-    /*
-     * Use FNV-1a hash for O(1) average lookup instead of linear scan.
-     * For small asset counts (<64), linear scan is fine, but hash helps
-     * when there are hundreds of embedded assets.
-     */
-    uint32_t target_hash = fnv1a(path);
-
-    /* Try exact match first */
-    for (int i = 0; i < srv->asset_count; i++) {
-        if (fnv1a(srv->assets[i].path) == target_hash &&
-            strcmp(srv->assets[i].path, path) == 0) {
-            found = &srv->assets[i];
-            break;
-        }
-    }
+  /*
+   * Use FNV-1a hash for O(1) average lookup instead of linear scan.
+   * For small asset counts (<64), linear scan is fine, but hash helps
+   * when there are hundreds of embedded assets.
+   */
+  uint32_t target_hash = fnv1a(path);
 
-    /* Try with /index.html appended (for directory-like paths) */
-    if (!found) {
-        char index_path[CERVER_MAX_PATH];
-        size_t plen = strlen(path);
-        if (plen > 0 && path[plen - 1] == '/') {
-            snprintf(index_path, sizeof(index_path), "%sindex.html", path);
-        } else {
-            snprintf(index_path, sizeof(index_path), "%s/index.html", path);
-        }
-
-        uint32_t idx_hash = fnv1a(index_path);
-        for (int i = 0; i < srv->asset_count; i++) {
-            if (fnv1a(srv->assets[i].path) == idx_hash &&
-                strcmp(srv->assets[i].path, index_path) == 0) {
-                found = &srv->assets[i];
-                break;
-            }
-        }
+  /* Try exact match first */
+  for (int i = 0; i < srv->asset_count; i++) {
+    if (fnv1a(srv->assets[i].path) == target_hash && strcmp(srv->assets[i].path, path) == 0) {
+      found = &srv->assets[i];
+      break;
     }
-
-    if (!found) return -1;
-
-    /* Check for pre-compressed variants */
-    encoding_prefs_t enc = parse_accept_encoding(req);
-
-    if (enc.accepts_br && found->data_br && found->data_br_len > 0) {
-        /* Serve brotli */
-        cerver_res_file(res, 200, found->mime_type,
-                       found->data_br, found->data_br_len);
-        cerver_res_header(res, "Content-Encoding", "br");
-        cerver_res_header(res, "Vary", "Accept-Encoding");
-    } else if (enc.accepts_gzip && found->data_gz && found->data_gz_len > 0) {
-        /* Serve gzip */
-        cerver_res_file(res, 200, found->mime_type,
-                       found->data_gz, found->data_gz_len);
-        cerver_res_header(res, "Content-Encoding", "gzip");
-        cerver_res_header(res, "Vary", "Accept-Encoding");
+  }
+
+  /* Try with /index.html appended (for directory-like paths) */
+  if (!found) {
+    char   index_path[CERVER_MAX_PATH];
+    size_t plen = strlen(path);
+    if (plen > 0 && path[plen - 1] == '/') {
+      snprintf(index_path, sizeof(index_path), "%sindex.html", path);
     } else {
-        /* Serve uncompressed */
-        cerver_res_file(res, 200, found->mime_type,
-                       found->data, found->data_len);
+      snprintf(index_path, sizeof(index_path), "%s/index.html", path);
     }
 
-    add_cache_headers(res, found->path);
-
-    return 0;
+    uint32_t idx_hash = fnv1a(index_path);
+    for (int i = 0; i < srv->asset_count; i++) {
+      if (fnv1a(srv->assets[i].path) == idx_hash && strcmp(srv->assets[i].path, index_path) == 0) {
+        found = &srv->assets[i];
+        break;
+      }
+    }
+  }
+
+  if (!found) return -1;
+
+  /* Check for pre-compressed variants */
+  encoding_prefs_t enc = parse_accept_encoding(req);
+
+  if (enc.accepts_br && found->data_br && found->data_br_len > 0) {
+    /* Serve brotli */
+    cerver_res_file(res, 200, found->mime_type, found->data_br, found->data_br_len);
+    cerver_res_header(res, "Content-Encoding", "br");
+    cerver_res_header(res, "Vary", "Accept-Encoding");
+  } else if (enc.accepts_gzip && found->data_gz && found->data_gz_len > 0) {
+    /* Serve gzip */
+    cerver_res_file(res, 200, found->mime_type, found->data_gz, found->data_gz_len);
+    cerver_res_header(res, "Content-Encoding", "gzip");
+    cerver_res_header(res, "Vary", "Accept-Encoding");
+  } else {
+    /* Serve uncompressed */
+    cerver_res_file(res, 200, found->mime_type, found->data, found->data_len);
+  }
+
+  add_cache_headers(res, found->path);
+
+  return 0;
 }
 
 /* ------------------------------------------------------------------ */
 /*  Serve from filesystem — sendfile/mmap + stat cache                */
 /* ------------------------------------------------------------------ */
 
-static int serve_filesystem(cerver_server_t *srv, cerver_request_t *req,
-                            cerver_response_t *res) {
-    if (!srv->public_dir) return -1;
+static int serve_filesystem(cerver_server_t* srv, cerver_request_t* req, cerver_response_t* res) {
+  if (!srv->public_dir) return -1;
 
-    const char *path = req->path;
-    if (!path_is_safe(path)) return -1;
+  const char* path = req->path;
+  if (!path_is_safe(path)) return -1;
 
-    /* Build the full filesystem path */
-    char full_path[CERVER_MAX_PATH * 2];
-    snprintf(full_path, sizeof(full_path), "%s%s", srv->public_dir, path);
+  /* Build the full filesystem path */
+  char full_path[CERVER_MAX_PATH * 2];
+  snprintf(full_path, sizeof(full_path), "%s%s", srv->public_dir, path);
 
-    /* Check if it's a directory — try index.html */
-    struct stat st;
-    if (stat(full_path, &st) == 0 && S_ISDIR(st.st_mode)) {
-        snprintf(full_path, sizeof(full_path), "%s%s/index.html",
-                 srv->public_dir, path);
-        if (stat(full_path, &st) != 0) return -1;
-    }
+  /* Check if it's a directory — try index.html */
+  struct stat st;
+  if (stat(full_path, &st) == 0 && S_ISDIR(st.st_mode)) {
+    snprintf(full_path, sizeof(full_path), "%s%s/index.html", srv->public_dir, path);
+    if (stat(full_path, &st) != 0) return -1;
+  }
 
-    /* Must be a regular file */
-    if (stat(full_path, &st) != 0 || !S_ISREG(st.st_mode)) {
-        return -1;
+  /* Must be a regular file */
+  if (stat(full_path, &st) != 0 || !S_ISREG(st.st_mode)) {
+    return -1;
+  }
+
+  size_t file_size = (size_t)st.st_size;
+
+  /* Store in stat cache for future lookups */
+  cerver_stat_cache_store(&srv->stat_cache, full_path, file_size, st.st_mtime);
+
+  /* Determine MIME type */
+  const char* mime = cerver_mime_from_path(full_path);
+
+  /*
+   * Use mmap for zero-copy serving instead of fopen+malloc+fread.
+   * The mmap'd region is used directly as the response body.
+   * We mark it as _body_owned=0 since munmap needs special handling,
+   * but for simplicity we'll use read() for small files and mmap for large.
+   */
+  if (file_size > 65536) {
+    /* Large files: mmap for zero-copy */
+    int fd = open(full_path, O_RDONLY);
+    if (fd < 0) return -1;
+
+    void* mapped = mmap(NULL, file_size, PROT_READ, MAP_PRIVATE, fd, 0);
+    close(fd);
+
+    if (mapped == MAP_FAILED) return -1;
+
+    /* Advise the kernel we'll read sequentially */
+    madvise(mapped, file_size, MADV_SEQUENTIAL);
+
+    res->status       = 200;
+    res->content_type = mime;
+    res->body         = (const char*)mapped;
+    res->body_len     = file_size;
+    res->_body_owned  = 2; /* Special flag: needs munmap, not free */
+  } else {
+    /* Small files: read into buffer (avoids mmap overhead) */
+    int fd = open(full_path, O_RDONLY);
+    if (fd < 0) return -1;
+
+    char* file_data = malloc(file_size);
+    if (!file_data) {
+      close(fd);
+      return -1;
     }
 
-    size_t file_size = (size_t)st.st_size;
-
-    /* Store in stat cache for future lookups */
-    cerver_stat_cache_store(&srv->stat_cache, full_path, file_size, st.st_mtime);
-
-    /* Determine MIME type */
-    const char *mime = cerver_mime_from_path(full_path);
-
-    /*
-     * Use mmap for zero-copy serving instead of fopen+malloc+fread.
-     * The mmap'd region is used directly as the response body.
-     * We mark it as _body_owned=0 since munmap needs special handling,
-     * but for simplicity we'll use read() for small files and mmap for large.
-     */
-    if (file_size > 65536) {
-        /* Large files: mmap for zero-copy */
-        int fd = open(full_path, O_RDONLY);
-        if (fd < 0) return -1;
-
-        void *mapped = mmap(NULL, file_size, PROT_READ, MAP_PRIVATE, fd, 0);
-        close(fd);
-
-        if (mapped == MAP_FAILED) return -1;
-
-        /* Advise the kernel we'll read sequentially */
-        madvise(mapped, file_size, MADV_SEQUENTIAL);
+    size_t total = 0;
+    while (total < file_size) {
+      ssize_t n = read(fd, file_data + total, file_size - total);
+      if (n <= 0) break;
+      total += (size_t)n;
+    }
+    close(fd);
 
-        res->status = 200;
-        res->content_type = mime;
-        res->body = (const char *)mapped;
-        res->body_len = file_size;
-        res->_body_owned = 2; /* Special flag: needs munmap, not free */
-    } else {
-        /* Small files: read into buffer (avoids mmap overhead) */
-        int fd = open(full_path, O_RDONLY);
-        if (fd < 0) return -1;
-
-        char *file_data = malloc(file_size);
-        if (!file_data) {
-            close(fd);
-            return -1;
-        }
-
-        size_t total = 0;
-        while (total < file_size) {
-            ssize_t n = read(fd, file_data + total, file_size - total);
-            if (n <= 0) break;
-            total += (size_t)n;
-        }
-        close(fd);
-
-        if (total != file_size) {
-            free(file_data);
-            return -1;
-        }
-
-        res->status = 200;
-        res->content_type = mime;
-        res->body = file_data;
-        res->body_len = file_size;
-        res->_body_owned = 1; /* malloc'd */
+    if (total != file_size) {
+      free(file_data);
+      return -1;
     }
 
-    add_cache_headers(res, path);
+    res->status       = 200;
+    res->content_type = mime;
+    res->body         = file_data;
+    res->body_len     = file_size;
+    res->_body_owned  = 1; /* malloc'd */
+  }
 
-    return 0;
+  add_cache_headers(res, path);
+
+  return 0;
 }
 
 /* ------------------------------------------------------------------ */
 /*  Main static serving entry point                                   */
 /* ------------------------------------------------------------------ */
 
-int cerver_serve_static(cerver_server_t *srv, cerver_request_t *req,
-                        cerver_response_t *res) {
-    /* Only serve GET requests for static files */
-    if (strcmp(req->method, "GET") != 0) return -1;
+int cerver_serve_static(cerver_server_t* srv, cerver_request_t* req, cerver_response_t* res) {
+  /* Only serve GET requests for static files */
+  if (strcmp(req->method, "GET") != 0) return -1;
 
-    /* Try embedded assets first */
-    if (serve_embedded(srv, req, res) == 0) return 0;
+  /* Try embedded assets first */
+  if (serve_embedded(srv, req, res) == 0) return 0;
 
-    /* Fall back to filesystem */
-    if (serve_filesystem(srv, req, res) == 0) return 0;
+  /* Fall back to filesystem */
+  if (serve_filesystem(srv, req, res) == 0) return 0;
 
-    return -1;
+  return -1;
 }

package/runtime/tests/minunit.c

@@ -0,0 +1,76 @@
+#include "minunit.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+int mu_tests_run    = 0;
+int mu_tests_failed = 0;
+int mu_test_failed  = 0;
+
+static int mu_is_tty(FILE* f) { return isatty(fileno(f)); }
+
+static const char* mu_color(FILE* f, const char* code) { return mu_is_tty(f) ? code : ""; }
+
+const char* mu_snip(const char* s, char* buf, size_t cap) {
+  if (s == NULL) {
+    return "(null)";
+  }
+  if (cap == 0) {
+    return "";
+  }
+
+  size_t len = strlen(s);
+  if (len < cap) {
+    snprintf(buf, cap, "%s", s);
+    return buf;
+  }
+
+  if (cap <= 4) {
+    size_t keep = cap - 1;
+    memcpy(buf, s, keep);
+    buf[keep] = '\0';
+    return buf;
+  }
+
+  size_t keep = cap - 4;
+  memcpy(buf, s, keep);
+  memcpy(buf + keep, "...", 3);
+  buf[keep + 3] = '\0';
+  return buf;
+}
+
+void mu_fail(const char* file, int line, const char* msg) {
+  const char* red   = mu_color(stderr, "\x1b[31m");
+  const char* reset = mu_color(stderr, "\x1b[0m");
+
+  mu_test_failed = 1;
+  fprintf(stderr, "%sFAIL%s %s:%d: %s\n", red, reset, file, line, msg);
+}
+
+void mu_run(const char* name, mu_test_fn fn) {
+  mu_tests_run++;
+  mu_test_failed = 0;
+  fn();
+  if (mu_test_failed) {
+    mu_tests_failed++;
+    fprintf(stderr, "  in %s\n", name);
+  } else {
+    const char* green = mu_color(stdout, "\x1b[32m");
+    const char* reset = mu_color(stdout, "\x1b[0m");
+    printf("%sok%s %s\n", green, reset, name);
+  }
+}
+
+int mu_report(void) {
+  const char* reset = mu_color(stdout, "\x1b[0m");
+  if (mu_tests_failed) {
+    const char* red = mu_color(stdout, "\x1b[31m");
+    printf("%sSummary:%s %d tests, %s%d failures%s\n", red, reset, mu_tests_run, red,
+           mu_tests_failed, reset);
+  } else {
+    const char* green = mu_color(stdout, "\x1b[32m");
+    printf("%sSummary:%s %d tests, %s0 failures%s\n", green, reset, mu_tests_run, green, reset);
+  }
+  return mu_tests_failed ? 1 : 0;
+}

package/runtime/tests/minunit.h

@@ -0,0 +1,64 @@
+#ifndef CERVER_MINUNIT_H
+#define CERVER_MINUNIT_H
+
+#include <stddef.h>
+#include <stdio.h>
+#include <string.h>
+
+typedef void (*mu_test_fn)(void);
+
+#define MU_SNIP_MAX 80
+
+extern int mu_tests_run;
+extern int mu_tests_failed;
+extern int mu_test_failed;
+
+void        mu_fail(const char* file, int line, const char* msg);
+void        mu_run(const char* name, mu_test_fn fn);
+int         mu_report(void);
+const char* mu_snip(const char* s, char* buf, size_t cap);
+
+#define MU_ASSERT(cond)                   \
+  do {                                    \
+    if (!(cond)) {                        \
+      mu_fail(__FILE__, __LINE__, #cond); \
+      return;                             \
+    }                                     \
+  } while (0)
+
+#define MU_ASSERT_EQ_INT(a, b)                                                      \
+  do {                                                                              \
+    if ((a) != (b)) {                                                               \
+      char _mu_buf[128];                                                            \
+      snprintf(_mu_buf, sizeof(_mu_buf), "got %d expected %d", (int)(a), (int)(b)); \
+      mu_fail(__FILE__, __LINE__, _mu_buf);                                         \
+      return;                                                                       \
+    }                                                                               \
+  } while (0)
+
+#define MU_ASSERT_EQ_SIZE(a, b)                                                             \
+  do {                                                                                      \
+    if ((a) != (b)) {                                                                       \
+      char _mu_buf[128];                                                                    \
+      snprintf(_mu_buf, sizeof(_mu_buf), "got %zu expected %zu", (size_t)(a), (size_t)(b)); \
+      mu_fail(__FILE__, __LINE__, _mu_buf);                                                 \
+      return;                                                                               \
+    }                                                                                       \
+  } while (0)
+
+#define MU_ASSERT_STREQ(a, b)                                                       \
+  do {                                                                              \
+    if (((a) == NULL && (b) != NULL) || ((a) != NULL && (b) == NULL) ||             \
+        ((a) != NULL && (b) != NULL && strcmp((a), (b)) != 0)) {                    \
+      char        _mu_buf[256];                                                     \
+      char        _mu_a[MU_SNIP_MAX];                                               \
+      char        _mu_b[MU_SNIP_MAX];                                               \
+      const char* _mu_as = mu_snip((a), _mu_a, sizeof(_mu_a));                      \
+      const char* _mu_bs = mu_snip((b), _mu_b, sizeof(_mu_b));                      \
+      snprintf(_mu_buf, sizeof(_mu_buf), "got '%s' expected '%s'", _mu_as, _mu_bs); \
+      mu_fail(__FILE__, __LINE__, _mu_buf);                                         \
+      return;                                                                       \
+    }                                                                               \
+  } while (0)
+
+#endif