@velox0/cerver 0.1.0 → 0.3.0

package/runtime/server.c

@@ -1,7 +1,9 @@
 /*
- * server.c — Socket setup and event loop for the cerver runtime.
+ * server.c — Socket setup, thread pool, and event loop for the cerver runtime.
  *
  * Uses kqueue on macOS, epoll on Linux, with a select() fallback.
+ * Requests are dispatched to a fixed-size thread pool via a ring-buffer
+ * task queue protected by a mutex + condition variable.
  */
 
 #include "cerver.h"
@@ -17,6 +19,7 @@
 #include <sys/types.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
+#include <pthread.h>
 
 /* Platform-specific event API */
 #if defined(__APPLE__) || defined(__FreeBSD__)
@@ -49,53 +52,122 @@ static int set_nonblocking(int fd) {
 }
 
 /* ------------------------------------------------------------------ */
-/*  Handle a single connection: read, parse, dispatch, respond        */
+/*  memmem fallback for systems that lack it                          */
 /* ------------------------------------------------------------------ */
 
-static int set_blocking(int fd) {
-    int flags = fcntl(fd, F_GETFL, 0);
-    if (flags < 0) return -1;
-    return fcntl(fd, F_SETFL, flags & ~O_NONBLOCK);
+#if !defined(__APPLE__) && !defined(__linux__) && !defined(_GNU_SOURCE)
+static void *cerver_memmem(const void *hay, size_t haylen,
+                           const void *needle, size_t nlen) {
+    if (nlen == 0) return (void *)hay;
+    if (nlen > haylen) return NULL;
+    const char *p = (const char *)hay;
+    const char *end = p + haylen - nlen;
+    for (; p <= end; p++) {
+        if (memcmp(p, needle, nlen) == 0) return (void *)p;
+    }
+    return NULL;
 }
+#define memmem cerver_memmem
+#endif
+
+/* ------------------------------------------------------------------ */
+/*  Buffered read — accumulates until \r\n\r\n or limit reached       */
+/* ------------------------------------------------------------------ */
+
+static char *read_full_request(int fd, size_t *out_len) {
+    size_t cap = CERVER_READ_BUF;
+    size_t len = 0;
+    char *buf = malloc(cap + 1); /* +1 for null terminator */
+    if (!buf) return NULL;
+
+    while (len < (size_t)CERVER_READ_BUF_MAX) {
+        ssize_t n = read(fd, buf + len, cap - len);
+        if (n <= 0) break;
+        len += (size_t)n;
+
+        /* Check for end of headers */
+        if (len >= 4 && memmem(buf, len, "\r\n\r\n", 4)) break;
+
+        /* Grow buffer if full */
+        if (len == cap) {
+            size_t newcap = cap * 2;
+            if (newcap > (size_t)CERVER_READ_BUF_MAX)
+                newcap = (size_t)CERVER_READ_BUF_MAX;
+            char *tmp = realloc(buf, newcap + 1);
+            if (!tmp) { free(buf); return NULL; }
+            buf = tmp;
+            cap = newcap;
+        }
+    }
+
+    if (len == 0) {
+        free(buf);
+        return NULL;
+    }
+
+    buf[len] = '\0';
+    *out_len = len;
+    return buf;
+}
+
+/* ------------------------------------------------------------------ */
+/*  Handle a single connection: read, parse, dispatch, respond        */
+/* ------------------------------------------------------------------ */
 
 static void handle_connection(cerver_server_t *srv, int client_fd) {
-    /* Client sockets may inherit non-blocking mode from listener.
-       Set to blocking so read() waits for data. */
-    set_blocking(client_fd);
+    /* Ensure the client socket is in blocking mode for reads.
+       Some platforms inherit O_NONBLOCK from the listening socket. */
+    int flags = fcntl(client_fd, F_GETFL, 0);
+    if (flags >= 0 && (flags & O_NONBLOCK)) {
+        fcntl(client_fd, F_SETFL, flags & ~O_NONBLOCK);
+    }
+
+    /* Set a read timeout so workers don't block on stale connections */
+    struct timeval tv = { 5, 0 }; /* 5 seconds */
+    setsockopt(client_fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
 
-    char buf[CERVER_READ_BUF];
-    ssize_t n = read(client_fd, buf, sizeof(buf) - 1);
+    /* Read the full request with buffering */
+    size_t req_len = 0;
+    char *buf = read_full_request(client_fd, &req_len);
 
-    if (n <= 0) {
+    if (!buf || req_len == 0) {
+        if (buf) free(buf);
         close(client_fd);
         return;
     }
-    buf[n] = '\0';
 
     /* Parse HTTP request */
     cerver_request_t req;
     memset(&req, 0, sizeof(req));
 
-    if (cerver_parse_request(buf, (size_t)n, &req) < 0) {
+    if (cerver_parse_request(buf, req_len, &req) < 0) {
         /* Bad request — send 400 */
         const char *resp = "HTTP/1.1 400 Bad Request\r\nContent-Length: 11\r\nConnection: close\r\n\r\nBad Request";
         write(client_fd, resp, strlen(resp));
+        free(buf);
         close(client_fd);
         return;
     }
 
+    /*
+     * The parser malloc'd its own mutable copy (req._raw_buf) and all
+     * internal pointers (path, headers, etc.) reference that copy.
+     * We can now free our original read buffer.
+     */
+    free(buf);
+
     /* Prepare response */
     cerver_response_t res;
     memset(&res, 0, sizeof(res));
 
-    /* Try to dispatch to a route handler */
-    cerver_handler_fn handler = cerver_dispatch(srv, &req);
+    /* Try static assets first — files take priority over route handlers */
+    if (cerver_serve_static(srv, &req, &res) < 0) {
+        /* No static file found — try route handlers */
+        cerver_handler_fn handler = cerver_dispatch(srv, &req);
 
-    if (handler) {
-        handler(&req, &res);
-    } else {
-        /* Try static assets */
-        if (cerver_serve_static(srv, &req, &res) < 0) {
+        if (handler) {
+            handler(&req, &res);
+        } else {
             /* 404 */
             cerver_res_text(&res, 404, "Not Found");
         }
@@ -115,16 +187,91 @@ static void handle_connection(cerver_server_t *srv, int client_fd) {
     close(client_fd);
 }
 
+/* ------------------------------------------------------------------ */
+/*  Thread pool — task queue (ring buffer)                             */
+/* ------------------------------------------------------------------ */
+
+static int enqueue_task(cerver_server_t *srv, int client_fd) {
+    pthread_mutex_lock(&srv->tq_mutex);
+
+    if (srv->tq_count >= CERVER_TASK_QUEUE_SIZE) {
+        /* Queue full — drop connection */
+        pthread_mutex_unlock(&srv->tq_mutex);
+        const char *resp = "HTTP/1.1 503 Service Unavailable\r\n"
+                           "Content-Length: 19\r\nConnection: close\r\n\r\n"
+                           "Service Unavailable";
+        write(client_fd, resp, strlen(resp));
+        close(client_fd);
+        return -1;
+    }
+
+    srv->task_queue[srv->tq_tail] = client_fd;
+    srv->tq_tail = (srv->tq_tail + 1) % CERVER_TASK_QUEUE_SIZE;
+    srv->tq_count++;
+
+    pthread_cond_signal(&srv->tq_cond);
+    pthread_mutex_unlock(&srv->tq_mutex);
+    return 0;
+}
+
+static int dequeue_task(cerver_server_t *srv) {
+    pthread_mutex_lock(&srv->tq_mutex);
+
+    while (srv->tq_count == 0 && srv->running) {
+        pthread_cond_wait(&srv->tq_cond, &srv->tq_mutex);
+    }
+
+    if (!srv->running && srv->tq_count == 0) {
+        pthread_mutex_unlock(&srv->tq_mutex);
+        return -1; /* shutdown signal */
+    }
+
+    int fd = srv->task_queue[srv->tq_head];
+    srv->tq_head = (srv->tq_head + 1) % CERVER_TASK_QUEUE_SIZE;
+    srv->tq_count--;
+
+    pthread_mutex_unlock(&srv->tq_mutex);
+    return fd;
+}
+
+/* ------------------------------------------------------------------ */
+/*  Worker thread entry point                                         */
+/* ------------------------------------------------------------------ */
+
+static void *worker_thread(void *arg) {
+    cerver_server_t *srv = (cerver_server_t *)arg;
+
+    while (srv->running) {
+        int client_fd = dequeue_task(srv);
+        if (client_fd < 0) break; /* shutdown */
+
+        handle_connection(srv, client_fd);
+    }
+
+    return NULL;
+}
+
 /* ------------------------------------------------------------------ */
 /*  Server init                                                       */
 /* ------------------------------------------------------------------ */
 
-int cerver_init(cerver_server_t *srv, int port) {
+int cerver_init(cerver_server_t *srv, int port, int threads) {
     memset(srv, 0, sizeof(*srv));
     srv->port = port;
     srv->sock_fd = -1;
     srv->running = 0;
     srv->public_dir = NULL;
+
+    /* Thread pool config */
+    srv->thread_count = (threads > 0) ? threads : CERVER_THREAD_POOL_DEFAULT;
+    srv->threads = NULL;
+    srv->tq_head = 0;
+    srv->tq_tail = 0;
+    srv->tq_count = 0;
+
+    pthread_mutex_init(&srv->tq_mutex, NULL);
+    pthread_cond_init(&srv->tq_cond, NULL);
+
     return 0;
 }
 
@@ -144,6 +291,43 @@ void cerver_set_public_dir(cerver_server_t *srv, const char *dir) {
     srv->public_dir = dir;
 }
 
+/* ------------------------------------------------------------------ */
+/*  Start thread pool                                                 */
+/* ------------------------------------------------------------------ */
+
+static int start_thread_pool(cerver_server_t *srv) {
+    srv->threads = malloc(sizeof(pthread_t) * (size_t)srv->thread_count);
+    if (!srv->threads) {
+        perror("cerver: malloc threads");
+        return -1;
+    }
+
+    /* Use 2 MB stack per worker (handles deep call chains with large buffers) */
+    pthread_attr_t attr;
+    pthread_attr_init(&attr);
+    pthread_attr_setstacksize(&attr, 2 * 1024 * 1024);
+
+    for (int i = 0; i < srv->thread_count; i++) {
+        if (pthread_create(&srv->threads[i], &attr, worker_thread, srv) != 0) {
+            perror("cerver: pthread_create");
+            /* Clean up already-created threads */
+            srv->running = 0;
+            pthread_cond_broadcast(&srv->tq_cond);
+            for (int j = 0; j < i; j++) {
+                pthread_join(srv->threads[j], NULL);
+            }
+            free(srv->threads);
+            srv->threads = NULL;
+            return -1;
+        }
+    }
+
+    pthread_attr_destroy(&attr);
+
+    printf("cerver: started %d worker thread(s)\n", srv->thread_count);
+    return 0;
+}
+
 /* ------------------------------------------------------------------ */
 /*  Server listen — event loop                                        */
 /* ------------------------------------------------------------------ */
@@ -190,7 +374,13 @@ int cerver_listen(cerver_server_t *srv) {
 
     srv->running = 1;
 
-    printf("cerver: listening on http://0.0.0.0:%d\n", srv->port);
+    printf("cerver: listening on http://localhost:%d\n", srv->port);
+
+    /* Start the thread pool */
+    if (start_thread_pool(srv) < 0) {
+        close(srv->sock_fd);
+        return -1;
+    }
 
 /* ================================================================== */
 /*  kqueue event loop (macOS / FreeBSD)                               */
@@ -236,7 +426,7 @@ int cerver_listen(cerver_server_t *srv) {
                         perror("cerver: accept");
                         break;
                     }
-                    handle_connection(srv, client_fd);
+                    enqueue_task(srv, client_fd);
                 }
             }
         }
@@ -285,7 +475,7 @@ int cerver_listen(cerver_server_t *srv) {
                         perror("cerver: accept");
                         break;
                     }
-                    handle_connection(srv, client_fd);
+                    enqueue_task(srv, client_fd);
                 }
             }
         }
@@ -319,7 +509,7 @@ int cerver_listen(cerver_server_t *srv) {
                                    (struct sockaddr *)&client_addr,
                                    &client_len);
             if (client_fd >= 0) {
-                handle_connection(srv, client_fd);
+                enqueue_task(srv, client_fd);
             }
         }
     }
@@ -335,10 +525,31 @@ int cerver_listen(cerver_server_t *srv) {
 /* ------------------------------------------------------------------ */
 
 void cerver_shutdown(cerver_server_t *srv) {
+    srv->running = 0;
+
+    /* Wake all worker threads so they can exit */
+    pthread_mutex_lock(&srv->tq_mutex);
+    pthread_cond_broadcast(&srv->tq_cond);
+    pthread_mutex_unlock(&srv->tq_mutex);
+
+    /* Join all worker threads */
+    if (srv->threads) {
+        for (int i = 0; i < srv->thread_count; i++) {
+            pthread_join(srv->threads[i], NULL);
+        }
+        free(srv->threads);
+        srv->threads = NULL;
+    }
+
+    /* Close listener socket */
     if (srv->sock_fd >= 0) {
         close(srv->sock_fd);
         srv->sock_fd = -1;
     }
-    srv->running = 0;
+
+    /* Destroy synchronization primitives */
+    pthread_mutex_destroy(&srv->tq_mutex);
+    pthread_cond_destroy(&srv->tq_cond);
+
     printf("\ncerver: server stopped\n");
 }

package/runtime/static.c

@@ -3,6 +3,7 @@
  *
  * In embedded mode, serves from the compiled-in asset array.
  * In external mode, serves from the filesystem (public/ directory).
+ * Supports pre-compressed gzip/brotli variants and cache headers.
  */
 
 #include "cerver.h"
@@ -29,6 +30,40 @@ static int path_is_safe(const char *path) {
     return 1;
 }
 
+/* ------------------------------------------------------------------ */
+/*  Accept-Encoding parsing                                           */
+/* ------------------------------------------------------------------ */
+
+typedef struct {
+    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;
+
+    if (strstr(ae, "br")) prefs.accepts_br = 1;
+    if (strstr(ae, "gzip")) prefs.accepts_gzip = 1;
+
+    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");
+    }
+}
+
 /* ------------------------------------------------------------------ */
 /*  Serve from embedded assets                                        */
 /* ------------------------------------------------------------------ */
@@ -38,33 +73,59 @@ static int serve_embedded(cerver_server_t *srv, cerver_request_t *req,
     if (!srv->assets || srv->asset_count == 0) return -1;
 
     const char *path = req->path;
+    const cerver_asset_t *found = NULL;
 
     /* Try exact match first */
     for (int i = 0; i < srv->asset_count; i++) {
         if (strcmp(srv->assets[i].path, path) == 0) {
-            cerver_res_file(res, 200, srv->assets[i].mime_type,
-                           srv->assets[i].data, srv->assets[i].data_len);
-            return 0;
+            found = &srv->assets[i];
+            break;
         }
     }
 
     /* Try with /index.html appended (for directory-like paths) */
-    char index_path[CERVER_MAX_PATH];
-    if (path[strlen(path) - 1] == '/') {
-        snprintf(index_path, sizeof(index_path), "%sindex.html", path);
-    } else {
-        snprintf(index_path, sizeof(index_path), "%s/index.html", path);
-    }
+    if (!found) {
+        char index_path[CERVER_MAX_PATH];
+        if (path[strlen(path) - 1] == '/') {
+            snprintf(index_path, sizeof(index_path), "%sindex.html", path);
+        } else {
+            snprintf(index_path, sizeof(index_path), "%s/index.html", path);
+        }
 
-    for (int i = 0; i < srv->asset_count; i++) {
-        if (strcmp(srv->assets[i].path, index_path) == 0) {
-            cerver_res_file(res, 200, srv->assets[i].mime_type,
-                           srv->assets[i].data, srv->assets[i].data_len);
-            return 0;
+        for (int i = 0; i < srv->asset_count; i++) {
+            if (strcmp(srv->assets[i].path, index_path) == 0) {
+                found = &srv->assets[i];
+                break;
+            }
         }
     }
 
-    return -1;
+    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;
 }
 
 /* ------------------------------------------------------------------ */
@@ -123,6 +184,8 @@ static int serve_filesystem(cerver_server_t *srv, cerver_request_t *req,
     res->body_len = file_size;
     res->_body_owned = 1; /* We malloc'd this */
 
+    add_cache_headers(res, path);
+
     return 0;
 }