@velox0/cerver 0.1.0

package/runtime/http_writer.c

@@ -0,0 +1,137 @@
+/*
+ * http_writer.c — HTTP/1.1 response writer.
+ *
+ * Formats a cerver_response_t into raw HTTP bytes and writes to a socket fd.
+ */
+
+#include "cerver.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+/* ------------------------------------------------------------------ */
+/*  Status text lookup                                                */
+/* ------------------------------------------------------------------ */
+
+static const char *status_text(int code) {
+    switch (code) {
+        case 200: return "OK";
+        case 201: return "Created";
+        case 204: return "No Content";
+        case 301: return "Moved Permanently";
+        case 302: return "Found";
+        case 304: return "Not Modified";
+        case 400: return "Bad Request";
+        case 401: return "Unauthorized";
+        case 403: return "Forbidden";
+        case 404: return "Not Found";
+        case 405: return "Method Not Allowed";
+        case 500: return "Internal Server Error";
+        default:  return "Unknown";
+    }
+}
+
+/* ------------------------------------------------------------------ */
+/*  Write the full response to fd                                     */
+/* ------------------------------------------------------------------ */
+
+int cerver_write_response(int fd, const cerver_response_t *res) {
+    /* Build the response header */
+    char header[4096];
+    int hlen = 0;
+
+    /* Status line */
+    hlen += snprintf(header + hlen, sizeof(header) - (size_t)hlen,
+                     "HTTP/1.1 %d %s\r\n", res->status, status_text(res->status));
+
+    /* Content-Type */
+    if (res->content_type) {
+        hlen += snprintf(header + hlen, sizeof(header) - (size_t)hlen,
+                         "Content-Type: %s\r\n", res->content_type);
+    }
+
+    /* Content-Length */
+    hlen += snprintf(header + hlen, sizeof(header) - (size_t)hlen,
+                     "Content-Length: %zu\r\n", res->body_len);
+
+    /* Extra headers */
+    for (int i = 0; i < res->header_count; i++) {
+        hlen += snprintf(header + hlen, sizeof(header) - (size_t)hlen,
+                         "%s: %s\r\n",
+                         res->headers[i].key, res->headers[i].value);
+    }
+
+    /* Connection: close (we don't do keep-alive in v0.1) */
+    hlen += snprintf(header + hlen, sizeof(header) - (size_t)hlen,
+                     "Connection: close\r\n");
+
+    /* Server header */
+    hlen += snprintf(header + hlen, sizeof(header) - (size_t)hlen,
+                     "Server: cerver\r\n");
+
+    /* End of headers */
+    hlen += snprintf(header + hlen, sizeof(header) - (size_t)hlen, "\r\n");
+
+    /* Write header */
+    ssize_t written = write(fd, header, (size_t)hlen);
+    if (written < 0) return -1;
+
+    /* Write body */
+    if (res->body && res->body_len > 0) {
+        size_t total = 0;
+        while (total < res->body_len) {
+            ssize_t n = write(fd, res->body + total, res->body_len - total);
+            if (n < 0) return -1;
+            total += (size_t)n;
+        }
+    }
+
+    return 0;
+}
+
+/* ------------------------------------------------------------------ */
+/*  Response helper functions                                         */
+/* ------------------------------------------------------------------ */
+
+void cerver_res_text(cerver_response_t *res, int status, const char *text) {
+    res->status = status;
+    res->content_type = "text/plain; charset=utf-8";
+    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->content_type = "application/json; charset=utf-8";
+    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->content_type = "text/html; charset=utf-8";
+    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->content_type = mime;
+    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].value = val;
+        res->header_count++;
+    }
+}

package/runtime/mime.c

@@ -0,0 +1,84 @@
+/*
+ * mime.c — MIME type detection by file extension.
+ */
+
+#include "cerver.h"
+
+#include <string.h>
+#include <ctype.h>
+
+typedef struct {
+    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" },
+
+    /* Text */
+    { ".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" },
+
+    /* Fonts */
+    { ".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" },
+
+    /* Archives */
+    { ".zip",   "application/zip" },
+    { ".gz",    "application/gzip" },
+    { ".tar",   "application/x-tar" },
+
+    /* Documents */
+    { ".pdf",   "application/pdf" },
+
+    /* Misc */
+    { ".wasm",  "application/wasm" },
+    { ".map",   "application/json" },
+
+    { NULL, NULL }
+};
+
+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";
+
+    /* 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";
+}

package/runtime/router.c

@@ -0,0 +1,150 @@
+/*
+ * router.c — Route matching and dispatch.
+ *
+ * Matches incoming requests against registered route patterns.
+ * Supports static paths and dynamic segments (:param).
+ */
+
+#include "cerver.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.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;
+        }
+    }
+    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;
+        }
+    }
+    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;
+        }
+    }
+    return NULL;
+}
+
+/* ------------------------------------------------------------------ */
+/*  Pattern matching with dynamic segment extraction                  */
+/* ------------------------------------------------------------------ */
+
+/*
+ * Match a route pattern against a request path.
+ * Pattern segments starting with ':' are dynamic and extract values.
+ *
+ * Examples:
+ *   pattern="/art/:key"  path="/art/sunset"  → match, key="sunset"
+ *   pattern="/"          path="/"             → match
+ *   pattern="/api/data"  path="/api/data"     → match
+ *   pattern="/api/data"  path="/api/other"    → no match
+ */
+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;
+
+    /* Fast path: exact match */
+    if (strcmp(pattern, path) == 0) {
+        return 1;
+    }
+
+    /* Segment-by-segment matching */
+    /* We'll work with copies so we can tokenize */
+    char pat_buf[CERVER_MAX_PATH];
+    char path_buf[CERVER_MAX_PATH];
+    strncpy(pat_buf, pattern, sizeof(pat_buf) - 1);
+    pat_buf[sizeof(pat_buf) - 1] = '\0';
+    strncpy(path_buf, path, sizeof(path_buf) - 1);
+    path_buf[sizeof(path_buf) - 1] = '\0';
+
+    /* Split into segments */
+    char *pat_segments[64];
+    char *path_segments[64];
+    int pat_count = 0;
+    int path_count = 0;
+
+    char *saveptr;
+    char *tok;
+
+    tok = strtok_r(pat_buf, "/", &saveptr);
+    while (tok && pat_count < 64) {
+        pat_segments[pat_count++] = tok;
+        tok = strtok_r(NULL, "/", &saveptr);
+    }
+
+    tok = strtok_r(path_buf, "/", &saveptr);
+    while (tok && path_count < 64) {
+        path_segments[path_count++] = tok;
+        tok = strtok_r(NULL, "/", &saveptr);
+    }
+
+    /* Segment counts must match */
+    if (pat_count != path_count) {
+        return 0;
+    }
+
+    /* Match each segment */
+    /* Reset params before populating */
+    int saved_params = req->params_count;
+
+    for (int i = 0; i < pat_count; i++) {
+        if (pat_segments[i][0] == ':') {
+            /* Dynamic segment — extract parameter */
+            if (req->params_count < CERVER_MAX_PARAMS) {
+                /* The key is the segment name without ':' */
+                /* We need stable storage — use the request's internal structures.
+                   Since we're in the request's lifetime, we can use strdup. */
+                req->params[req->params_count].key = pat_segments[i] + 1;
+                req->params[req->params_count].value = path_segments[i];
+                req->params_count++;
+            }
+        } else {
+            /* Static segment — must match exactly */
+            if (strcmp(pat_segments[i], path_segments[i]) != 0) {
+                /* Restore params on mismatch */
+                req->params_count = saved_params;
+                return 0;
+            }
+        }
+    }
+
+    return 1;
+}
+
+/* ------------------------------------------------------------------ */
+/*  Dispatch: find and return the handler for a request               */
+/* ------------------------------------------------------------------ */
+
+cerver_handler_fn cerver_dispatch(cerver_server_t *srv, cerver_request_t *req) {
+    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;
+        }
+    }
+
+    return NULL;
+}