http5_server.c
http-5.0/http5_server.c · 516 line(s) · c
/* http5_server.c — SLeeLa HTTP 5.0 portable server implementation
*
* Platforms: Linux, macOS, Windows 10+
* Transport: HTTP/1.x over sleela_net.
* Application: HTTP 5.0 frames (13 types incl. Friends' Pack extensions)
* at /__sleela/h5 (POST).
*/
#if !defined(_WIN32) && !defined(_POSIX_C_SOURCE)
#define _POSIX_C_SOURCE 200809L
#endif
#include "http5_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 <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>
#endif
static volatile int g_stop = 0;
void h5s_server_stop(void) { g_stop = 1; }
#ifndef _WIN32
static void h5s_sig(int s) { (void)s; g_stop = 1; }
#endif
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 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 > H5S_MAX_HEADER ? H5S_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_hdr(const h5s_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, h5s_request *req,
const char **bs, size_t *hb) {
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 *c = memchr(p,':',(size_t)(le-p));
if(!c||c==p||req->header_count>=H5S_MAX_HEADERS)return -1;
h5s_header *h = &req->headers[req->header_count];
size_t nl=(size_t)(c-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(c+1); size_t vl=(size_t)(le-v);
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;
*hb=(size_t)(p-raw); *bs=p;
{ const char *v;
v=get_hdr(req,"x-sleela-version"); if(v) snprintf(req->sleela_version,sizeof(req->sleela_version),"%s",v);
v=get_hdr(req,"x-sleela-accept"); if(v) snprintf(req->sleela_accept,sizeof(req->sleela_accept),"%s",v);
v=get_hdr(req,"x-sleela-port"); if(v) snprintf(req->sleela_port,sizeof(req->sleela_port),"%s",v);
v=get_hdr(req,"x-sleela-service-id"); if(v) snprintf(req->service_id,sizeof(req->service_id),"%s",v);
v=get_hdr(req,"x-sleela-op-id"); if(v) snprintf(req->op_id,sizeof(req->op_id),"%s",v);
}
return 0;
}
/* ── response ───────────────────────────────────────────────────────── */
int h5s_response_add_header(h5s_response *r, const char *n, const char *v) {
if(!r||!n||!v||r->header_count>=H5S_MAX_HEADERS)return -1;
/* Reject header injection and values that would be silently truncated. */
if(strchr(n,'\r')||strchr(n,'\n')||strchr(v,'\r')||strchr(v,'\n'))return -1;
if(strlen(n)>=sizeof(r->headers[0].name)||strlen(v)>=sizeof(r->headers[0].value))return -1;
h5s_header *h=&r->headers[r->header_count];
snprintf(h->name,sizeof(h->name),"%s",n); snprintf(h->value,sizeof(h->value),"%s",v);
++r->header_count;
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 h5s_request *req,
const h5s_response *resp, const char *sn) {
char buf[H5S_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: 5.0\r\n"
"X-SLeeLa-Accept: 5.0, 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 h5s_download_should_resume(uint64_t cl){return cl>H5S_DOWNLOAD_THRESHOLD;}
int h5s_download_serialise(const h5s_download_state *st, char *buf, size_t cap) {
if(!st||!buf||cap<512)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;
}
static int h5s_parse_u64(const char *s, uint64_t *out) {
if (!s || !*s || !out) return -1;
uint64_t v = 0;
for (const unsigned char *p = (const unsigned char *)s; *p; ++p) {
if (*p < '0' || *p > '9') return -1;
unsigned digit = (unsigned)(*p - '0');
if (v > (UINT64_MAX - digit) / 10u) return -1;
v = v * 10u + digit;
}
*out = v;
return 0;
}
static int h5s_copy_field(char *dst, size_t cap, const char *src) {
if (!dst || cap == 0 || !src) return -1;
size_t n = strlen(src);
if (n == 0 || n >= cap) return -1;
memcpy(dst, src, n + 1);
return 0;
}
int h5s_download_parse(const char *line, h5s_download_state *out) {
if (!line || !out) return -1;
size_t line_len = strlen(line);
if (line_len == 0 || line_len >= 2048) return -1;
char copy[2048];
memcpy(copy, line, line_len + 1);
char *fields[7];
size_t count = 0;
char *field = copy;
for (char *p = copy;; ++p) {
if (*p == '|' || *p == '\0') {
char delimiter = *p;
*p = '\0';
while (*field == ' ' || *field == '\t') ++field;
size_t n = strlen(field);
while (n > 0 && (field[n - 1] == ' ' || field[n - 1] == '\t'))
field[--n] = '\0';
if (n == 0 || count >= 7) return -1;
fields[count++] = field;
if (delimiter == '\0') break;
field = p + 1;
}
}
if (count != 7) return -1;
h5s_download_state parsed;
memset(&parsed, 0, sizeof(parsed));
if (h5s_copy_field(parsed.session_id, sizeof(parsed.session_id), fields[0]) ||
h5s_copy_field(parsed.datetime, sizeof(parsed.datetime), fields[1]) ||
h5s_copy_field(parsed.file_id, sizeof(parsed.file_id), fields[2]) ||
h5s_copy_field(parsed.file_name, sizeof(parsed.file_name), fields[3]))
return -1;
/* File names are leaf names, never paths or traversal expressions. */
if (strcmp(parsed.file_name, ".") == 0 || strcmp(parsed.file_name, "..") == 0 ||
strchr(parsed.file_name, '/') || strchr(parsed.file_name, '\\'))
return -1;
for (const unsigned char *p = (const unsigned char *)parsed.file_name; *p; ++p)
if (*p < 0x20 || *p == 0x7f) return -1;
if (h5s_parse_u64(fields[4], &parsed.index) != 0 ||
h5s_parse_u64(fields[5], &parsed.offset) != 0 ||
h5s_parse_u64(fields[6], &parsed.total_size) != 0 ||
parsed.offset > parsed.total_size)
return -1;
*out = parsed;
return 0;
}
/* ── built-in routes ────────────────────────────────────────────────── */
static int builtin_health(h5s_response *r) {
static const char b[]="SLeeLa HTTP/5.0 OK\n";
r->status_code=200;r->content_type="text/plain; charset=utf-8";
r->body=b;r->body_length=sizeof(b)-1;return 0;
}
static int builtin_status(h5s_response *r) {
static char b[1024];
int n=snprintf(b,sizeof(b),
"{\"server\":\"SLeeLa\","
"\"http_generation\":\"5.0\","
"\"vm_generation\":5,"
"\"vm_name\":\"Manager\","
"\"vm_path\":\"/5\","
"\"platform\":\"%s\","
"\"frame_version\":%u,"
"\"frame_types\":[\"OPEN\",\"DATA\",\"END\",\"RESET\",\"WINDOW\","
"\"PING\",\"PONG\",\"RESUME\",\"CAPSULE\","
"\"FRIENDS_PACK\",\"BONUS_OFFER\",\"FP_UPDATE\",\"AUDIT\"],"
"\"friends_packs\":true,"
"\"lower_http_compatibility\":true}\n",
slnet_platform_name(), HTTP5_VERSION);
r->status_code=200;r->content_type="application/json";
r->body=b;r->body_length=(size_t)n;return 0;
}
static int builtin_negotiate(const h5s_request *req, h5s_response *r, int fb) {
const char *neg=sleela_http_negotiate(
req->sleela_version[0]?req->sleela_version:NULL,
req->sleela_accept[0]?req->sleela_accept:NULL, fb);
static char b[256]; int n;
if(neg){n=snprintf(b,sizeof(b),"{\"negotiated\":\"%s\",\"ok\":true}\n",neg);r->status_code=200;}
else{n=snprintf(b,sizeof(b),"{\"negotiated\":null,\"ok\":false}\n");r->status_code=400;}
r->content_type="application/json";r->body=b;r->body_length=(size_t)n;return 0;
}
static int builtin_h5_frame(const h5s_request *req, h5s_response *resp,
h5s_frame_handler fh, void *ud) {
if(!req->body||req->body_length<HTTP5_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;}
http5_frame_view_t frame; size_t consumed;
if(http5_frame_decode((const uint8_t*)req->body,req->body_length,&frame,&consumed)!=0){
resp->status_code=400;resp->content_type="text/plain";
resp->body="Invalid H5 frame\n";resp->body_length=17;return 0;}
/* This endpoint accepts exactly one frame; never silently ignore a suffix. */
if(consumed != req->body_length){
resp->status_code=400;resp->content_type="text/plain";
resp->body="Trailing bytes after H5 frame\n";resp->body_length=30;return 0;
}
if(fh){
static uint8_t rp[4096]; size_t rl=0;
if(fh(&frame,rp,sizeof(rp),&rl,ud)!=0){
resp->status_code=500;resp->content_type="text/plain";
resp->body="Frame handler error\n";resp->body_length=20;return 0;}
http5_frame_header_t rh={0};
rh.version=HTTP5_VERSION;
rh.type=(frame.header.type==HTTP5_FRAME_PING)?HTTP5_FRAME_PONG:HTTP5_FRAME_DATA;
rh.flags=HTTP5_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)rl;
static uint8_t wire[4096+HTTP5_FRAME_HEADER_SIZE]; size_t written;
if(http5_frame_encode(&rh,rp,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-h5";
resp->body=(const char*)wire;resp->body_length=written;return 0;
}
static char result[4096]; int n;
n=snprintf(result,sizeof(result),
"{\"frame_type\":\"%s\",\"stream_id\":%llu,\"request_id\":%llu,"
"\"sequence\":%llu,\"flags\":%u,\"payload_length\":%u}\n",
http5_frame_type_name((http5_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 h5s_server_config *cfg) {
size_t rc=H5S_MAX_HEADER+4096; char *raw=malloc(rc);
if(!raw){slnet_close(fd);return;}
int got=recv_headers(fd,raw,rc);
if(got<=0){free(raw);slnet_close(fd);return;}
if((size_t)got>=rc){free(raw);slnet_close(fd);return;}
raw[got]='\0';
h5s_request req; h5s_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;
h5s_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=NULL;
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=req.headers[i].value;++cl_count;}
if(strcmp(req.headers[i].name,"transfer-encoding")==0)++te_count;
}
if(cl_count>1||te_count>0){
resp.status_code=400;resp.content_type="text/plain";
resp.body="Ambiguous request framing\n";resp.body_length=26;
send_response(fd,&req,&resp,cfg->server_name);free(raw);slnet_close(fd);return;
}
if(cl){
uint64_t parsed_len=0;
if(h5s_parse_u64(cl,&parsed_len)!=0){
resp.status_code=400;resp.content_type="text/plain";
resp.body="Invalid Content-Length\n";resp.body_length=24;
send_response(fd,&req,&resp,cfg->server_name);free(raw);slnet_close(fd);return;
}
if(parsed_len>H5S_MAX_BODY||parsed_len>SIZE_MAX-1){
resp.status_code=413;resp.content_type="text/plain";
resp.body="Content Too Large\n";resp.body_length=18;
send_response(fd,&req,&resp,cfg->server_name);free(raw);slnet_close(fd);return;
}
size_t clen=(size_t)parsed_len;
size_t already=(size_t)got-hb;
if(already>clen){
resp.status_code=400;resp.content_type="text/plain";
resp.body="Bytes exceed Content-Length\n";resp.body_length=28;
send_response(fd,&req,&resp,cfg->server_name);free(raw);slnet_close(fd);return;
}
req.body=malloc(clen+1);
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>0)memcpy(req.body,bs,already);
size_t rem=clen-already,filled=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;}
if(rem>0){
free(req.body);req.body=NULL;
resp.status_code=400;resp.content_type="text/plain";
resp.body="Truncated request body\n";resp.body_length=22;
send_response(fd,&req,&resp,cfg->server_name);free(raw);slnet_close(fd);return;
}
req.body_length=filled;req.body[filled]='\0';
} else {
size_t already=(size_t)got-hb;
if(already!=0){
resp.status_code=400;resp.content_type="text/plain";
resp.body="Body without Content-Length\n";resp.body_length=28;
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(&resp);handled=1;}
else if(strcmp(req.uri,"/__sleela/status")==0){builtin_status(&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/h5")==0&&strcmp(req.method,"POST")==0){
builtin_h5_frame(&req,&resp,cfg->frame_handler,cfg->user_data);handled=1;}
if(!handled&&cfg->handler){
if(cfg->handler(&req,&resp,cfg->user_data)!=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);
}
static int portable_poll_readable(SLNetHandle fd, int ms) {
#ifdef _WIN32
WSAPOLLFD pfd;pfd.fd=(SOCKET)fd;pfd.events=POLLIN;pfd.revents=0;
return WSAPoll(&pfd,1,ms)>0&&(pfd.revents&POLLIN);
#else
struct pollfd pfd;pfd.fd=(int)fd;pfd.events=POLLIN;pfd.revents=0;
return poll(&pfd,1,ms)>0&&(pfd.revents&POLLIN);
#endif
}
void h5s_server_config_init(h5s_server_config *cfg) {
if(!cfg)return;memset(cfg,0,sizeof(*cfg));
cfg->port=8084;cfg->backlog=128;cfg->server_name="SLeeLa-HTTP/5.0";
cfg->allow_negotiation_fallback=1;
}
int h5s_server_run(const h5s_server_config *cfg) {
if(!cfg)return -1; g_stop=0;
if(slnet_startup()!=0){fprintf(stderr,"h5s: slnet_startup failed\n");return -1;}
sleela_preferred_router_startup(NULL,"HTTP/5.0");
SLNetHandle listener=slnet_listen(cfg->port,cfg->backlog);
if(!slnet_valid(listener)){fprintf(stderr,"h5s: listen failed on port %u\n",(unsigned)cfg->port);slnet_shutdown();return -1;}
fprintf(stderr,"SLeeLa HTTP/5.0 listening on port %u [%s]\n",(unsigned)cfg->port,slnet_platform_name());
#ifndef _WIN32
signal(SIGINT,h5s_sig);signal(SIGTERM,h5s_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/5.0 stopped.\n");return 0;
}
/* ── self-test ──────────────────────────────────────────────────────── */
int h5s_self_test(void) {
int f=0;
/* 1. HTTP parse */
{ const char raw[]="GET /__sleela/health HTTP/1.1\r\nHost: localhost\r\n"
"X-SLeeLa-Version: 5.0\r\n\r\n";
h5s_request req;const char *bs;size_t hb;
if(parse_request(raw,sizeof(raw)-1,&req,&bs,&hb)!=0||strcmp(req.sleela_version,"5.0")!=0){
fprintf(stderr,"FAIL: HTTP parse\n");++f;}}
/* 2. Frame encode/decode */
{ http5_frame_header_t h={0};h.version=HTTP5_VERSION;h.type=HTTP5_FRAME_FRIENDS_PACK;
h.flags=HTTP5_FLAG_OPTIONAL;h.stream_id=1;h.request_id=42;h.sequence=1;h.payload_length=5;
const uint8_t payload[]="alice";uint8_t wire[128];size_t written;
if(http5_frame_encode(&h,payload,wire,sizeof(wire),&written)!=0){fprintf(stderr,"FAIL: encode\n");++f;}
else{http5_frame_view_t v;size_t consumed;
if(http5_frame_decode(wire,written,&v,&consumed)!=0){fprintf(stderr,"FAIL: decode\n");++f;}
else if(v.header.type!=HTTP5_FRAME_FRIENDS_PACK||v.header.request_id!=42||
v.header.payload_length!=5||memcmp(v.payload,"alice",5)!=0){
fprintf(stderr,"FAIL: round-trip\n");++f;}}}
/* 3. Reject reserved flag bits and preserve output metadata on failure. */
{
http5_frame_header_t h={0};
uint8_t wire[64];
size_t written=777;
h.version=HTTP5_VERSION;h.type=HTTP5_FRAME_DATA;h.flags=0x8000;
if(http5_frame_encode(&h,NULL,wire,sizeof(wire),&written)==0||written!=777){
fprintf(stderr,"FAIL: reserved flag rejection\n");++f;
}
h.flags=0;h.type=255;
if(http5_frame_validate(&h,0)==0){
fprintf(stderr,"FAIL: unknown frame type rejection\n");++f;
}
}
/* 4. FP consume */
{ http5_friends_pack_t fp={100,10,2};
if(!http5_fp_can_offer(&fp)){fprintf(stderr,"FAIL: fp_can_offer\n");++f;}
http5_fp_consume(&fp);
if(fp.fp_remaining!=9){fprintf(stderr,"FAIL: fp_consume\n");++f;}
fp.fp_remaining=0;
if(http5_fp_can_offer(&fp)){fprintf(stderr,"FAIL: zero fp\n");++f;}
if(http5_fp_consume(&fp)!=-1){fprintf(stderr,"FAIL: consume at zero\n");++f;}}
/* 5. All 13 frame types */
{ for(int t=1;t<=13;++t){
const char *n=http5_frame_type_name((http5_frame_type_t)t);
if(!n||strcmp(n,"UNKNOWN")==0){fprintf(stderr,"FAIL: type %d\n",t);++f;}}}
/* 6. Download round-trip */
{ h5s_download_state st={0};
snprintf(st.session_id,sizeof(st.session_id),"h5-sess");
snprintf(st.datetime,sizeof(st.datetime),"2026-10-15");
snprintf(st.file_id,sizeof(st.file_id),"fid");
snprintf(st.file_name,sizeof(st.file_name),"big.dat");
st.index=2;st.offset=100000000ULL;st.total_size=500000000ULL;
char buf[512];
if(h5s_download_serialise(&st,buf,sizeof(buf))!=0){fprintf(stderr,"FAIL: dl ser\n");++f;}
else{h5s_download_state p;if(h5s_download_parse(buf,&p)!=0||p.index!=2){
fprintf(stderr,"FAIL: dl parse\n");++f;}}}
/* 6. Reject unsafe or malformed resume metadata. */
{
h5s_download_state bad;
if(h5s_download_parse("sess | date | id | ../secret | 0 | 0 | 10",&bad)==0){
fprintf(stderr,"FAIL: path traversal filename accepted\n");++f;
}
if(h5s_download_parse("sess | date | id | safe.dat | 0 | nope | 10",&bad)==0){
fprintf(stderr,"FAIL: invalid offset accepted\n");++f;
}
if(h5s_download_parse("sess | date | id | safe.dat | 0 | 11 | 10",&bad)==0){
fprintf(stderr,"FAIL: offset beyond total accepted\n");++f;
}
}
/* 7. Negotiation */
{ const char *r=sleela_http_negotiate("5.0","5.0, 4.0, 1.1",1);
if(!r||strcmp(r,"5.0")!=0){fprintf(stderr,"FAIL: negotiate\n");++f;}
r=sleela_http_negotiate("6.0","5.0, 1.1",1);
if(!r||strcmp(r,"1.1")!=0){fprintf(stderr,"FAIL: negotiate fallback\n");++f;}}
if(f==0) fprintf(stderr,"h5s_self_test: all tests passed\n");
else fprintf(stderr,"h5s_self_test: %d test(s) FAILED\n",f);
return f;
}