Failed to buffer the request body: length limit exceeded

axum = "=0.8.9"
tokio = { version = "=1.54.1", features = ["macros", "rt-multi-thread", "net", "io-util", "process"] }

use std::net::SocketAddr;

use axum::{Router, body::Bytes, routing::post};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::{TcpListener, TcpStream};

const MIB: usize = 1024 * 1024;

async fn len(body: Bytes) -> String {
  format!("got {} bytes", body.len())
}

// write the whole request first, then read whatever comes back
async fn raw_post(addr: SocketAddr, path: &str, size: usize) {
  let mut s = TcpStream::connect(addr).await.unwrap();
  let head = format!("POST {path} HTTP/1.1\r\nhost: x\r\nconnection: close\r\ncontent-length: {size}\r\n\r\n");
  let mut req = head.into_bytes();
  req.extend(std::iter::repeat_n(b'a', size));
  let write = s.write_all(&req).await.map_err(|e| e.kind());
  let mut resp = Vec::new();
  let mut buf = [0u8; 4096];
  let end = loop {
    match s.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 status = text.lines().next().unwrap_or("-");
  let body = text.split("\r\n\r\n").nth(1).unwrap_or("-");
  println!("{path:<8} {:>2} MiB: write {write:?}; read {status:?} {body:?}, then {end}", size / MIB);
}

#[tokio::main]
async fn main() {
  let app = Router::new().route("/upload", post(len));
  let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
  let addr = listener.local_addr().unwrap();
  tokio::spawn(async move { axum::serve(listener, app).await.unwrap() });

  for size in [1 * MIB, 3 * MIB, 20 * MIB] {
    raw_post(addr, "/upload", size).await;
  }

  // the same two uploads with curl; the file paths come from the command line
  let url = format!("http://{addr}/upload");
  for file in std::env::args().skip(1) {
    let out = tokio::process::Command::new("curl")
      .args(["-sS", "--noproxy", "*", "-w", " -> %{http_code}", "--data-binary"])
      .arg(format!("@{file}"))
      .arg(&url)
      .output()
      .await
      .unwrap();
    let name = file.rsplit('/').next().unwrap();
    println!(
      "curl {name:<10} exit {:?}: {} {}",
      out.status.code(),
      String::from_utf8_lossy(&out.stdout),
      String::from_utf8_lossy(&out.stderr).trim_end()
    );
  }
}

/upload   1 MiB: write Ok(()); read "HTTP/1.1 200 OK" "got 1048576 bytes", then EOF
/upload   3 MiB: write Ok(()); read "HTTP/1.1 413 Payload Too Large" "Failed to buffer the request body: length limit exceeded", then EOF
/upload  20 MiB: write Err(ConnectionReset); read "HTTP/1.1 413 Payload Too Large" "Failed to buffer the request body: length limit exceeded", then Err(ConnectionReset)
curl 3mib.bin   exit Some(0): Failed to buffer the request body: length limit exceeded -> 413 
curl 20mib.bin  exit Some(0): Failed to buffer the request body: length limit exceeded -> 413 

    pub(crate) fn from_err<E>(err: E) -> Self
    where
        E: Into<BoxError>,
    {
        // two layers of boxes here because `with_limited_body`
        // wraps the `http_body_util::Limited` in a `axum_core::Body`
        // which also wraps the error type
        let box_error = match err.into().downcast::<Error>() {
            Ok(err) => err.into_inner(),
            Err(err) => err,
        };
        let box_error = match box_error.downcast::<Error>() {
            Ok(err) => err.into_inner(),
            Err(err) => err,
        };
        match box_error.downcast::<http_body_util::LengthLimitError>() {
            Ok(err) => Self::LengthLimitError(LengthLimitError::from_err(err)),
            Err(err) => Self::UnknownBodyError(UnknownBodyError::from_err(err)),
        }
    }

let app = Router::new()
  .route("/upload", post(upload).layer(DefaultBodyLimit::max(50 * 1024 * 1024)))
  .route("/users", post(create_user));

/a: 200 OK
/b: 200 OK
/c: 413 Payload Too Large