/* * lib/web-server-technology/native/src/slweb.c * * SLeeLa Web Server Technology -- native C11 library core. * Dependency-free (libc only); no sockets, no HTTP wire handling. */ #include "slweb.h" #include #include #include #if defined(_WIN32) || defined(_WIN64) #include /* GetSystemInfo for the CPU count on Windows */ #else #include /* sysconf(_SC_NPROCESSORS_ONLN) on POSIX/macOS */ #endif const char *slweb_version(void) { return "1.0.0"; } /* ================================================================== */ /* Envelopment */ /* ================================================================== */ typedef struct { char name[SLWEB_MAX_NAME]; slweb_program_kind kind; char mount[SLWEB_MAX_PATH]; char resource[SLWEB_MAX_PATH]; int writable; } slweb_program; typedef struct { char cause[SLWEB_MAX_PATH]; char subject[SLWEB_MAX_NAME]; char path_prefix[SLWEB_MAX_PATH]; char program[SLWEB_MAX_NAME]; int enabled; } slweb_warrant; struct slweb_envelopment { char domain[SLWEB_MAX_NAME]; int enabled; int scientist; slweb_program *programs; size_t n_programs, cap_programs; slweb_warrant *warrants; size_t n_warrants, cap_warrants; }; static void copy_bounded(char *dst, size_t cap, const char *src) { if (!src) { dst[0] = 0; return; } size_t n = strlen(src); if (n >= cap) n = cap - 1; memcpy(dst, src, n); dst[n] = 0; } slweb_envelopment *slweb_env_new(const char *domain) { slweb_envelopment *e = (slweb_envelopment *)calloc(1, sizeof *e); if (!e) return NULL; copy_bounded(e->domain, sizeof e->domain, domain ? domain : ""); return e; } void slweb_env_free(slweb_envelopment *env) { if (!env) return; free(env->programs); free(env->warrants); free(env); } void slweb_env_set_enabled(slweb_envelopment *env, int enabled) { if (env) env->enabled = enabled ? 1 : 0; } void slweb_env_set_scientist(slweb_envelopment *env, int scientist) { if (env) env->scientist = scientist ? 1 : 0; } int slweb_env_enabled(const slweb_envelopment *env) { return env ? env->enabled : 0; } int slweb_env_scientist(const slweb_envelopment *env) { return env ? env->scientist : 0; } static int ensure_programs(slweb_envelopment *e) { if (e->n_programs < e->cap_programs) return 1; size_t ncap = e->cap_programs ? e->cap_programs * 2 : 4; slweb_program *p = (slweb_program *)realloc(e->programs, ncap * sizeof *p); if (!p) return 0; e->programs = p; e->cap_programs = ncap; return 1; } static int ensure_warrants(slweb_envelopment *e) { if (e->n_warrants < e->cap_warrants) return 1; size_t ncap = e->cap_warrants ? e->cap_warrants * 2 : 4; slweb_warrant *w = (slweb_warrant *)realloc(e->warrants, ncap * sizeof *w); if (!w) return 0; e->warrants = w; e->cap_warrants = ncap; return 1; } static const slweb_program *find_program(const slweb_envelopment *e, const char *name) { for (size_t i = 0; i < e->n_programs; ++i) if (strcmp(e->programs[i].name, name) == 0) return &e->programs[i]; return NULL; } slweb_status slweb_env_add_program(slweb_envelopment *env, const char *name, slweb_program_kind kind, const char *mount, const char *resource, int writable) { if (!env || !name || !*name) return SLWEB_ERR_ARG; if (strlen(name) >= SLWEB_MAX_NAME) return SLWEB_ERR_RANGE; if (find_program(env, name)) return SLWEB_ERR_ARG; /* duplicate */ if (!ensure_programs(env)) return SLWEB_ERR_OOM; slweb_program *p = &env->programs[env->n_programs++]; memset(p, 0, sizeof *p); copy_bounded(p->name, sizeof p->name, name); p->kind = kind; copy_bounded(p->mount, sizeof p->mount, mount ? mount : "/"); copy_bounded(p->resource, sizeof p->resource, resource ? resource : ""); p->writable = writable ? 1 : 0; return SLWEB_OK; } slweb_status slweb_env_add_warrant(slweb_envelopment *env, const char *cause, const char *subject, const char *path_prefix, const char *program, int enabled) { if (!env || !cause || !*cause) return SLWEB_ERR_ARG; if (!ensure_warrants(env)) return SLWEB_ERR_OOM; slweb_warrant *w = &env->warrants[env->n_warrants++]; memset(w, 0, sizeof *w); copy_bounded(w->cause, sizeof w->cause, cause); copy_bounded(w->subject, sizeof w->subject, subject ? subject : "*"); copy_bounded(w->path_prefix, sizeof w->path_prefix, path_prefix ? path_prefix : ""); copy_bounded(w->program, sizeof w->program, program ? program : ""); w->enabled = enabled ? 1 : 0; return SLWEB_OK; } size_t slweb_env_program_count(const slweb_envelopment *env) { return env ? env->n_programs : 0; } size_t slweb_env_warrant_count(const slweb_envelopment *env) { return env ? env->n_warrants : 0; } int slweb_env_active(const slweb_envelopment *env) { if (!env) return 0; return env->enabled && env->scientist && env->n_warrants > 0; } static int starts_with(const char *s, const char *prefix) { size_t n = strlen(prefix); return strncmp(s, prefix, n) == 0; } slweb_status slweb_env_resolve(const slweb_envelopment *env, const char *host, const char *path, char *out_program, char *out_cause, slweb_program_kind *out_kind) { if (!env) return SLWEB_ERR_ARG; if (!slweb_env_active(env)) return SLWEB_ERR_DENIED; if (!path) path = "/"; if (!host) host = ""; const slweb_warrant *best = NULL; const slweb_program *best_prog = NULL; size_t best_len = 0; int have = 0; for (size_t i = 0; i < env->n_warrants; ++i) { const slweb_warrant *w = &env->warrants[i]; if (!w->enabled) continue; if (!(strcmp(w->subject, "*") == 0 || strcmp(w->subject, host) == 0)) continue; if (w->path_prefix[0] && !starts_with(path, w->path_prefix)) continue; const slweb_program *p = find_program(env, w->program); if (!p) continue; size_t len = strlen(w->path_prefix); if (!have || len > best_len) { have = 1; best = w; best_prog = p; best_len = len; } } if (!have) return SLWEB_ERR_NOTFOUND; if (out_program) copy_bounded(out_program, SLWEB_MAX_NAME, best_prog->name); if (out_cause) copy_bounded(out_cause, SLWEB_MAX_PATH, best->cause); if (out_kind) *out_kind = best_prog->kind; return SLWEB_OK; } const char *slweb_program_kind_name(slweb_program_kind k) { switch (k) { case SLWEB_PROGRAM_STATIC: return "static"; case SLWEB_PROGRAM_SQL: return "sql"; case SLWEB_PROGRAM_MEME: return "meme"; } return "meme"; } /* ================================================================== */ /* Rate limiter */ /* ================================================================== */ typedef struct { char peer[64]; unsigned long long *stamps; /* ring of request times (ms) */ size_t n, cap, head; /* count, capacity, ring head */ } slweb_peer_window; struct slweb_rate { unsigned per_peer_max, global_max, window_ms; unsigned long long *global_stamps; size_t global_n, global_cap, global_head; slweb_peer_window *peers; size_t n_peers, cap_peers; }; slweb_rate *slweb_rate_new(unsigned per_peer_max, unsigned global_max, unsigned window_ms) { slweb_rate *r = (slweb_rate *)calloc(1, sizeof *r); if (!r) return NULL; r->per_peer_max = per_peer_max; r->global_max = global_max; r->window_ms = window_ms ? window_ms : 1000; return r; } void slweb_rate_free(slweb_rate *r) { if (!r) return; free(r->global_stamps); for (size_t i = 0; i < r->n_peers; ++i) free(r->peers[i].stamps); free(r->peers); free(r); } int slweb_rate_enabled(const slweb_rate *r) { return r && (r->per_peer_max != 0 || r->global_max != 0); } /* Keep stamps still within the window: stamp is live iff stamp + window > now. * Written overflow-safe (no now-window subtraction that could underflow), so a * stamp recorded at t=0 is correctly still live while now < window. Compacts in * place and returns the kept count. */ static size_t window_count(unsigned long long *stamps, size_t n, unsigned long long now_ms, unsigned window_ms) { size_t keep = 0; for (size_t i = 0; i < n; ++i) if (stamps[i] + (unsigned long long)window_ms > now_ms) stamps[keep++] = stamps[i]; return keep; } static int push_stamp(unsigned long long **arr, size_t *n, size_t *cap, unsigned long long v) { if (*n >= *cap) { size_t ncap = *cap ? *cap * 2 : 8; unsigned long long *p = (unsigned long long *)realloc(*arr, ncap * sizeof(unsigned long long)); if (!p) return 0; *arr = p; *cap = ncap; } (*arr)[(*n)++] = v; return 1; } static slweb_peer_window *peer_of(slweb_rate *r, const char *peer) { for (size_t i = 0; i < r->n_peers; ++i) if (strcmp(r->peers[i].peer, peer) == 0) return &r->peers[i]; if (r->n_peers >= r->cap_peers) { size_t ncap = r->cap_peers ? r->cap_peers * 2 : 8; slweb_peer_window *p = (slweb_peer_window *)realloc(r->peers, ncap * sizeof *p); if (!p) return NULL; r->peers = p; r->cap_peers = ncap; } slweb_peer_window *w = &r->peers[r->n_peers++]; memset(w, 0, sizeof *w); copy_bounded(w->peer, sizeof w->peer, peer ? peer : ""); (void)w->head; return w; } int slweb_rate_allow(slweb_rate *r, const char *peer, unsigned long long now_ms) { if (!slweb_rate_enabled(r)) return 1; if (!peer) peer = ""; if (r->global_max != 0) { r->global_n = window_count(r->global_stamps, r->global_n, now_ms, r->window_ms); if (r->global_n >= r->global_max) return 0; } slweb_peer_window *w = peer_of(r, peer); if (!w) return 0; /* OOM: fail closed */ if (r->per_peer_max != 0) { w->n = window_count(w->stamps, w->n, now_ms, r->window_ms); if (w->n >= r->per_peer_max) return 0; } if (r->global_max != 0) if (!push_stamp(&r->global_stamps, &r->global_n, &r->global_cap, now_ms)) return 0; if (!push_stamp(&w->stamps, &w->n, &w->cap, now_ms)) return 0; return 1; } void slweb_rate_sweep(slweb_rate *r, unsigned long long now_ms) { if (!r) return; r->global_n = window_count(r->global_stamps, r->global_n, now_ms, r->window_ms); size_t keep = 0; for (size_t i = 0; i < r->n_peers; ++i) { r->peers[i].n = window_count(r->peers[i].stamps, r->peers[i].n, now_ms, r->window_ms); if (r->peers[i].n == 0) { free(r->peers[i].stamps); } else { r->peers[keep++] = r->peers[i]; } } r->n_peers = keep; } /* ================================================================== */ /* Write auth + client IP */ /* ================================================================== */ int slweb_constant_time_equals(const char *a, const char *b) { if (!a) a = ""; if (!b) b = ""; size_t la = strlen(a), lb = strlen(b); size_t n = la > lb ? la : lb; unsigned diff = (la == lb) ? 0u : 1u; for (size_t i = 0; i < n; ++i) { unsigned char ca = i < la ? (unsigned char)a[i] : 0; unsigned char cb = i < lb ? (unsigned char)b[i] : 0; diff |= (unsigned)(ca ^ cb); } return diff == 0 ? 1 : 0; } int slweb_write_authorize(const char *token, const char *authorization_header) { if (!token || !*token) return 1; /* no gate */ const char *h = authorization_header ? authorization_header : ""; size_t i = 0; while (h[i] && isspace((unsigned char)h[i])) ++i; size_t s = i; while (h[s] && !isspace((unsigned char)h[s])) ++s; /* scheme = h[i..s) */ char scheme[16]; size_t slen = s - i; if (slen >= sizeof scheme) return 0; for (size_t k = 0; k < slen; ++k) scheme[k] = (char)tolower((unsigned char)h[i + k]); scheme[slen] = 0; if (strcmp(scheme, "bearer") != 0) return 0; while (h[s] && isspace((unsigned char)h[s])) ++s; /* credential = h[s..end), trim trailing ws */ size_t e = strlen(h); while (e > s && isspace((unsigned char)h[e - 1])) --e; char cred[SLWEB_MAX_PATH]; size_t clen = e - s; if (clen >= sizeof cred) return 0; memcpy(cred, h + s, clen); cred[clen] = 0; return slweb_constant_time_equals(cred, token); } slweb_status slweb_client_ip(const char *peer_ip, const char *forwarded_for, const char *const *trusted_proxies, size_t n_proxies, char *out, size_t out_cap) { if (!out || out_cap == 0) return SLWEB_ERR_ARG; if (!peer_ip) peer_ip = ""; if (!forwarded_for || !*forwarded_for) { copy_bounded(out, out_cap, peer_ip); return SLWEB_OK; } int trusted = 0; for (size_t i = 0; i < n_proxies; ++i) if (trusted_proxies && trusted_proxies[i] && strcmp(trusted_proxies[i], peer_ip) == 0) { trusted = 1; break; } if (!trusted) { copy_bounded(out, out_cap, peer_ip); return SLWEB_OK; } /* left-most of a comma list is the origin client */ const char *comma = strchr(forwarded_for, ','); size_t len = comma ? (size_t)(comma - forwarded_for) : strlen(forwarded_for); /* trim */ size_t a = 0; while (a < len && isspace((unsigned char)forwarded_for[a])) ++a; while (len > a && isspace((unsigned char)forwarded_for[len - 1])) --len; if (len <= a) { copy_bounded(out, out_cap, peer_ip); return SLWEB_OK; } size_t cp = len - a; if (cp >= out_cap) cp = out_cap - 1; memcpy(out, forwarded_for + a, cp); out[cp] = 0; return SLWEB_OK; } /* ================================================================== */ /* Keep-warm band math */ /* ================================================================== */ slweb_warm slweb_warm_default(void) { slweb_warm w; w.enabled = 1; w.floor_pct = 11; w.ceiling_pct = 14; w.max_cores = 16; w.window_ms = 200; return w; } slweb_warm slweb_warm_sanitize(slweb_warm w) { if (w.floor_pct < 1) w.floor_pct = 1; if (w.floor_pct > 90) w.floor_pct = 90; if (w.ceiling_pct < w.floor_pct) w.ceiling_pct = w.floor_pct; if (w.ceiling_pct > 95) w.ceiling_pct = 95; if (w.max_cores < 1) w.max_cores = 1; if (w.max_cores > 16) w.max_cores = 16; if (w.window_ms < 50) w.window_ms = 50; if (w.window_ms > 2000) w.window_ms = 2000; return w; } double slweb_warm_target_pct(slweb_warm w) { w = slweb_warm_sanitize(w); return ((double)w.floor_pct + (double)w.ceiling_pct) / 2.0; } unsigned slweb_warm_core_count(unsigned max_cores) { long n = 1; #if defined(_WIN32) || defined(_WIN64) /* Windows (XP through 11+): GetSystemInfo is available on every version. */ SYSTEM_INFO si; GetSystemInfo(&si); if (si.dwNumberOfProcessors > 0) n = (long)si.dwNumberOfProcessors; #elif defined(_SC_NPROCESSORS_ONLN) /* POSIX / macOS. */ long got = sysconf(_SC_NPROCESSORS_ONLN); if (got > 0) n = got; #endif if (max_cores < 1) max_cores = 1; if (max_cores > 16) max_cores = 16; if (n < 1) n = 1; if ((unsigned)n > max_cores) n = (long)max_cores; return (unsigned)n; }