remaining() 是 25，chunk() 只有 8 个字节

bytes = "=1.12.1"
http-body = "1"
http-body-util = "=0.1.5"
futures-util = "0.3"
tokio = { version = "=1.54.1", features = ["rt"] }

use std::convert::Infallible;
use std::panic;

use bytes::{Buf, Bytes};
use futures_util::stream;
use http_body::Frame;
use http_body_util::{BodyExt, StreamBody};

// 错误写法：以为 chunk() 就是全部数据
fn find_crlf_buggy(buf: &impl Buf) -> Option<usize> {
  buf.chunk().windows(2).position(|w| w == b"\r\n")
}

// 错误写法：直接从 chunk() 里切 4 个字节当长度前缀
fn frame_len_buggy(buf: &impl Buf) -> u32 {
  u32::from_be_bytes(buf.chunk()[..4].try_into().unwrap())
}

// 改法：找分隔符之前先变成一个连续的 Bytes，再按行切
fn lines(buf: &mut impl Buf) -> (Vec<Bytes>, bool) {
  let first = buf.chunk().as_ptr();
  let mut all = buf.copy_to_bytes(buf.remaining());
  let copied = all.as_ptr() != first;
  let mut out = Vec::new();
  while let Some(pos) = all.windows(2).position(|w| w == b"\r\n") {
    out.push(all.split_to(pos)); // Bytes::split_to 不拷贝
    all.advance(2);
  }
  (out, copied)
}

// 一个分几帧到达的 body，经 BodyExt::collect 收集，再 aggregate
fn aggregated(parts: &[&'static [u8]]) -> impl Buf + use<> {
  let frames: Vec<_> = parts.iter().map(|p| Ok::<_, Infallible>(Frame::data(Bytes::from_static(p)))).collect();
  let body = StreamBody::new(stream::iter(frames));
  let rt = tokio::runtime::Builder::new_current_thread().build().unwrap();
  rt.block_on(body.collect()).unwrap().aggregate()
}

fn main() {
  panic::set_hook(Box::new(|info| println!("panicked: {}", info.payload_as_str().unwrap_or("?"))));
  let (a, b): (&'static [u8], &'static [u8]) = (b"GET / HT", b"TP/1.1\r\nHost: a\r\n");

  // 1. Chain：一行请求在两次 read 之间被切开
  let mut buf = Bytes::from_static(a).chain(Bytes::from_static(b));
  println!("chain:     remaining={} chunk={:?}", buf.remaining(), Bytes::copy_from_slice(buf.chunk()));
  println!("chain:     find_crlf_buggy={:?}", find_crlf_buggy(&buf));
  println!("chain:     lines={:?}", lines(&mut buf));

  // 2. http-body-util 的 Collected::aggregate()：两帧原样排队
  let mut agg = aggregated(&[a, b]);
  println!("aggregate: remaining={} chunk={:?}", agg.remaining(), Bytes::copy_from_slice(agg.chunk()));
  println!("aggregate: find_crlf_buggy={:?}", find_crlf_buggy(&agg));
  println!("aggregate: lines={:?}", lines(&mut agg));

  // 3. 只有一帧时：copy_to_bytes 不拷贝
  let mut one = aggregated(&[b"GET / HTTP/1.1\r\nHost: a\r\n"]);
  println!("one frame: lines={:?}", lines(&mut one));

  // 4. 长度前缀被切在 2 + 2
  let mut frame = aggregated(&[&[0, 0], &[0, 5, b'h', b'e', b'l', b'l', b'o']]);
  let r = panic::catch_unwind(|| frame_len_buggy(&frame));
  println!("prefix:    frame_len_buggy ok={}", r.is_ok());
  println!("prefix:    try_get_u32={:?}", frame.try_get_u32());
  let mut body = [0u8; 5];
  frame.copy_to_slice(&mut body);
  println!("prefix:    copy_to_slice={:?}", std::str::from_utf8(&body).unwrap());
}

chain:     remaining=25 chunk=b"GET / HT"
chain:     find_crlf_buggy=None
chain:     lines=([b"GET / HTTP/1.1", b"Host: a"], true)
aggregate: remaining=25 chunk=b"GET / HT"
aggregate: find_crlf_buggy=None
aggregate: lines=([b"GET / HTTP/1.1", b"Host: a"], true)
one frame: lines=([b"GET / HTTP/1.1", b"Host: a"], false)
panicked: range end index 4 out of range for slice of length 2
prefix:    frame_len_buggy ok=false
prefix:    try_get_u32=Ok(5)
prefix:    copy_to_slice="hello"

    /// Returns a slice starting at the current position and of length between 0
    /// and `Buf::remaining()`. Note that this *can* return a shorter slice (this
    /// allows non-continuous internal representation).

    fn chunk(&self) -> &[u8] {
        if self.a.has_remaining() {
            self.a.chunk()
        } else {
            self.b.chunk()
        }
    }

    #[inline]
    fn chunk(&self) -> &[u8] {
        self.bufs.front().map(Buf::chunk).unwrap_or_default()
    }

use bytes::{Buf, Bytes};

// 错误写法：只在 chunk() 里找第一行
fn first_line_buggy(buf: &impl Buf) -> Option<Bytes> {
  let c = buf.chunk();
  c.windows(2).position(|w| w == b"\r\n").map(|p| Bytes::copy_from_slice(&c[..p]))
}

// 改法：先变成连续的 Bytes 再找
fn first_line(buf: &mut impl Buf) -> Option<Bytes> {
  let mut all = buf.copy_to_bytes(buf.remaining());
  let p = all.windows(2).position(|w| w == b"\r\n")?;
  Some(all.split_to(p))
}

fn main() {
  let msg = Bytes::from_static(b"GET / HTTP/1.1\r\nHost: a\r\n");
  let want = Some(Bytes::from_static(b"GET / HTTP/1.1"));
  let (mut bad, mut good) = (Vec::new(), 0);
  // 在每一个位置把消息切成两段，用 Chain 接起来再解析
  for at in 0..=msg.len() {
    let mut buf = msg.slice(..at).chain(msg.slice(at..));
    if first_line_buggy(&buf) != want {
      bad.push(at);
    }
    if first_line(&mut buf) == want {
      good += 1;
    }
  }
  println!("split points: {}", msg.len() + 1);
  println!("buggy wrong at {} points: {:?}", bad.len(), bad);
  println!("fixed right at {} points", good);
}

split points: 26
buggy wrong at 15 points: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
fixed right at 26 points