Crate http_net 

http_net

An HTTP/1.1 engine that does no I/O itself. Feed it the bytes a socket delivered; it hands back requests (or responses) as borrowed views of those bytes, decodes their bodies, and serializes what you send back. The caller owns sockets, threads, and timers, so the same core runs under a blocking loop, an event loop, or a test that never opens a socket.

Parsing follows RFC 9112 strictly. Messages that recipients could disagree about are refused rather than repaired: conflicting Content-Length / Transfer-Encoding, duplicate Content-Length, obsolete line folding, bare CR or LF, whitespace before a colon, and control characters in field values each have their own HttpError. Every buffer is bounded by Limits, and each limit is checked before the bytes it governs are buffered.

Tier 1: serve and fetch (blocking, std)

use http_net::{blocking, Response};

let server = blocking::Server::bind("127.0.0.1:0")?;
let addr = server.local_addr();
let stop = server.shutdown_handle();
let t = std::thread::spawn(move || server.serve(|req, _body| Response::text(200, req.path())));

let resp = blocking::get(&format!("http://{addr}/hi"))?;
assert_eq!(resp.text(), Some("/hi"));

stop.shutdown();
t.join().unwrap()?;

Tier 2: the sans-IO connection

use http_net::{Response, ServerConn, ServerEvent};

let mut conn = ServerConn::new();
let mut out = Vec::new();
let _ = conn.feed(b"GET /status HTTP/1.1\r\nHost: localhost\r\n\r\n");
loop {
    match conn.poll()? {
        ServerEvent::Request(req) => assert_eq!(req.path(), "/status"),
        ServerEvent::Body(_) => {}
        ServerEvent::RequestEnd => conn.respond(&Response::text(200, "up"), &mut out)?,
        _ => break, // NeedInput: read more from the socket
    }
}
assert!(out.starts_with(b"HTTP/1.1 200 OK\r\n"));

ClientConn is the mirror image for the client side, and the blocking module shows how either is driven over std::net.

Protocol upgrades

A request with Connection: upgrade and an Upgrade field offering a protocol other than h2c reports RequestHead::is_upgrade. Answering it with Response::switching_protocols naming an offered protocol moves the connection to ServerEvent::Upgraded, after which ServerConn::remaining_input holds any bytes of the new protocol that arrived with the request. This is the hand-off point for a WebSocket engine such as ws-net.

Feature flags

Feature	Default	Description
std	yes	The blocking adapter over std::net. Without it the crate is no_std and needs only alloc (built in CI for thumbv7em-none-eabihf).

Credentials in Debug output

Every Debug implementation in the crate prints the values of authorization, proxy-authorization, cookie, and set-cookie as <redacted N bytes>, so logging a request with {:?} never leaks a session cookie or a bearer token. The accessors return the real values.

Re-exports

pub use status::StatusClass;

pub use status::reason_phrase;

pub use status::status_class;

Modules

blockingstd

A small blocking adapter over std::net: the Tier-1 path.

status

The HTTP status code registry: a named constant for every registered code, the canonical reason phrases, and status classes.

Structs

ClientConn

The client side of one HTTP/1.1 connection: a sans-IO state machine.

HeaderValues

Iterator over the values of every field with one name, in arrival order: what RequestHead::header_all and ResponseHead::header_all return. Each Set-Cookie, for example, is its own field and its own item; nothing is comma-joined.

Headers

Iterator over a head’s fields as (name, value) pairs, in arrival order.

Limits

The budgets a connection enforces on incoming messages.

MethodSet

A set of methods: one bit per Method, so a membership check is one AND. For routers and for the Allow field of a 405 response.

Request

A request for a ClientConn to send.

RequestHead

A parsed request head, borrowed from the connection’s buffer.

Response

A response for a ServerConn to send.

ResponseHead

A parsed response head, borrowed from the client connection’s buffer.

ServerConn

The server side of one HTTP/1.1 connection: a sans-IO state machine.

Enums

BodyFraming

How a message’s body is delimited.

ClientEvent

What a ClientConn has for the caller after poll.

HttpError

Why a message was refused, or why a call was out of order.

Method

The request method.

ServerEvent

What a ServerConn has for the caller after poll.

TargetForm

The form of a request target (RFC 9112 section 3.2).

Version

The HTTP version of a message.

Constants

VERSION

The crate version, as published (CARGO_PKG_VERSION).