message head is too large

hyper = { version = "=1.12.0", features = ["server", "http1"] }
hyper-util = { version = "=0.1.21", features = ["tokio"] }
http-body-util = "=0.1.5"
bytes = "1"
tokio = { version = "=1.54.1", features = ["full"] }

use std::convert::Infallible;

use bytes::Bytes;
use http_body_util::Full;
use hyper::body::Incoming;
use hyper::server::conn::http1;
use hyper::service::service_fn;
use hyper::{Request, Response};
use hyper_util::rt::TokioIo;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::{TcpListener, TcpStream};

async fn handler(_: Request<Incoming>) -> Result<Response<Full<Bytes>>, Infallible> {
  Ok(Response::new(Full::new(Bytes::from("ok"))))
}

// A request whose head is about `head_kib` KiB: one big `x-big` header.
fn request(head_kib: usize) -> Vec<u8> {
  let filler = "a".repeat(head_kib * 1024 - 40);
  format!("GET / HTTP/1.1\r\nhost: x\r\nconnection: close\r\nx-big: {filler}\r\n\r\n").into_bytes()
}

async fn run(label: &str, head_kib: usize, cfg: impl Fn(&mut http1::Builder)) {
  let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
  let addr = listener.local_addr().unwrap();
  let mut builder = http1::Builder::new();
  cfg(&mut builder);
  let server = tokio::spawn(async move {
    let (stream, _) = listener.accept().await.unwrap();
    builder.serve_connection(TokioIo::new(stream), service_fn(handler)).await.map_err(|e| e.to_string())
  });

  let mut client = TcpStream::connect(addr).await.unwrap();
  let req = request(head_kib);
  let write = client.write_all(&req).await;
  // read until EOF or error, keeping what arrived before an error
  let mut resp = Vec::new();
  let mut buf = [0u8; 4096];
  let end = loop {
    match client.read(&mut buf).await {
      Ok(0) => break "EOF".to_string(),
      Ok(n) => resp.extend_from_slice(&buf[..n]),
      Err(e) => break format!("Err({:?})", e.kind()),
    }
  };
  let text = String::from_utf8_lossy(&resp);
  let first = text.lines().next().unwrap_or("");
  println!("== {label}: {} byte head", req.len());
  println!("client: write {:?}, read {} bytes, then {end}", write.map(|_| "ok"), resp.len());
  println!("client: first line {first:?}");
  println!("server: {:?}", server.await.unwrap());
}

#[tokio::main]
async fn main() {
  run("default", 12, |_| {}).await;
  run("default", 500, |_| {}).await;
  run("max_header_size(16 KiB)", 20, |b| {
    b.max_header_size(16 * 1024);
  })
  .await;
  run("max_header_size(1 MiB)", 500, |b| {
    b.max_header_size(1024 * 1024);
  })
  .await;
  run("max_header_size(1 MiB) + max_buf_size(1 MiB)", 500, |b| {
    b.max_header_size(1024 * 1024).max_buf_size(1024 * 1024);
  })
  .await;
}

== default: 12303 byte head
client: write Ok("ok"), read 96 bytes, then EOF
client: first line "HTTP/1.1 200 OK"
server: Ok(())
== default: 512015 byte head
client: write Ok("ok"), read 123 bytes, then Err(ConnectionReset)
client: first line "HTTP/1.1 431 Request Header Fields Too Large"
server: Err("message head is too large")
== max_header_size(16 KiB): 20495 byte head
client: write Ok("ok"), read 123 bytes, then EOF
client: first line "HTTP/1.1 431 Request Header Fields Too Large"
server: Err("message head is too large")
== max_header_size(1 MiB): 512015 byte head
client: write Ok("ok"), read 123 bytes, then Err(ConnectionReset)
client: first line "HTTP/1.1 431 Request Header Fields Too Large"
server: Err("message head is too large")
== max_header_size(1 MiB) + max_buf_size(1 MiB): 512015 byte head
client: write Ok("ok"), read 96 bytes, then EOF
client: first line "HTTP/1.1 200 OK"
server: Ok(())

                let curr_len = self.read_buf.len();
                if let Some(max_header_size) = parse_ctx.h1_max_header_size {
                    if curr_len >= max_header_size {
                        debug!("max_header_size ({}) reached, closing", max_header_size);
                        return Poll::Ready(Err(crate::Error::new_too_large()));
                    }
                }
                let max = self.read_buf_strategy.max();
                if curr_len >= max {
                    debug!("max_buf_size ({}) reached, closing", max);
                    return Poll::Ready(Err(crate::Error::new_too_large()));
                }

hyper = { version = "=1.12.0", features = ["client", "server", "http1"] }
hyper-util = { version = "=0.1.21", features = ["client-legacy", "http1", "tokio"] }
http-body-util = "=0.1.5"
bytes = "1"
tokio = { version = "=1.54.1", features = ["full"] }

use std::convert::Infallible;

use bytes::Bytes;
use http_body_util::{Empty, Full};
use hyper::body::Incoming;
use hyper::client::conn::http1 as client_h1;
use hyper::server::conn::http1;
use hyper::service::service_fn;
use hyper::{Request, Response};
use hyper_util::client::legacy::Client;
use hyper_util::rt::{TokioExecutor, TokioIo};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::{TcpListener, TcpStream};

// Raw server: reads one request head, answers with a `head_kib` KiB head.
async fn big_head_server(head_kib: usize) -> std::net::SocketAddr {
  let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
  let addr = listener.local_addr().unwrap();
  tokio::spawn(async move {
    loop {
      let (mut s, _) = listener.accept().await.unwrap();
      tokio::spawn(async move {
        let mut buf = vec![0u8; 4096];
        let _ = s.read(&mut buf).await;
        let filler = "a".repeat(head_kib * 1024 - 60);
        let head = format!("HTTP/1.1 200 OK\r\ncontent-length: 2\r\nx-big: {filler}\r\n\r\nok");
        let _ = s.write_all(head.as_bytes()).await;
        let _ = s.read(&mut buf).await; // keep the socket open until the client goes
      });
    }
  });
  addr
}

fn chain(e: &(dyn std::error::Error + 'static)) -> String {
  let mut out = format!("{e}");
  let mut cur = e.source();
  while let Some(s) = cur {
    out.push_str(&format!(" <- {s}"));
    cur = s.source();
  }
  out
}

async fn conn_client(label: &str, head_kib: usize, max_header_size: Option<usize>) {
  let addr = big_head_server(head_kib).await;
  let io = TokioIo::new(TcpStream::connect(addr).await.unwrap());
  let mut b = client_h1::Builder::new();
  if let Some(m) = max_header_size {
    b.max_header_size(m);
  }
  let (mut tx, conn) = b.handshake::<_, Empty<Bytes>>(io).await.unwrap();
  let conn = tokio::spawn(conn);
  let r = tx.send_request(Request::get("/").body(Empty::new()).unwrap()).await;
  match r {
    Ok(res) => println!("{label}, {head_kib} KiB response head: Ok({})", res.status()),
    Err(e) => println!(
      "{label}, {head_kib} KiB response head: Err({e}), is_parse_too_large={}",
      e.is_parse_too_large()
    ),
  }
  drop(tx);
  println!("  conn task: {:?}", conn.await.unwrap().map_err(|e| e.to_string()));
}

async fn legacy_client(head_kib: usize) {
  let addr = big_head_server(head_kib).await;
  let client: Client<_, Empty<Bytes>> = Client::builder(TokioExecutor::new()).build_http();
  match client.get(format!("http://{addr}/").parse().unwrap()).await {
    Ok(res) => println!("legacy Client, {head_kib} KiB response head: Ok({})", res.status()),
    Err(e) => println!("legacy Client, {head_kib} KiB response head: Err({})", chain(&e)),
  }
}

async fn handler(_: Request<Incoming>) -> Result<Response<Full<Bytes>>, Infallible> {
  Ok(Response::new(Full::new(Bytes::from("ok"))))
}

// A hyper client sends a `head_kib` KiB request head to a hyper server.
async fn send_big_request(label: &str, head_kib: usize, cfg: impl Fn(&mut http1::Builder)) {
  let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
  let addr = listener.local_addr().unwrap();
  let mut builder = http1::Builder::new();
  cfg(&mut builder);
  tokio::spawn(async move {
    let (stream, _) = listener.accept().await.unwrap();
    let _ = builder.serve_connection(TokioIo::new(stream), service_fn(handler)).await;
  });
  let io = TokioIo::new(TcpStream::connect(addr).await.unwrap());
  let (mut tx, conn) = client_h1::handshake::<_, Empty<Bytes>>(io).await.unwrap();
  tokio::spawn(conn);
  let big = "a".repeat(head_kib * 1024);
  let req = Request::get("/").header("host", "x").header("x-big", big).body(Empty::new()).unwrap();
  match tx.send_request(req).await {
    Ok(res) => println!("{label}: client sent {head_kib} KiB head, got Ok({})", res.status()),
    Err(e) => println!("{label}: client sent {head_kib} KiB head, got Err({})", chain(&e)),
  }
}

#[tokio::main]
async fn main() {
  println!("-- part 1: big response heads");
  conn_client("conn::http1 default", 12, None).await;
  conn_client("conn::http1 default", 500, None).await;
  conn_client("conn::http1 max_header_size(8 KiB)", 12, Some(8 * 1024)).await;
  legacy_client(500).await;
  println!("-- part 2: big request heads");
  send_big_request("server max_header_size(16 KiB)", 20, |b| {
    b.max_header_size(16 * 1024);
  })
  .await;
  send_big_request("server default", 500, |_| {}).await;
  send_big_request("server default", 2048, |_| {}).await;
}

-- part 1: big response heads
conn::http1 default, 12 KiB response head: Ok(200 OK)
  conn task: Ok(())
conn::http1 default, 500 KiB response head: Err(message head is too large), is_parse_too_large=true
  conn task: Ok(())
conn::http1 max_header_size(8 KiB), 12 KiB response head: Err(message head is too large), is_parse_too_large=true
  conn task: Ok(())
legacy Client, 500 KiB response head: Err(client error (SendRequest) <- message head is too large)
-- part 2: big request heads
server max_header_size(16 KiB): client sent 20 KiB head, got Ok(431 Request Header Fields Too Large)
server default: client sent 500 KiB head, got Ok(431 Request Header Fields Too Large)
server default: client sent 2048 KiB head, got Err(error writing a body to connection <- Connection reset by peer (os error 54))

            Some(Err(err)) => {
                debug!("read_head error: {}", err);
                self.dispatch.recv_msg(Err(err))?;
                // if here, the dispatcher gave the user the error
                // somewhere else. we still need to shutdown, but
                // not as a second error.
                self.close();
                Poll::Ready(Ok(()))
            }

use hyper_util::rt::TokioExecutor;
use hyper_util::server::conn::auto;

fn main() {
  let mut builder = auto::Builder::new(TokioExecutor::new());
  builder.http1().max_header_size(16 * 1024);
}

error[E0599]: no method named `max_header_size` found for struct `Http1Builder<'a, E>` in the current scope
 --> src/bin/auto_max_header.rs:6:19
  |
6 |   builder.http1().max_header_size(16 * 1024);
  |                   ^^^^^^^^^^^^^^^
  |
help: there is a method `max_headers` with a similar name
  |
6 -   builder.http1().max_header_size(16 * 1024);
6 +   builder.http1().max_headers(16 * 1024);
  |

  handler called, x-big is 12288 bytes
12 KiB header: Ok(200 OK)
20 KiB header: Ok(431 Request Header Fields Too Large)
  handler called, x-big is 1024 bytes
1 KiB header: Ok(200 OK)