use crate::error::{Error, Result};
const HEADER_SEP: &[u8] = b"\r\n\r\n";
pub const DEFAULT_MAX_FRAME_LEN: usize = 16 * 1024 * 1024;
pub fn encode_frame(body: &[u8]) -> Vec<u8> {
let header = format!("Content-Length: {}\r\n\r\n", body.len());
let mut out = Vec::with_capacity(header.len() + body.len());
out.extend_from_slice(header.as_bytes());
out.extend_from_slice(body);
out
}
pub fn decode_frame(buf: &[u8]) -> Result<Vec<u8>> {
decode_frame_limited(buf, DEFAULT_MAX_FRAME_LEN)
}
pub fn decode_frame_limited(buf: &[u8], max_frame_len: usize) -> Result<Vec<u8>> {
let sep = buf
.windows(HEADER_SEP.len())
.position(|w| w == HEADER_SEP)
.ok_or_else(|| Error::Protocol("missing header terminator".into()))?;
let header = std::str::from_utf8(&buf[..sep])
.map_err(|e| Error::Protocol(format!("invalid header utf8: {e}")))?;
let len = parse_content_length(header)?;
ensure_frame_len(len, max_frame_len)?;
let body_start = sep + HEADER_SEP.len();
let body_end = body_start
.checked_add(len)
.ok_or_else(|| Error::Protocol("content length overflow".into()))?;
if body_end > buf.len() {
return Err(Error::Protocol(format!(
"incomplete body: need {len}, have {}",
buf.len().saturating_sub(body_start)
)));
}
Ok(buf[body_start..body_end].to_vec())
}
fn parse_content_length(header: &str) -> Result<usize> {
let mut content_length: Option<usize> = None;
for line in header.split("\r\n") {
let line = line.trim();
if line.is_empty() {
continue;
}
let Some((k, v)) = line.split_once(':') else {
continue;
};
if k.eq_ignore_ascii_case("Content-Length") {
content_length = Some(
v.trim()
.parse()
.map_err(|_| Error::Protocol(format!("bad Content-Length: {v}")))?,
);
}
}
content_length.ok_or_else(|| Error::Protocol("Content-Length header required".into()))
}
fn ensure_frame_len(len: usize, max_frame_len: usize) -> Result<()> {
if len > max_frame_len {
return Err(Error::Protocol(format!(
"frame too large: {len} > max {max_frame_len}"
)));
}
Ok(())
}
pub trait FrameReaderView: Send + Sync {
fn max_frame_len(&self) -> usize;
fn buffer(&self) -> &[u8];
fn buffered_len(&self) -> usize {
self.buffer().len()
}
}
pub trait FrameReaderMut: FrameReaderView {
fn buffer_mut(&mut self) -> &mut Vec<u8>;
fn set_max_frame_len(&mut self, max: usize);
fn push(&mut self, data: &[u8]) {
self.buffer_mut().extend_from_slice(data);
}
fn clear(&mut self) {
self.buffer_mut().clear();
}
fn try_next(&mut self) -> Result<Option<Vec<u8>>> {
let max = self.max_frame_len();
try_next_frame(self.buffer_mut(), max)
}
}
fn try_next_frame(buf: &mut Vec<u8>, max_frame_len: usize) -> Result<Option<Vec<u8>>> {
let sep = match buf.windows(HEADER_SEP.len()).position(|w| w == HEADER_SEP) {
Some(p) => p,
None => return Ok(None),
};
let header = std::str::from_utf8(&buf[..sep])
.map_err(|e| Error::Protocol(format!("invalid header utf8: {e}")))?;
let len = parse_content_length(header)?;
ensure_frame_len(len, max_frame_len)?;
let body_start = sep + HEADER_SEP.len();
let body_end = body_start
.checked_add(len)
.ok_or_else(|| Error::Protocol("content length overflow".into()))?;
if buf.len() < body_end {
return Ok(None);
}
let body = buf[body_start..body_end].to_vec();
buf.drain(..body_end);
Ok(Some(body))
}
#[derive(Debug)]
pub struct FrameReader {
buf: Vec<u8>,
max_frame_len: usize,
}
impl Default for FrameReader {
fn default() -> Self {
Self::new()
}
}
impl FrameReader {
pub fn new() -> Self {
Self::from_parts(Vec::new(), DEFAULT_MAX_FRAME_LEN)
}
pub fn with_max_frame_len(max_frame_len: usize) -> Self {
Self::from_parts(Vec::new(), max_frame_len)
}
pub fn from_parts(buf: Vec<u8>, max_frame_len: usize) -> Self {
Self { buf, max_frame_len }
}
pub fn into_parts(self) -> (Vec<u8>, usize) {
(self.buf, self.max_frame_len)
}
pub fn max_frame_len(&self) -> usize {
FrameReaderView::max_frame_len(self)
}
pub fn buffered_len(&self) -> usize {
FrameReaderView::buffered_len(self)
}
pub fn push(&mut self, data: &[u8]) {
FrameReaderMut::push(self, data)
}
pub fn clear(&mut self) {
FrameReaderMut::clear(self)
}
pub fn try_next(&mut self) -> Result<Option<Vec<u8>>> {
FrameReaderMut::try_next(self)
}
}
impl FrameReaderView for FrameReader {
fn max_frame_len(&self) -> usize {
self.max_frame_len
}
fn buffer(&self) -> &[u8] {
&self.buf
}
}
impl FrameReaderMut for FrameReader {
fn buffer_mut(&mut self) -> &mut Vec<u8> {
&mut self.buf
}
fn set_max_frame_len(&mut self, max: usize) {
self.max_frame_len = max;
}
}