SLeeLa SLeeLa # SLeeLa HTTP 1.0 **Status:** Internet-capable SLeeLa application-protocol server. **Platforms:** Linux · macOS · Windows 10+ SLeeLa HTTP 1.0 establishes the baseline application model used by the later HTTP generations in this repository. It keeps transport addressing separate from SLeeLa's logical service-routing identifiers and provides a portable, real-wire HTTP/1.0 server built on the `sleela_net` socket abstraction. ## Build and test ```sh make # build the http1_server binary + negotiation objects make test # run the built-in self-test (parse, negotiation, download state) make syntax # syntax-only check of all sources make clean # remove build artefacts ``` ### Platform notes | Platform | Socket layer | Compiler | Link flags | |----------------|-----------------------------|--------------------|-------------------| | Linux | POSIX sockets via sleela_net| `cc` / `gcc` | (none) | | macOS | POSIX sockets via sleela_net| `cc` / `clang` | (none) | | Windows 10+ | Winsock2 via sleela_net | MSVC / MinGW | `-lws2_32` | The Makefile detects Windows via `$(OS)` and adds `-lws2_32` automatically. ## Running the server ```sh ./http1_server --port 8080 ``` Options: - `--port N` — TCP listen port (default 8080) - `--self-test` — run the built-in test suite and exit - `--help` — show usage The server logs to stderr and runs until interrupted (SIGINT / SIGTERM on POSIX; Ctrl-C on Windows). ## Architecture ```text Native transport endpoint (TCP, any platform) | HTTP/1.0 request / connection ← sleela_net portable sockets | SLeeLa envelope / route ← X-SLeeLa-* application headers | Logical PORT (X-SLeeLa-Port) | SERVICE-ID (X-SLeeLa-Service-ID) | OP-ID (X-SLeeLa-Op-ID) | Application handler | HTTP/1.0 response ``` A SLeeLa **logical port** is an application-level identifier. It is not a replacement for, or necessarily a one-to-one mapping with, a native TCP or UDP port. ## SLeeLa application headers Every response includes the version advertisement headers described in HTTP.NEGOTIATION.md: ``` X-SLeeLa-Version: 1.0 X-SLeeLa-Accept: 1.0, 1.1 ``` Clients may set the following request headers for SLeeLa logical routing: | Header | Purpose | |--------------------------|----------------------------------------| | `X-SLeeLa-Version` | Requested SLeeLa protocol generation | | `X-SLeeLa-Accept` | Comma-separated acceptable generations | | `X-SLeeLa-Port` | Logical port (application route) | | `X-SLeeLa-Service-ID` | Service identifier | | `X-SLeeLa-Op-ID` | Operation identifier | A normal HTTP/1.x peer may ignore these headers and continue ordinary request/response processing (HTTP.NEGOTIATION.md §Wire fallback). ## Built-in endpoints | Path | Method | Description | |---------------------------|--------|---------------------------------------| | `/__sleela/health` | GET | Returns `SLeeLa HTTP/1.0 OK` | | `/__sleela/status` | GET | JSON: server, generation, VM, platform| | `/__sleela/negotiate` | GET | Version negotiation result (JSON) | ## Multiplexing HTTP/1.0 does not provide HTTP/2-style stream multiplexing. SLeeLa therefore treats concurrent application exchanges as logical operations above the HTTP/1.0 request and connection boundary, using one-request-per-connection. ## Large-file download mode SLeeLa HTTP 1.0 and later generations define a common **DOWNLOAD** mode for files larger than 50 MB. The server provides resume metadata: ``` SESSION-ID | DATETIME | FILE-ID | FILE-NAME | INDEX | OFFSET | TOTAL-SIZE ``` - **FILE-ID** identifies the transfer. - **INDEX** identifies a segment or chunk. - **OFFSET** identifies the byte position. - **TOTAL-SIZE** records the complete transfer size. The 50 MB threshold selects the resume-oriented mode; it is not a maximum file size. ## Compatibility The HTTP 1.0 layer is designed to coexist with conventional HTTP infrastructure. TCP sockets, TLS termination, proxies, routers, and native port bindings remain transport concerns; SLeeLa logical ports remain application-routing concerns. ## Policy hooks The server checks two policy gates on startup and per-negotiation: 1. **Preferred router** (`preferred_router`) — verifies routing-tier policy. 2. **Resolver** (`resolver`) — verifies event/packet policy. Both are opt-in; the server continues with built-in defaults when the external configuration is unavailable. ## File inventory | File | Description | |--------------------------|--------------------------------------------------| | `http1_server.h` | Server API, request/response types, download state| | `http1_server.c` | Full server: parse, route, respond, self-test | | `http1_main.c` | CLI entry point (demo handler) | | `http_negotiation.h` | C negotiation API | | `http_negotiation.c` | Version negotiation with policy checks | | `http_negotiation.hpp` | C++ negotiation wrapper | | `http_negotiation.cpp` | C++ wrapper implementation | | `Makefile` | Build: `all`, `server`, `syntax`, `test`, `clean` | | `FLOW.md` | Request-path diagram and multiplexing design | | `HTTP.NEGOTIATION.md` | Negotiation protocol for SLeeLa HTTP 1–9 | | `STATUS.md` | Port multiplexing and download-mode status | ## Dependencies | Module | Path | Role | |-----------------------------|-------------------------------|------------------------------| | `sleela_net` | `impl/core/sleela_net.{c,h}` | Portable TCP sockets | | `preferred_router` | `preferred-routers/` | Routing-tier policy | | `resolver` | `resolver/` | DNS / path / event policy | ## Scope HTTP 1.0 provides the foundational routing and transfer model. Later SLeeLa generations add additional framing, multiplexing, integrity, capability, and application features without changing the distinction between transport and application addressing. ## Unified route data This server consumes the SLeeLa unified route-data contract in `route/ROUTE.DATA.json` and `route/ROUTE.DATA.md`. Route records carry protocol, server surface, HTTP generation, VM generation/formal VM name, canonical configuration root, route identifier, target/resolution mode, capability, transport, port, and status. VM names are architectural metadata only and do not grant capabilities. Dynamic targets must use the shared resolver before acceptance. ## Security and validation The native parser applies bounded header/body sizes, validates request-line and header token syntax, rejects control characters, duplicate header fields, duplicate or malformed Content-Length, and unsupported Transfer-Encoding. It requires complete request bodies and applies a 10-second total deadline to header and body reads. Response headers are validated and bounded before serialization. Resumable-download metadata rejects malformed decimal fields, offsets beyond the file size, delimiters/control characters, and path-like file names. Run the expanded checks with: - `make syntax` - `make test` - `make sanitize` (GCC/Clang with AddressSanitizer and UBSan) - `make fuzz-download` (Clang/libFuzzer) The current portable listener binds all interfaces; the `bind_address` config field is reserved and is not yet enforced by `sleela_net`. Use host firewall rules and a trusted TLS-terminating proxy until address-specific binding is implemented. The server remains serial (one connection at a time), and this code does not implement TLS or identity verification. Applications can configure the optional native `authorize` callback: return 0 to allow a request and non-zero to deny it. When configured, it protects all routes except GET/HEAD `/__sleela/health`. Do not expose plaintext HTTP to untrusted networks without a trusted TLS-terminating proxy. Protect non-health routes at the application layer, never treat X-SLeeLa routing IDs or download session IDs as credentials, and bind resume state to an authenticated principal and stable file identity. The declarative classes under `lib/http-1.0` document these contracts; they do not replace native enforcement. --- # SLeeLa

SLeeLa — The Now. The Ingredient.

SLeeLa Marketing Logo