Module http/index

Serialize to wire format, on the status line's own version (so a parsed response round-trips). A Content-Length header is added when none is present (the byte length of body), so the peer can delimit the message without waiting for close.

The error that caused this one, or .None at the root of the chain.

Rust's Error::source. Defaulted to .None, so an error with nothing underneath it implements the trait by saying only what it is; a wrapper overrides it to hand back what it wrapped. Walking the chain to the root cause works as of 2026-09-14 — the returned Dyn used to lose the Error trait on an erased receiver, so a caller could print one link but not follow it (#521, issues/fixed/self-trait-in-a-return-type-loses-the-trait-on-an-erased-receiver.md).

Serialize to wire format, on the status line's own version (so a parsed response round-trips). A Content-Length header is added when none is present (the byte length of body), so the peer can delimit the message without waiting for close.

Parse a request-line method token (case-sensitive, as RFC 9110 §9.1 requires). .None for anything not in the enum.

Create a new header with the given name and value.

An empty header section.

Number of field LINES, counting each repeat of a name separately.

True when there are no field lines.

The first value for name, or .None. Case-insensitive.

Every value for name, in the order the field lines appeared. Empty when the field is absent — which is what makes Set-Cookie usable.

True when name has at least one value. Case-insensitive.

Add a value for name, KEEPING any existing values. Rust's HeaderMap::append.

Remove every value for name, returning how many field lines went.

Set name to exactly value, dropping every value it had. Rust's HeaderMap::insert. Returns the first previous value, if any — a caller overwriting a header usually wants to know it was there.

The field lines in order — for serialization and iteration. The list is a snapshot: pushing to it does not change the map.

The header section in wire format — each line Name: value\r\n, WITHOUT the blank line that terminates the section (the message serializers add that, since they also append Content-Length).

Wrap a raw code, or .None when it is outside the 100-599 range RFC 9110 SS15 defines. An unrecognized code INSIDE the range is accepted — a client must treat an unknown 4xx as 400, so refusing it would break the very forward-compatibility the classes exist for.

The raw code.

1xx — the request was received and the process continues.

2xx — the request succeeded.

3xx — further action is needed to complete the request.

4xx — the request was malformed or cannot be fulfilled.

5xx — the server failed to fulfil an apparently valid request.

4xx or 5xx — either side's fault, but a failure either way.

The reason phrase RFC 9110 registers for this code, or Unknown.

The phrase is ADVISORY: a server may send any text and a client must not act on it — which is why this is a lookup here rather than a field, and why HttpResponse keeps whatever phrase the peer actually sent.

The digits alone — what goes in a status line.

Create a new request with the given method and path.

Add a header and return the request (builder pattern). APPENDS, so a repeatable field can be built up by chaining.

Set the request body and return the request (builder pattern).

Set the Host header, REPLACING any existing one — there is exactly one Host per request (RFC 9112 SS3.2), and appending a second used to put both on the wire.

Set a header, REPLACING every existing value for that name. Use self.headers.append(...) for a field that may legitimately repeat.

Set the request body.

Look up a header value by name (case-insensitive). The first value, when the field repeats — self.headers.get_all(name) for all of them.

Serialize the request to an HTTP/1.1 wire-format string.

Create a response with the given status and reason phrase.

Look up a header value by name (case-insensitive). The first value, when the field repeats — self.headers.get_all(name) for all of them, which is what Set-Cookie needs.

Set a header, REPLACING every existing value for that name.

True if the status is 2xx.

True if the status is 3xx.

True if the status is 4xx or 5xx.

A response with status and its registered reason phrase.

Add a header and return the response (builder pattern). APPENDS, so a repeatable field can be built up by chaining.

Set the body and return the response (builder pattern).

Serialize to wire format, on the status line's own version (so a parsed response round-trips). A Content-Length header is added when none is present (the byte length of body), so the peer can delimit the message without waiting for close.

Serialize to wire format, on the status line's own version (so a parsed response round-trips). A Content-Length header is added when none is present (the byte length of body), so the peer can delimit the message without waiting for close.

The error that caused this one, or .None at the root of the chain.

Rust's Error::source. Defaulted to .None, so an error with nothing underneath it implements the trait by saying only what it is; a wrapper overrides it to hand back what it wrapped. Walking the chain to the root cause works as of 2026-09-14 — the returned Dyn used to lose the Error trait on an erased receiver, so a caller could print one link but not follow it (#521, issues/fixed/self-trait-in-a-return-type-loses-the-trait-on-an-erased-receiver.md).

Create default options (GET, no headers, empty body, no timeout, 10 redirects, 64 MiB response ceiling).

Set the HTTP method.

Add a request header.

Set the request body.

Give the whole request (redirects included) a deadline.

Cap the number of redirect hops followed (0 = return 3xx verbatim).

Cap the raw response bytes buffered into memory (0 = unlimited).

A client with an empty pool, DEFAULT_MAX_IDLE_CONNECTIONS idle slots and a DEFAULT_IDLE_TIMEOUT_SECS age limit.

Cap the idle connections held at once (0 disables reuse).

Set the idle age limit (Duration.from_secs(0) lifts it).

How many connections are currently idle in the pool.

Close every idle connection — Go's Transport.CloseIdleConnections. Connections currently carrying a request are unaffected; they are owned by their exchange and are closed or pooled when it finishes.

Release the resources self owns — a file descriptor, a socket, a lock, a buffer the allocator handed out. Called automatically when the value's owner drops it (a value type) or the last reference to it goes away (a reference type), so an implementor never calls it directly and must tolerate being the only one who ever does.

It must be safe to run exactly once, and a type that also exposes an explicit close/release is responsible for making the second call a no-op.

GET url_str, reusing an idle connection to the same scheme/host/port when the pool has one and returning it to the pool afterwards.

fetch_with's options, over this client's connection pool.

Bind a listening socket on addr (port 0 picks a free port — read it back with local_addr()).

The address the server is listening on.

Set the request-size ceiling (builder pattern; 0 = unlimited).

Accept ONE connection, read one request, run handler, write the response and close. A request that does not parse gets a 400 Bad Request whose body names the defect, without calling handler; a framing defect (oversize, unreadable Content-Length, malformed chunking) is answered the same way (413 for oversize) instead of being thrown out of the server (issues/fixed/one-malformed-request-killed-http-server-serve.md).

Serve connections one after another until stop() has been called (checked after each connection completes).

Ask serve to return after the connection it is currently handling.

Close the listening socket.