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 reports RequestHead::is_upgrade. Answering it with Response::switching_protocols 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.

Modules

blockingstd

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

Structs

ClientConn

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

Headers

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

Limits

The budgets a connection enforces on incoming messages.

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.

Version

The HTTP version of a message.

Functions

reason_phrase

The canonical reason phrase for a status code (RFC 9110 section 15).