logos.std.io.http

Turns a Request into a Response; implement to plug a handler into the conn loop.

Decodes a chunked-encoded Read source, exposing the body as a plain Read.

Frames each write call to the wrapped Write sink as one chunked-encoded record. Call finish to emit the terminator; dropping without it leaves the stream malformed. For chatty producers, wrap the sink in a BufWriter first to coalesce small chunks.

Packs a connection fd + type-erased service pointer for handoff to a worker. Heap-allocated by the acceptor, freed by the worker fiber after it is consumed.

Caps reads from a Read source at a fixed byte budget; frames a Content-Length: N body. Returns 0 (EOF) once the budget is exhausted; never reads past it on the underlying reader.

Service adapter wrapping a plain fn(&Request) -> Response handler.

Offset/length quad locating one header’s name and value inside Headers::buf.

Ordered list of HTTP header (name, value) pairs; duplicates allowed. Name lookup is ASCII case-insensitive (RFC 7230 §3.2).

Errors produced by HTTP client and server operations.

HTTP request method: a small integer code plus the literal token.

HTTP request: method, target URL, headers, and body.

HTTP response: status code, reason phrase, headers, and body.

Compares two byte ranges case-insensitively (ASCII only).

Returns the body-framing decision for headers h. >= 0: Content-Length bytes; -1: no framing (caller decides; response → read to EOF, request → empty); -2: chunked; -3: malformed (invalid or conflicting Content-Length, non-chunked Transfer-Encoding, or TE with CL).

Compares two byte ranges exactly (ASCII, case-sensitive).

Decodes chunked bytes [src, src+len), appending body data to out. Returns total input bytes consumed (through the final trailer CRLF), or -1 on malformed input. Trailer headers are parsed and skipped.

Encodes a whole body as one chunk plus the zero-length terminator, appended to out. For streaming, call chunked_write_chunk repeatedly, then chunked_finalize.

Appends the chunked-stream terminator (0\r\n\r\n) to out.

Wraps r in a ChunkedReader, taking ownership. To keep the underlying reader available afterwards, use read_chunked_body instead.

Appends one chunk (hex-length + CRLF + data + CRLF) to out. n == 0 emits bytes identical to the stream terminator; use chunked_finalize for that.

Wraps w in a ChunkedWriter, taking ownership of the sink.

Wraps r in a ContentLengthReader capped at n bytes; negative n is clamped to 0.

Returns the index of the first CRLF’s CR in [from, len), or -1 if absent.

Wraps f in a FnService so a fn-pointer handler can be used as a Service.

Parses url_str as an absolute HTTP URL (http://host[:port]/path[?query]) and issues a GET. Only numeric IPv4 hosts are supported; a hostname or a non-http scheme yields HttpError::BadUrl.

Issues a GET for path against host_ip:port, building a minimal Request with a Host header set to host_hdr.

Returns the standard reason phrase for status; unknown codes yield "".

Sends req to host_ip:port over a fresh TCP connection and reads the response. Reads until the peer closes or a complete message is buffered. host_ip must be numeric IPv4 — DNS resolution is not implemented.

Parses a method token (ASCII, case-sensitive per RFC 7230). Unknown tokens return code == 7 with the original name preserved.

Parses header lines from [pos, len) into h, appending each field. Returns the position just past the empty-CRLF terminator, or -1 on malformed input. Names must be RFC 7230 tokens; values are OWS-trimmed.

Parses a complete HTTP request (request-line, headers, body) from [src, src+len). Body framing follows body_length: Content-Length is copied, chunked is decoded, no framing yields an empty body. Partial input is HttpError::Parse — the buffer must hold the whole message.

Reads and parses a request head (request-line + headers) from br; no body is read. Leaves br at the first body byte; the returned Request.body is empty — frame it via body_length(&req.headers). Stricter than parse_request_buf: requires HTTP/1.0|1.1, origin-/asterisk-form target, Host on 1.1, and no Transfer-Encoding on 1.0.

Parses a complete HTTP response (status-line, headers, body) from [src, src+len). Body framing follows body_length: with no framing, the remainder of the buffer becomes the body (read-to-EOF semantics).

Reads and parses a response head (status-line + headers) from br; no body is read. Leaves br at the first body byte; the returned Response.body is empty — frame it via body_length(&resp.headers).

Reads a full chunked-encoded body from r, appending decoded bytes to out. Returns bytes appended on success, -1 on malformed input / I/O error. Borrows r (unlike ChunkedReader), so e.g. an HTTP server can read the next request from the same BufReader afterwards.

Drains a full HTTP/1.1 request message from s into buf. Reads until headers are complete AND the entire Content-Length body (or chunked terminator) has arrived, or the peer closes. Returns Ok(bytes_in_buf) or Err on IO / framing failure.

Borrows a String’s contents as a str (no copy).

Appends the full HTTP/1.1 request — request-line, headers, CRLF, body — to out. Wire form: METHOD /path?query HTTP/1.1\r\n<headers>\r\n<body>; empty path serializes as /, ?query only when non-empty. Headers are written as stored; no Content-Length is synthesized.

Writes only the request head — request-line, headers, terminator CRLF — to w. Request counterpart of serialize_response_head_stream; the caller writes the body afterwards. Returns 0 on success, negative errno on error.

Serializes the full request into one buffer and writes it to w via a single write_all. Returns 0 on success, negative errno on error.

Appends the full HTTP/1.1 response — status-line, headers, CRLF, body — to out. Wire form: HTTP/1.1 <status> <reason>\r\n<headers>\r\n<body>; headers are written as stored.

Writes only the response head — status-line, headers, terminator CRLF — to w. Use when the body is large or framed by a different encoder (ChunkedWriter, an open file, ...); the caller writes the body afterwards through the same writer. Returns 0 on success, negative errno on error.

Serializes the full response into one buffer and writes it to w via a single write_all. Returns 0 on success, negative errno on error.

Accepts up to count connections serially, running each through serve_connection (keep-alive works per connection). Returns Ok(()) after count connections have been served or accept fails; Err(Connect) if bind fails. For tests and “single request batch” scenarios.

Serves HTTP/1.1 requests from stream through svc in a keep-alive loop. Handles Expect: 100-continue; drains Content-Length bodies and decodes chunked bodies into req.body. Closes on Connection: close from either side or on a framing/IO error (malformed requests get a 400 reply first). Always returns 0.

Runs a multi-worker server: accepts on the calling thread’s reactor and hands each connection round-robin to one of n_workers worker threads via serve_connection. Stops when *stop_flag != 0 or accept fails; Err(Connect) if bind fails or n_workers < 1. Safety: svc is shared by raw pointer across workers — safe only for stateless services (e.g. FnService); stateful services need their own sync.

Accepts exactly count connections, handing each round-robin to n_workers workers, then signals shutdown and returns the pool without joining it. Caller must thread_pool_join + thread_pool_free only after its own reactor has drained — joining inside the fiber would block the OS thread and deadlock peers.

Binds port, accepts count connections serially, invokes handler for each, writes the serialized response back, and closes — one request per connection. Returns Ok(()) once count connections have been served, or Err(Connect) on fatal bind/accept failure.

Accepts connections until *stop_flag != 0, serving each through serve_connection. The stop flag must be an i64 cell the caller mutates from another fiber / signal handler — checked between accepts; accept failure also stops. Returns Ok(()) on clean stop or Err(Connect) if bind fails.

Returns a raw const pointer to the byte at index i of v.

Returns the byte at index i of v.

Returns the number of bytes in v.

Pushes byte b onto v.

Appends the decimal ASCII representation of v to out. Supports non-negative values only; v < 0 appends nothing.