@velox0/cerver 0.4.2 → 0.5.0

package/runtime/static.c

@@ -85,6 +85,64 @@ static void add_cache_headers(cerver_response_t* res, const char* path) {
   }
 }
 
+/* ------------------------------------------------------------------ */
+/*  Helper to resolve fallback paths for directory/clean-URL routes.  */
+/*  - "/" -> "/index.html"                                            */
+/*  - "/page" or "/page/" -> "/page/page.html"                        */
+/* ------------------------------------------------------------------ */
+
+static void get_fallback_path(const char* path, char* out, size_t out_len) {
+  if (strcmp(path, "/") == 0 || strcmp(path, "") == 0) {
+    snprintf(out, out_len, "/index.html");
+    return;
+  }
+
+  size_t len = strlen(path);
+  while (len > 0 && path[len - 1] == '/') {
+    len--;
+  }
+
+  if (len == 0) {
+    snprintf(out, out_len, "/index.html");
+    return;
+  }
+
+  int last_slash = -1;
+  for (int i = (int)len - 1; i >= 0; i--) {
+    if (path[i] == '/') {
+      last_slash = i;
+      break;
+    }
+  }
+
+  size_t segment_len = len - (last_slash + 1);
+  if (segment_len == 0) {
+    snprintf(out, out_len, "/index.html");
+    return;
+  }
+
+  /* Extract the prefix and segment safely */
+  char prefix[1024];
+  if (len < sizeof(prefix)) {
+    memcpy(prefix, path, len);
+    prefix[len] = '\0';
+  } else {
+    snprintf(out, out_len, "/index.html");
+    return;
+  }
+
+  char segment[256];
+  if (segment_len < sizeof(segment)) {
+    memcpy(segment, path + last_slash + 1, segment_len);
+    segment[segment_len] = '\0';
+  } else {
+    snprintf(out, out_len, "/index.html");
+    return;
+  }
+
+  snprintf(out, out_len, "%s/%s.html", prefix, segment);
+}
+
 /* ------------------------------------------------------------------ */
 /*  Serve from embedded assets — hash-accelerated lookup              */
 /* ------------------------------------------------------------------ */
@@ -110,19 +168,15 @@ static int serve_embedded(cerver_server_t* srv, cerver_request_t* req, cerver_re
     }
   }
 
-  /* Try with /index.html appended (for directory-like paths) */
+  /* Try with fallback path (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);
-    }
+    char fallback_path[CERVER_MAX_PATH];
+    get_fallback_path(path, fallback_path, sizeof(fallback_path));
 
-    uint32_t idx_hash = fnv1a(index_path);
+    uint32_t idx_hash = fnv1a(fallback_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) {
+      if (fnv1a(srv->assets[i].path) == idx_hash &&
+          strcmp(srv->assets[i].path, fallback_path) == 0) {
         found = &srv->assets[i];
         break;
       }
@@ -168,10 +222,12 @@ static int serve_filesystem(cerver_server_t* srv, cerver_request_t* req, cerver_
   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 */
+  /* Check if it's a directory — try fallback path */
   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);
+    char fallback_path[CERVER_MAX_PATH];
+    get_fallback_path(path, fallback_path, sizeof(fallback_path));
+    snprintf(full_path, sizeof(full_path), "%s%s", srv->public_dir, fallback_path);
     if (stat(full_path, &st) != 0) return -1;
   }
 
@@ -189,59 +245,19 @@ static int serve_filesystem(cerver_server_t* srv, cerver_request_t* req, cerver_
   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.
+   * Use sendfile for zero-copy filesystem static serving.
+   * The file is opened and its descriptor is stored in the response structure
+   * for streaming directly to the client socket in the writer.
    */
-  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 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 */
-  }
+  int fd = open(full_path, O_RDONLY);
+  if (fd < 0) return -1;
+
+  res->status       = 200;
+  res->content_type = mime;
+  res->body         = NULL;
+  res->body_len     = file_size;
+  res->_body_owned  = 3; /* Special flag: sendfile, close fd */
+  res->_file_fd     = fd;
 
   add_cache_headers(res, path);
 

package/runtime/tests/runtime_tests.c

@@ -224,6 +224,22 @@ static void test_route_match_mismatch_resets_params(void) {
   MU_ASSERT_EQ_INT(0, req.params_count);
 }
 
+static void test_route_match_multi_segment(void) {
+  cerver_route_t route;
+  route.method  = "GET";
+  route.pattern = "/users/:id/profile";
+  route.handler = handler_a;
+
+  cerver_request_t req;
+  memset(&req, 0, sizeof(req));
+  strcpy(req.method, "GET");
+  strcpy(req.path, "/users/123/profile");
+
+  MU_ASSERT(cerver_route_match(&route, &req) == 1);
+  MU_ASSERT_EQ_INT(1, req.params_count);
+  MU_ASSERT_STREQ("123", cerver_req_param(&req, "id"));
+}
+
 static void test_request_header_helpers(void) {
   cerver_request_t req;
   memset(&req, 0, sizeof(req));
@@ -272,9 +288,9 @@ static void test_static_embedded_index_fallback(void) {
   cerver_server_t srv;
   cerver_init(&srv, 8080, 1);
 
-  static const unsigned char data[] = "docs";
+  static const unsigned char data[] = "about";
   cerver_asset_t             assets[1];
-  assets[0].path        = "/docs/index.html";
+  assets[0].path        = "/about/about.html";
   assets[0].mime_type   = "text/html";
   assets[0].data        = data;
   assets[0].data_len    = sizeof(data) - 1;
@@ -289,13 +305,91 @@ static void test_static_embedded_index_fallback(void) {
   memset(&req, 0, sizeof(req));
   memset(&res, 0, sizeof(res));
   strcpy(req.method, "GET");
-  strcpy(req.path, "/docs/");
+  strcpy(req.path, "/about/");
 
   MU_ASSERT_EQ_INT(0, cerver_serve_static(&srv, &req, &res));
   MU_ASSERT(res.body == (const char*)data);
   MU_ASSERT_STREQ("text/html", res.content_type);
 }
 
+static void test_static_filesystem_directory_fallback(void) {
+  char  dir_template[] = "/tmp/cerver-test-XXXXXX";
+  char* dir            = mkdtemp(dir_template);
+  MU_ASSERT(dir != NULL);
+
+  /* Create public/index.html (maps to /) */
+  char file_path[PATH_MAX];
+  snprintf(file_path, sizeof(file_path), "%s/index.html", dir);
+  MU_ASSERT_EQ_INT(0, write_file(file_path, "root index", 10));
+
+  /* Create public/about/about.html (maps to /about or /about/) */
+  char sub_dir[PATH_MAX];
+  snprintf(sub_dir, sizeof(sub_dir), "%s/about", dir);
+  MU_ASSERT_EQ_INT(0, mkdir(sub_dir, 0700));
+
+  char file_path2[PATH_MAX];
+  snprintf(file_path2, sizeof(file_path2), "%s/about/about.html", dir);
+  MU_ASSERT_EQ_INT(0, write_file(file_path2, "about content", 13));
+
+  /* Create public/about/index.html (should NOT map to /about, since index.html under subdirectory
+   * doesn't alias) */
+  char file_path3[PATH_MAX];
+  snprintf(file_path3, sizeof(file_path3), "%s/about/index.html", dir);
+  MU_ASSERT_EQ_INT(0, write_file(file_path3, "about index", 11));
+
+  cerver_server_t srv;
+  cerver_init(&srv, 8080, 1);
+  cerver_set_public_dir(&srv, dir);
+
+  /* Test / -> index.html fallback */
+  {
+    cerver_request_t  req;
+    cerver_response_t res;
+    memset(&req, 0, sizeof(req));
+    memset(&res, 0, sizeof(res));
+    strcpy(req.method, "GET");
+    strcpy(req.path, "/");
+
+    MU_ASSERT_EQ_INT(0, cerver_serve_static(&srv, &req, &res));
+    MU_ASSERT_EQ_SIZE(10, res.body_len);
+    if (res._body_owned == 3 && res._file_fd >= 0) close(res._file_fd);
+  }
+
+  /* Test /about -> about/about.html fallback */
+  {
+    cerver_request_t  req;
+    cerver_response_t res;
+    memset(&req, 0, sizeof(req));
+    memset(&res, 0, sizeof(res));
+    strcpy(req.method, "GET");
+    strcpy(req.path, "/about");
+
+    MU_ASSERT_EQ_INT(0, cerver_serve_static(&srv, &req, &res));
+    MU_ASSERT_EQ_SIZE(13, res.body_len);
+    if (res._body_owned == 3 && res._file_fd >= 0) close(res._file_fd);
+  }
+
+  /* Test /about/ -> about/about.html fallback */
+  {
+    cerver_request_t  req;
+    cerver_response_t res;
+    memset(&req, 0, sizeof(req));
+    memset(&res, 0, sizeof(res));
+    strcpy(req.method, "GET");
+    strcpy(req.path, "/about/");
+
+    MU_ASSERT_EQ_INT(0, cerver_serve_static(&srv, &req, &res));
+    MU_ASSERT_EQ_SIZE(13, res.body_len);
+    if (res._body_owned == 3 && res._file_fd >= 0) close(res._file_fd);
+  }
+
+  unlink(file_path);
+  unlink(file_path2);
+  unlink(file_path3);
+  rmdir(sub_dir);
+  rmdir(dir);
+}
+
 static void test_static_filesystem_small(void) {
   char  dir_template[] = "/tmp/cerver-test-XXXXXX";
   char* dir            = mkdtemp(dir_template);
@@ -318,10 +412,27 @@ static void test_static_filesystem_small(void) {
 
   MU_ASSERT_EQ_INT(0, cerver_serve_static(&srv, &req, &res));
   MU_ASSERT_EQ_SIZE(5, res.body_len);
-  MU_ASSERT(memcmp(res.body, "small", 5) == 0);
-  MU_ASSERT_EQ_INT(1, res._body_owned);
+  MU_ASSERT(res.body == NULL);
+  MU_ASSERT_EQ_INT(3, res._body_owned);
+  MU_ASSERT(res._file_fd >= 0);
+
+  int fds[2];
+  MU_ASSERT(pipe(fds) == 0);
+  MU_ASSERT_EQ_INT(0, cerver_write_response(fds[1], &res, 1));
+  close(fds[1]);
+
+  char    out[1024];
+  ssize_t n = read_all(fds[0], out, sizeof(out));
+  MU_ASSERT(n > 0);
+  close(fds[0]);
+
+  MU_ASSERT(strstr(out, "HTTP/1.1 200 OK\r\n") != NULL);
+  MU_ASSERT(strstr(out, "Content-Length: 5\r\n") != NULL);
+  MU_ASSERT(strstr(out, "\r\nsmall") != NULL);
 
-  free((void*)res.body);
+  if (res._body_owned == 3 && res._file_fd >= 0) {
+    close(res._file_fd);
+  }
   unlink(file_path);
   rmdir(dir);
 }
@@ -334,10 +445,10 @@ static void test_static_filesystem_large(void) {
   char file_path[PATH_MAX];
   snprintf(file_path, sizeof(file_path), "%s/large.bin", dir);
 
-  char* payload = (char*)malloc(70000);
+  char* payload = (char*)malloc(32000);
   MU_ASSERT(payload != NULL);
-  memset(payload, 'a', 70000);
-  MU_ASSERT_EQ_INT(0, write_file(file_path, payload, 70000));
+  memset(payload, 'a', 32000);
+  MU_ASSERT_EQ_INT(0, write_file(file_path, payload, 32000));
   free(payload);
 
   cerver_server_t srv;
@@ -352,11 +463,27 @@ static void test_static_filesystem_large(void) {
   strcpy(req.path, "/large.bin");
 
   MU_ASSERT_EQ_INT(0, cerver_serve_static(&srv, &req, &res));
-  MU_ASSERT_EQ_SIZE(70000, res.body_len);
-  MU_ASSERT_EQ_INT(2, res._body_owned);
-  MU_ASSERT(((const char*)res.body)[0] == 'a');
+  MU_ASSERT_EQ_SIZE(32000, res.body_len);
+  MU_ASSERT(res.body == NULL);
+  MU_ASSERT_EQ_INT(3, res._body_owned);
+  MU_ASSERT(res._file_fd >= 0);
+
+  int fds[2];
+  MU_ASSERT(pipe(fds) == 0);
+  MU_ASSERT_EQ_INT(0, cerver_write_response(fds[1], &res, 1));
+  close(fds[1]);
+
+  char    out[35000];
+  ssize_t n = read_all(fds[0], out, sizeof(out));
+  MU_ASSERT(n > 0);
+  close(fds[0]);
 
-  munmap((void*)res.body, res.body_len);
+  MU_ASSERT(strstr(out, "HTTP/1.1 200 OK\r\n") != NULL);
+  MU_ASSERT(strstr(out, "Content-Length: 32000\r\n") != NULL);
+
+  if (res._body_owned == 3 && res._file_fd >= 0) {
+    close(res._file_fd);
+  }
   unlink(file_path);
   rmdir(dir);
 }
@@ -402,11 +529,13 @@ int main(void) {
   mu_run("write_response_force_close", test_write_response_force_close);
   mu_run("route_match_and_dispatch", test_route_match_and_dispatch);
   mu_run("route_match_mismatch_resets_params", test_route_match_mismatch_resets_params);
+  mu_run("route_match_multi_segment", test_route_match_multi_segment);
   mu_run("request_header_helpers", test_request_header_helpers);
   mu_run("static_embedded_prefers_br", test_static_embedded_prefers_br);
   mu_run("static_embedded_index_fallback", test_static_embedded_index_fallback);
   mu_run("static_filesystem_small", test_static_filesystem_small);
   mu_run("static_filesystem_large", test_static_filesystem_large);
+  mu_run("static_filesystem_directory_fallback", test_static_filesystem_directory_fallback);
   mu_run("static_rejects_unsafe_path", test_static_rejects_unsafe_path);
   mu_run("stat_cache_store_lookup", test_stat_cache_store_lookup);
   mu_run("cerver_init_fields", test_cerver_init_fields);

package/.github/workflows/ci.yml

@@ -1,35 +0,0 @@
-name: CI
-
-on:
-  push:
-  pull_request:
-
-jobs:
-  tests:
-    name: Tests
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v6
-
-      - name: Setup pnpm
-        uses: pnpm/action-setup@v6
-        with:
-          version: 10
-          run_install: false
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v6
-        with:
-          node-version: 24
-          cache: pnpm
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Run runtime tests
-        run: make test-runtime
-
-      - name: Run JS tests
-        run: pnpm test

package/.github/workflows/publish.yml

@@ -1,50 +0,0 @@
-name: Publish package
-
-on:
-  push:
-    tags:
-      - "v*"
-  workflow_dispatch:
-
-permissions:
-  contents: write
-  id-token: write
-
-jobs:
-  publish:
-    name: Publish to npm
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v6
-
-      - name: Setup pnpm
-        uses: pnpm/action-setup@v6
-        with:
-          version: 10
-          run_install: false
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v6
-        with:
-          node-version: 24
-          registry-url: https://registry.npmjs.org
-          cache: pnpm
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Run runtime tests
-        run: make test-runtime
-
-      - name: Run tests
-        run: pnpm test
-
-      - name: Verify package contents
-        run: npm pack --dry-run
-
-      - name: Publish to npm
-        run: npm publish --access public --provenance
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}