http4_server.c
http-4.0/http4_server.c · 704 line(s) · c
/* http4_server.c — SLeeLa HTTP 4.0 portable server implementation
*
* Platforms: Linux, macOS, Windows 10+
*
* Transport: HTTP/1.x over sleela_net portable sockets.
* Application: SLeeLa HTTP 4.0 frame protocol — OPEN/DATA/END/RESET/WINDOW/
* PING/PONG/RESUME/CAPSULE — rides inside the HTTP request body at
* /__sleela/h4 (POST). Frames are binary (32-byte header + payload).
*/
#if !defined(_WIN32) && !defined(_POSIX_C_SOURCE)
#define _POSIX_C_SOURCE 200809L
#endif
#include "http4_server.h"
#include "http_negotiation.h"
#include "../impl/core/sleela_net.h"
#include "../preferred-routers/preferred_router.h"
#include "../resolver/resolver.h"
#include <ctype.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#ifdef _WIN32
#include <winsock2.h>
#include <ws2tcpip.h>
#else
#include <poll.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>
#endif
/* Bind explicitly. The safe default is loopback; public binding is opt-in. */
static SLNetHandle h4s_listen_on(const char *address, uint16_t port, int backlog)
{
if (!address || !*address) address = "127.0.0.1";
if (port == 0 || backlog < 1) return SL_NET_INVALID;
#ifdef _WIN32
SOCKET raw = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (raw == INVALID_SOCKET) return SL_NET_INVALID;
#else
int raw = socket(AF_INET, SOCK_STREAM, 0);
if (raw < 0) return SL_NET_INVALID;
#endif
int yes = 1;
#ifdef _WIN32
if (setsockopt(raw, SOL_SOCKET, SO_REUSEADDR, (const char *)&yes,
(int)sizeof(yes)) == SOCKET_ERROR) {
#else
if (setsockopt(raw, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)) < 0) {
#endif
slnet_close((SLNetHandle)raw);
return SL_NET_INVALID;
}
struct sockaddr_in addr;
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
#ifdef _WIN32
if (InetPtonA(AF_INET, address, &addr.sin_addr) != 1) {
#else
if (inet_pton(AF_INET, address, &addr.sin_addr) != 1) {
#endif
slnet_close((SLNetHandle)raw);
return SL_NET_INVALID;
}
#ifdef _WIN32
if (bind(raw, (struct sockaddr *)&addr, (int)sizeof(addr)) == SOCKET_ERROR ||
listen(raw, backlog) == SOCKET_ERROR) {
#else
if (bind(raw, (struct sockaddr *)&addr, sizeof(addr)) < 0 ||
listen(raw, backlog) < 0) {
#endif
slnet_close((SLNetHandle)raw);
return SL_NET_INVALID;
}
return (SLNetHandle)raw;
}
/* ── signal-safe stop ───────────────────────────────────────────────── */
static volatile int g_stop = 0;
void h4s_server_stop(void) { g_stop = 1; }
#ifndef _WIN32
static void h4s_sig(int s) { (void)s; g_stop = 1; }
#endif
/* ── helpers ────────────────────────────────────────────────────────── */
static void str_lower(char *s)
{ for (; *s; ++s) *s = (char)tolower((unsigned char)*s); }
static const char *str_ltrim(const char *s)
{ while (*s == ' ' || *s == '\t') ++s; return s; }
static const char *reason_phrase(int c)
{
switch (c) {
case 200: return "OK";
case 400: return "Bad Request";
case 404: return "Not Found";
case 413: return "Content Too Large";
case 500: return "Internal Server Error";
default: return "Error";
}
}
/* ── HTTP request parsing ───────────────────────────────────────────── */
static int recv_headers(SLNetHandle fd, char *buf, size_t cap)
{
size_t total = 0;
while (total < cap) {
SLNetCount n = slnet_read(fd, buf + total, cap - total);
if (n <= 0) return total > 0 ? (int)total : -1;
total += (size_t)n;
if (total >= 4) {
const char *lim = buf + (total > H4S_MAX_HEADER ? H4S_MAX_HEADER : total);
for (const char *p = buf + (total - n > 3 ? total - n - 3 : 0);
p + 3 < lim; ++p)
if (p[0]=='\r'&&p[1]=='\n'&&p[2]=='\r'&&p[3]=='\n') return (int)total;
}
}
return -1;
}
static const char *get_header(const h4s_request *r, const char *n)
{ for (int i = 0; i < r->header_count; ++i)
if (strcmp(r->headers[i].name, n) == 0) return r->headers[i].value;
return NULL; }
static int parse_request(const char *raw, size_t raw_len, h4s_request *req,
const char **body_start, size_t *header_bytes)
{
const char *p = raw, *end = raw + raw_len, *le;
memset(req, 0, sizeof(*req));
le = strstr(p, "\r\n"); if (!le) return -1;
{ const char *sp = memchr(p,' ',(size_t)(le-p));
if (!sp||(size_t)(sp-p)>=sizeof(req->method)) return -1;
memcpy(req->method,p,(size_t)(sp-p)); p=sp+1; }
{ const char *sp = memchr(p,' ',(size_t)(le-p));
if (!sp||(size_t)(sp-p)>=sizeof(req->uri)) return -1;
memcpy(req->uri,p,(size_t)(sp-p)); p=sp+1; }
{ size_t vl=(size_t)(le-p);
if (vl>=sizeof(req->version)) return -1;
memcpy(req->version,p,vl); }
p = le + 2;
while (p+1<end && !(p[0]=='\r'&&p[1]=='\n')) {
le = strstr(p,"\r\n"); if (!le) break;
const char *colon = memchr(p,':',(size_t)(le-p));
if (!colon||colon==p) return -1;
if (req->header_count>=H4S_MAX_HEADERS) return -1;
h4s_header *h = &req->headers[req->header_count];
size_t nl=(size_t)(colon-p);
if (nl>=sizeof(h->name)) return -1;
memcpy(h->name,p,nl); h->name[nl]='\0'; str_lower(h->name);
const char *v = str_ltrim(colon+1);
size_t vl=(size_t)(le-v);
while (vl > 0 && (v[vl-1] == ' ' || v[vl-1] == '\t')) --vl;
if (vl>=sizeof(h->value)) return -1;
memcpy(h->value,v,vl); h->value[vl]='\0';
++req->header_count; p=le+2;
}
if (p+1<end && p[0]=='\r' && p[1]=='\n') p+=2;
*header_bytes = (size_t)(p-raw); *body_start = p;
{ const char *v;
v=get_header(req,"x-sleela-version");
if(v) snprintf(req->sleela_version,sizeof(req->sleela_version),"%s",v);
v=get_header(req,"x-sleela-accept");
if(v) snprintf(req->sleela_accept,sizeof(req->sleela_accept),"%s",v);
v=get_header(req,"x-sleela-port");
if(v) snprintf(req->sleela_port,sizeof(req->sleela_port),"%s",v);
v=get_header(req,"x-sleela-service-id");
if(v) snprintf(req->service_id,sizeof(req->service_id),"%s",v);
v=get_header(req,"x-sleela-op-id");
if(v) snprintf(req->op_id,sizeof(req->op_id),"%s",v);
}
return 0;
}
/* ── response serialisation ─────────────────────────────────────────── */
int h4s_response_add_header(h4s_response *r, const char *n, const char *v)
{
if (!r||!n||!v||r->header_count>=H4S_MAX_HEADERS) return -1;
h4s_header *h = &r->headers[r->header_count++];
snprintf(h->name,sizeof(h->name),"%s",n);
snprintf(h->value,sizeof(h->value),"%s",v);
return 0;
}
static int send_all(SLNetHandle fd, const char *d, size_t l)
{ while(l>0){SLNetCount n=slnet_write(fd,d,l);if(n<=0)return -1;d+=n;l-=(size_t)n;}return 0; }
static int send_response(SLNetHandle fd, const h4s_request *req,
const h4s_response *resp, const char *sn)
{
char buf[H4S_MAX_HEADER]; int off=0;
const char *reason = resp->reason ? resp->reason : reason_phrase(resp->status_code);
off+=snprintf(buf+off,sizeof(buf)-(size_t)off,"%s %d %s\r\n",
req->version[0]?req->version:"HTTP/1.0",resp->status_code,reason);
off+=snprintf(buf+off,sizeof(buf)-(size_t)off,"Server: %s\r\n",sn);
if(resp->content_type)
off+=snprintf(buf+off,sizeof(buf)-(size_t)off,"Content-Type: %s\r\n",resp->content_type);
off+=snprintf(buf+off,sizeof(buf)-(size_t)off,"Content-Length: %zu\r\n",resp->body_length);
for(int i=0;i<resp->header_count;++i)
off+=snprintf(buf+off,sizeof(buf)-(size_t)off,"%s: %s\r\n",
resp->headers[i].name,resp->headers[i].value);
off+=snprintf(buf+off,sizeof(buf)-(size_t)off,
"X-SLeeLa-Version: 4.0\r\n"
"X-SLeeLa-Accept: 4.0, 3.0, 2.1, 1.1, 1.0\r\n"
"Connection: close\r\n\r\n");
if(off<=0||(size_t)off>=sizeof(buf)) return -1;
if(send_all(fd,buf,(size_t)off)!=0) return -1;
if(resp->body&&resp->body_length>0) return send_all(fd,resp->body,resp->body_length);
return 0;
}
/* ── download helpers ───────────────────────────────────────────────── */
int h4s_download_should_resume(uint64_t cl){return cl>H4S_DOWNLOAD_THRESHOLD;}
static int h4s_download_fields_valid(const h4s_download_state *st)
{
if (!st ||
!memchr(st->session_id, '\0', sizeof(st->session_id)) ||
!memchr(st->datetime, '\0', sizeof(st->datetime)) ||
!memchr(st->file_id, '\0', sizeof(st->file_id)) ||
!memchr(st->file_name, '\0', sizeof(st->file_name)) ||
!st->session_id[0] || !st->datetime[0] ||
!st->file_id[0] || !st->file_name[0] || st->offset > st->total_size)
return 0;
/* A filename is a leaf name, never a path supplied by the peer. */
if (strchr(st->file_name, '/') || strchr(st->file_name, '\\') ||
strstr(st->file_name, "..")) return 0;
return 1;
}
static int h4s_parse_u64(const char *s, uint64_t *out)
{
if (!s || !*s || !out) return -1;
for (const unsigned char *p = (const unsigned char *)s; *p; ++p)
if (*p < '0' || *p > '9') return -1;
errno = 0;
char *end = NULL;
unsigned long long v = strtoull(s, &end, 10);
if (errno == ERANGE || !end || *end != '\0') return -1;
*out = (uint64_t)v;
return 0;
}
int h4s_download_serialise(const h4s_download_state *st,char *buf,size_t cap)
{
if (!h4s_download_fields_valid(st) || !buf || cap == 0) return -1;
int n=snprintf(buf,cap,"%s | %s | %s | %s | %llu | %llu | %llu",
st->session_id,st->datetime,st->file_id,st->file_name,
(unsigned long long)st->index,(unsigned long long)st->offset,
(unsigned long long)st->total_size);
return(n>0&&(size_t)n<cap)?0:-1;
}
int h4s_download_parse(const char *line, h4s_download_state *out)
{
if (!line || !out) return -1;
size_t n = strlen(line);
if (n == 0 || n >= 2048) return -1;
char copy[2048];
memcpy(copy, line, n + 1);
char *fields[7];
char *p = copy;
for (int i = 0; i < 7; ++i) {
fields[i] = p;
char *sep = strchr(p, '|');
if (i < 6) {
if (!sep) return -1;
*sep = '\0';
p = sep + 1;
} else if (sep) {
return -1;
}
while (*fields[i] == ' ' || *fields[i] == '\t') ++fields[i];
size_t fl = strlen(fields[i]);
while (fl > 0 && (fields[i][fl-1] == ' ' || fields[i][fl-1] == '\t'))
fields[i][--fl] = '\0';
if (fl == 0) return -1;
}
h4s_download_state tmp;
memset(&tmp, 0, sizeof(tmp));
if (strlen(fields[0]) >= sizeof(tmp.session_id) ||
strlen(fields[1]) >= sizeof(tmp.datetime) ||
strlen(fields[2]) >= sizeof(tmp.file_id) ||
strlen(fields[3]) >= sizeof(tmp.file_name)) return -1;
memcpy(tmp.session_id, fields[0], strlen(fields[0]) + 1);
memcpy(tmp.datetime, fields[1], strlen(fields[1]) + 1);
memcpy(tmp.file_id, fields[2], strlen(fields[2]) + 1);
memcpy(tmp.file_name, fields[3], strlen(fields[3]) + 1);
if (h4s_parse_u64(fields[4], &tmp.index) != 0 ||
h4s_parse_u64(fields[5], &tmp.offset) != 0 ||
h4s_parse_u64(fields[6], &tmp.total_size) != 0 ||
!h4s_download_fields_valid(&tmp)) return -1;
*out = tmp;
return 0;
}
/* ── built-in routes ────────────────────────────────────────────────── */
static int builtin_health(const h4s_request *r, h4s_response *resp)
{
(void)r;
static const char b[]="SLeeLa HTTP/4.0 OK\n";
resp->status_code=200; resp->content_type="text/plain; charset=utf-8";
resp->body=b; resp->body_length=sizeof(b)-1; return 0;
}
static int builtin_status(const h4s_request *r, h4s_response *resp)
{
(void)r;
static char b[512];
int n=snprintf(b,sizeof(b),
"{\"server\":\"SLeeLa\","
"\"http_generation\":\"4.0\","
"\"vm_generation\":4,"
"\"vm_name\":\"Supervisor\","
"\"vm_path\":\"/4\","
"\"platform\":\"%s\","
"\"route_data_schema\":\"1.0\","
"\"frame_version\":%u,"
"\"frame_types\":[\"OPEN\",\"DATA\",\"END\",\"RESET\",\"WINDOW\","
"\"PING\",\"PONG\",\"RESUME\",\"CAPSULE\"],"
"\"segmentation\":true,"
"\"reassembly\":true,"
"\"packet_context\":true,"
"\"lower_http_compatibility\":true}\n",
slnet_platform_name(), HTTP4_VERSION);
resp->status_code=200; resp->content_type="application/json";
resp->body=b; resp->body_length=(size_t)n; return 0;
}
static int builtin_negotiate(const h4s_request *r, h4s_response *resp, int fb)
{
const char *neg=sleela_http_negotiate(
r->sleela_version[0]?r->sleela_version:NULL,
r->sleela_accept[0]?r->sleela_accept:NULL, fb);
static char b[256]; int n;
if(neg){n=snprintf(b,sizeof(b),"{\"negotiated\":\"%s\",\"ok\":true}\n",neg);resp->status_code=200;}
else{n=snprintf(b,sizeof(b),"{\"negotiated\":null,\"ok\":false}\n");resp->status_code=400;}
resp->content_type="application/json";resp->body=b;resp->body_length=(size_t)n;return 0;
}
/* ── H4 frame endpoint ──────────────────────────────────────────────── */
static int builtin_h4_frame(const h4s_request *req, h4s_response *resp,
h4s_frame_handler fh, void *ud)
{
if(!req->body||req->body_length<HTTP4_FRAME_HEADER_SIZE){
resp->status_code=400;resp->content_type="text/plain";
resp->body="Frame body required (min 32 bytes)\n";resp->body_length=35;return 0;
}
http4_frame_view_t frame; size_t consumed;
if(http4_frame_decode((const uint8_t*)req->body,req->body_length,
&frame,&consumed)!=0 || consumed != req->body_length){
resp->status_code=400;resp->content_type="text/plain";
resp->body="Invalid H4 frame or trailing bytes\n";
resp->body_length=strlen(resp->body);return 0;
}
if (frame.header.sequence == UINT64_MAX) {
resp->status_code=400;resp->content_type="text/plain";
resp->body="Frame sequence exhausted\n";
resp->body_length=strlen(resp->body);return 0;
}
/* If no frame handler, echo frame info as JSON. */
static char result[4096]; int n;
if(fh){
static uint8_t resp_payload[4096]; size_t resp_len=0;
int rc=fh(&frame,resp_payload,sizeof(resp_payload),&resp_len,ud);
if(rc!=0 || resp_len > sizeof(resp_payload) || resp_len > UINT32_MAX){
resp->status_code=500;resp->content_type="text/plain";
resp->body="Frame handler error or oversized response\n";
resp->body_length=strlen(resp->body);return 0;
}
/* Encode a response frame (PONG for PING, DATA for DATA/OPEN). */
http4_frame_header_t rh;
memset(&rh,0,sizeof(rh));
rh.version=HTTP4_VERSION;
rh.type=(frame.header.type==HTTP4_FRAME_PING)?HTTP4_FRAME_PONG:HTTP4_FRAME_DATA;
rh.flags=HTTP4_FLAG_FIN;
rh.stream_id=frame.header.stream_id;
rh.request_id=frame.header.request_id;
rh.sequence=frame.header.sequence+1;
rh.payload_length=(uint32_t)resp_len;
static uint8_t wire[4096+HTTP4_FRAME_HEADER_SIZE]; size_t written;
if(http4_frame_encode(&rh,resp_payload,wire,sizeof(wire),&written)!=0){
resp->status_code=500;resp->content_type="text/plain";
resp->body="Frame encode error\n";resp->body_length=19;return 0;
}
resp->status_code=200;resp->content_type="application/x-sleela-h4";
resp->body=(const char*)wire;resp->body_length=written;return 0;
}
/* Default: echo frame metadata as JSON. */
n=snprintf(result,sizeof(result),
"{\"frame_type\":\"%s\","
"\"stream_id\":%llu,"
"\"request_id\":%llu,"
"\"sequence\":%llu,"
"\"flags\":%u,"
"\"payload_length\":%u}\n",
http4_frame_type_name((http4_frame_type_t)frame.header.type),
(unsigned long long)frame.header.stream_id,
(unsigned long long)frame.header.request_id,
(unsigned long long)frame.header.sequence,
(unsigned)frame.header.flags,
(unsigned)frame.header.payload_length);
resp->status_code=200;resp->content_type="application/json";
resp->body=result;resp->body_length=(size_t)n;return 0;
}
/* ── connection handler ─────────────────────────────────────────────── */
static void handle_connection(SLNetHandle fd, const h4s_server_config *cfg)
{
size_t raw_cap=H4S_MAX_HEADER+4096;
char *raw=malloc(raw_cap + 1u);
if(!raw){slnet_close(fd);return;}
int got=recv_headers(fd,raw,raw_cap);
if(got<=0){free(raw);slnet_close(fd);return;}
raw[(size_t)got] = '\0';
h4s_request req; h4s_response resp;
const char *bs=NULL; size_t hb=0;
memset(&resp,0,sizeof(resp)); resp.status_code=200;
if(parse_request(raw,(size_t)got,&req,&bs,&hb)!=0){
resp.status_code=400;resp.content_type="text/plain";
resp.body="Bad Request\n";resp.body_length=12;
h4s_request bad;memset(&bad,0,sizeof(bad));memcpy(bad.version,"HTTP/1.0",9);
send_response(fd,&bad,&resp,cfg->server_name);free(raw);slnet_close(fd);return;
}
{
const char *cl = get_header(&req, "content-length");
int cl_count = 0, te_count = 0;
for (int i = 0; i < req.header_count; ++i) {
if (strcmp(req.headers[i].name, "content-length") == 0) ++cl_count;
if (strcmp(req.headers[i].name, "transfer-encoding") == 0) ++te_count;
}
/* This server implements Content-Length only, never ambiguous framing. */
if (cl_count > 1 || te_count > 0) {
resp.status_code=400; resp.content_type="text/plain";
resp.body="Invalid message framing\n"; resp.body_length=strlen(resp.body);
send_response(fd,&req,&resp,cfg->server_name);
free(raw); slnet_close(fd); return;
}
if (cl) {
uint64_t clen64 = 0;
if (h4s_parse_u64(cl, &clen64) != 0 || clen64 > H4S_MAX_BODY) {
resp.status_code = clen64 > H4S_MAX_BODY ? 413 : 400;
resp.content_type = "text/plain";
resp.body = resp.status_code == 413 ? "Content Too Large\n" : "Invalid Content-Length\n";
resp.body_length = strlen(resp.body);
send_response(fd,&req,&resp,cfg->server_name);
free(raw); slnet_close(fd); return;
}
size_t clen = (size_t)clen64;
size_t already = (size_t)got - hb;
if (already > clen) {
resp.status_code=400; resp.content_type="text/plain";
resp.body="Body exceeds Content-Length\n"; resp.body_length=strlen(resp.body);
send_response(fd,&req,&resp,cfg->server_name);
free(raw); slnet_close(fd); return;
}
req.body = malloc(clen + 1u);
if (!req.body) {
resp.status_code=500; resp.content_type="text/plain";
resp.body="Internal Server Error\n"; resp.body_length=22;
send_response(fd,&req,&resp,cfg->server_name);
free(raw); slnet_close(fd); return;
}
if (already) memcpy(req.body, bs, already);
size_t filled = already, rem = clen - already;
while (rem > 0) {
SLNetCount n = slnet_read(fd, req.body + filled, rem);
if (n <= 0) break;
filled += (size_t)n; rem -= (size_t)n;
}
req.body_length = filled;
req.body[filled] = '\0';
if (rem != 0) {
free(req.body);
resp.status_code=400; resp.content_type="text/plain";
resp.body="Truncated request body\n"; resp.body_length=23;
send_response(fd,&req,&resp,cfg->server_name);
free(raw); slnet_close(fd); return;
}
} else if ((size_t)got > hb) {
resp.status_code=400; resp.content_type="text/plain";
resp.body="Body requires Content-Length\n"; resp.body_length=strlen(resp.body);
send_response(fd,&req,&resp,cfg->server_name);
free(raw); slnet_close(fd); return;
}
}
free(raw);raw=NULL;
int handled=0;
if(strcmp(req.uri,"/__sleela/health")==0){builtin_health(&req,&resp);handled=1;}
else if(strcmp(req.uri,"/__sleela/status")==0){builtin_status(&req,&resp);handled=1;}
else if(strcmp(req.uri,"/__sleela/negotiate")==0){
builtin_negotiate(&req,&resp,cfg->allow_negotiation_fallback);handled=1;}
else if(strcmp(req.uri,"/__sleela/h4")==0&&strcmp(req.method,"POST")==0){
builtin_h4_frame(&req,&resp,cfg->frame_handler,cfg->user_data);handled=1;}
if(!handled&&cfg->handler){
int rc=cfg->handler(&req,&resp,cfg->user_data);
if(rc!=0){resp.status_code=500;resp.content_type="text/plain";
resp.body="Internal Server Error\n";resp.body_length=22;}
}else if(!handled){resp.status_code=404;resp.content_type="text/plain";
resp.body="Not Found\n";resp.body_length=10;}
send_response(fd,&req,&resp,cfg->server_name);
free(req.body);slnet_close(fd);
}
/* ── portable poll ──────────────────────────────────────────────────── */
static int portable_poll_readable(SLNetHandle fd, int timeout_ms)
{
#ifdef _WIN32
WSAPOLLFD pfd;pfd.fd=(SOCKET)fd;pfd.events=POLLIN;pfd.revents=0;
return WSAPoll(&pfd,1,timeout_ms)>0&&(pfd.revents&POLLIN);
#else
struct pollfd pfd;pfd.fd=(int)fd;pfd.events=POLLIN;pfd.revents=0;
return poll(&pfd,1,timeout_ms)>0&&(pfd.revents&POLLIN);
#endif
}
/* ── server entry point ─────────────────────────────────────────────── */
void h4s_server_config_init(h4s_server_config *cfg)
{
if(!cfg)return; memset(cfg,0,sizeof(*cfg));
cfg->port=8083; cfg->backlog=128;
cfg->bind_address="127.0.0.1";
cfg->server_name="SLeeLa-HTTP/4.0";
cfg->allow_negotiation_fallback=1;
}
int h4s_server_run(const h4s_server_config *cfg)
{
if(!cfg)return -1; g_stop=0;
if(slnet_startup()!=0){fprintf(stderr,"h4s: slnet_startup failed\n");return -1;}
if(!sleela_preferred_router_packet_policy("HTTP/4.0",1))
fprintf(stderr,"h4s: preferred-router policy unavailable, continuing\n");
sleela_preferred_router_startup(NULL,"HTTP/4.0");
SLNetHandle listener=h4s_listen_on(cfg->bind_address,cfg->port,cfg->backlog);
if(!slnet_valid(listener)){fprintf(stderr,"h4s: listen failed on %s:%u\n",cfg->bind_address?cfg->bind_address:"127.0.0.1",(unsigned)cfg->port);slnet_shutdown();return -1;}
fprintf(stderr,"SLeeLa HTTP/4.0 listening on %s:%u [%s]\n",cfg->bind_address?cfg->bind_address:"127.0.0.1",(unsigned)cfg->port,slnet_platform_name());
#ifndef _WIN32
signal(SIGINT,h4s_sig);signal(SIGTERM,h4s_sig);
#endif
while(!g_stop){if(!portable_poll_readable(listener,500))continue;
SLNetHandle c=slnet_accept(listener);if(!slnet_valid(c))continue;handle_connection(c,cfg);}
slnet_close(listener);slnet_shutdown();
fprintf(stderr,"SLeeLa HTTP/4.0 stopped.\n");return 0;
}
/* ── test echo frame handler ────────────────────────────────────────── */
static int test_echo_frame(const http4_frame_view_t *frame,
uint8_t *resp_payload, size_t resp_cap,
size_t *resp_len, void *ud)
{
(void)ud;
size_t n=frame->header.payload_length<resp_cap?frame->header.payload_length:resp_cap;
if(n>0) memcpy(resp_payload,frame->payload,n);
*resp_len=n; return 0;
}
/* ── self-test ──────────────────────────────────────────────────────── */
int h4s_self_test(void)
{
int failures=0;
/* 0. Safe default: do not listen on all interfaces implicitly. */
{ h4s_server_config cfg;
h4s_server_config_init(&cfg);
if (!cfg.bind_address || strcmp(cfg.bind_address,"127.0.0.1") != 0) {
fprintf(stderr,"FAIL: server bind default is not loopback\n"); ++failures;
}
}
/* 1. HTTP parse */
{ const char raw[]="POST /__sleela/h4 HTTP/1.1\r\nHost: localhost\r\n"
"Content-Length: 0\r\nX-SLeeLa-Version: 4.0\r\n\r\n";
h4s_request req;const char *bs;size_t hb;
if(parse_request(raw,sizeof(raw)-1,&req,&bs,&hb)!=0){
fprintf(stderr,"FAIL: HTTP parse\n");++failures;}
else if(strcmp(req.sleela_version,"4.0")!=0){
fprintf(stderr,"FAIL: version='%s'\n",req.sleela_version);++failures;}
}
/* 2. Frame encode/decode round-trip */
{ http4_frame_header_t h={0};
h.version=HTTP4_VERSION; h.type=HTTP4_FRAME_DATA;
h.flags=HTTP4_FLAG_INCREMENTAL; h.stream_id=1; h.request_id=42;
h.sequence=7; h.payload_length=4;
const uint8_t payload[]="ping";
uint8_t wire[128]; size_t written;
if(http4_frame_encode(&h,payload,wire,sizeof(wire),&written)!=0){
fprintf(stderr,"FAIL: frame encode\n");++failures;}
else{
http4_frame_view_t v; size_t consumed;
if(http4_frame_decode(wire,written,&v,&consumed)!=0){
fprintf(stderr,"FAIL: frame decode\n");++failures;}
else if(v.header.stream_id!=1||v.header.request_id!=42||
v.header.sequence!=7||v.header.payload_length!=4||
memcmp(v.payload,"ping",4)!=0){
fprintf(stderr,"FAIL: frame round-trip\n");++failures;}
}
}
/* 3. Frame handler round-trip */
{ http4_frame_header_t h={0};
h.version=HTTP4_VERSION;h.type=HTTP4_FRAME_PING;h.flags=0;
h.stream_id=5;h.request_id=99;h.sequence=1;h.payload_length=0;
uint8_t wire[128];size_t written;
http4_frame_encode(&h,NULL,wire,sizeof(wire),&written);
http4_frame_view_t fv;size_t consumed;
http4_frame_decode(wire,written,&fv,&consumed);
uint8_t resp_payload[64];size_t resp_len=0;
if(test_echo_frame(&fv,resp_payload,sizeof(resp_payload),&resp_len,NULL)!=0){
fprintf(stderr,"FAIL: echo frame handler\n");++failures;}
{
h4s_request rq; h4s_response rs;
memset(&rq,0,sizeof(rq)); memset(&rs,0,sizeof(rs));
rq.body=(char*)wire; rq.body_length=written+1;
if(builtin_h4_frame(&rq,&rs,NULL,NULL)!=0 || rs.status_code!=400){
fprintf(stderr,"FAIL: trailing frame bytes accepted\n");++failures;}
memset(&rs,0,sizeof(rs)); rq.body_length=written;
if(builtin_h4_frame(&rq,&rs,NULL,NULL)!=0 || rs.status_code!=200){
fprintf(stderr,"FAIL: exact single frame rejected\n");++failures;}
}
}
/* 4. Segmentation count */
{ /* MTU=1000, overhead=64 (frame hdr 32 + segment hdr 32), capacity=936
* ceil(10000/936) = 11 segments. */
size_t count=http4_segment_count(10000,1000);
if(count!=11){fprintf(stderr,"FAIL: segment_count=%zu\n",count);++failures;}
}
/* 5. Download state round-trip */
{ h4s_download_state st={0};
snprintf(st.session_id,sizeof(st.session_id),"h4-sess");
snprintf(st.datetime,sizeof(st.datetime),"2026-10-15T00:00:00Z");
snprintf(st.file_id,sizeof(st.file_id),"file-h4");
snprintf(st.file_name,sizeof(st.file_name),"big.dat");
st.index=3;st.offset=150000000ULL;st.total_size=500000000ULL;
char buf[512];
if(h4s_download_serialise(&st,buf,sizeof(buf))!=0){
fprintf(stderr,"FAIL: download serialise\n");++failures;}
else{h4s_download_state p2;
if(h4s_download_parse(buf,&p2)!=0||p2.index!=3||p2.offset!=150000000ULL){
fprintf(stderr,"FAIL: download round-trip\n");++failures;}
if(h4s_download_parse("s | t | id | ../secret | 1 | 0 | 2",&p2)==0){
fprintf(stderr,"FAIL: traversal filename accepted\n");++failures;}
if(h4s_download_parse("s | t | id | f | -1 | 0 | 2",&p2)==0){
fprintf(stderr,"FAIL: negative index accepted\n");++failures;}
if(h4s_download_parse("s | t | id | f | 1x | 0 | 2",&p2)==0){
fprintf(stderr,"FAIL: malformed integer accepted\n");++failures;}
if(h4s_download_parse("s | t | id | f | 1 | 3 | 2",&p2)==0){
fprintf(stderr,"FAIL: offset beyond total accepted\n");++failures;}
if(h4s_download_parse("s | t | id | f | 1 | 0 | 2 | extra",&p2)==0){
fprintf(stderr,"FAIL: extra DOWNLOAD field accepted\n");++failures;}}
}
/* 6. Negotiation */
{ const char *r=sleela_http_negotiate("4.0","4.0, 3.0, 1.1",1);
if(!r||strcmp(r,"4.0")!=0){fprintf(stderr,"FAIL: negotiate 4.0\n");++failures;}
r=sleela_http_negotiate("5.0","4.0, 1.1",1);
if(!r||strcmp(r,"1.1")!=0){fprintf(stderr,"FAIL: negotiate fallback\n");++failures;}
}
/* 7. Frame type names */
{ if(strcmp(http4_frame_type_name(HTTP4_FRAME_OPEN),"OPEN")!=0){
fprintf(stderr,"FAIL: frame type name\n");++failures;}
if(strcmp(http4_frame_type_name(HTTP4_FRAME_RESUME),"RESUME")!=0){
fprintf(stderr,"FAIL: RESUME name\n");++failures;}
}
if(failures==0) fprintf(stderr,"h4s_self_test: all tests passed\n");
else fprintf(stderr,"h4s_self_test: %d test(s) FAILED\n",failures);
return failures;
}