Home /Modules/web-server-technology/slweb.c

slweb.c

lib/web-server-technology/native/src/slweb.c · 438 line(s) · c

/*
 * 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 <ctype.h>
#include <stdlib.h>
#include <string.h>

#if defined(_WIN32) || defined(_WIN64)
#include <windows.h>   /* GetSystemInfo for the CPU count on Windows */
#else
#include <unistd.h>    /* 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;
}