use alloc::vec::Vec;
use core::{fmt, ops::Range};
use crate::limits::Limits;
pub const READ_CHUNK: usize = 8 * 1024;
const SHRINK_CHUNKS: usize = 4;
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum Framing {
ContentLength,
Newline,
}
impl Framing {
pub fn encode(self, body: &[u8], out: &mut Vec<u8>) {
match self {
Framing::ContentLength => {
out.reserve(body.len() + 40);
out.extend_from_slice(b"Content-Length: ");
let (digits, at) = decimal(body.len() as u64);
out.extend_from_slice(&digits[at..]);
out.extend_from_slice(b"\r\n\r\n");
out.extend_from_slice(body);
}
Framing::Newline => {
out.reserve(body.len() + 1);
let mut rest = body;
while let Some(at) = find_line_break(rest) {
out.extend_from_slice(&rest[..at]);
out.push(b' ');
rest = &rest[at + 1..];
}
out.extend_from_slice(rest);
out.push(b'\n');
}
}
}
#[must_use]
pub fn decoder(self, limits: &Limits) -> Decoder {
Decoder::new(self, limits)
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum FrameError {
HeaderTooLarge {
limit: usize,
},
TooManyHeaders {
limit: usize,
},
InvalidHeader,
MissingContentLength,
DuplicateContentLength,
InvalidContentLength,
TooLarge {
length: Option<u64>,
limit: usize,
},
Truncated,
TooLargeToSkip {
length: u64,
limit: u64,
},
}
impl FrameError {
#[must_use]
pub const fn is_recoverable(&self) -> bool {
matches!(self, FrameError::TooLarge { .. })
}
}
impl fmt::Display for FrameError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
FrameError::HeaderTooLarge { limit } => {
write!(f, "a header section is longer than {limit} bytes")
}
FrameError::TooManyHeaders { limit } => {
write!(f, "a header section has more than {limit} lines")
}
FrameError::InvalidHeader => f.write_str("a header line is not `name: value`"),
FrameError::MissingContentLength => {
f.write_str("a header section has no `Content-Length`")
}
FrameError::DuplicateContentLength => {
f.write_str("a header section has more than one `Content-Length`")
}
FrameError::InvalidContentLength => {
f.write_str("a `Content-Length` value is not a non-negative decimal integer")
}
FrameError::TooLarge {
length: Some(length),
limit,
} => write!(
f,
"a message of {length} bytes exceeds the limit of {limit}"
),
FrameError::TooLarge {
length: None,
limit,
} => {
write!(f, "a message exceeds the limit of {limit} bytes")
}
FrameError::Truncated => f.write_str("the stream ended inside a message"),
FrameError::TooLargeToSkip { length, limit } => write!(
f,
"a message of {length} bytes is over the skip limit of {limit}"
),
}
}
}
impl core::error::Error for FrameError {}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum State {
Headers {
lines: usize,
bytes: usize,
length: Option<u64>,
},
Body { length: usize },
Skip { remaining: u64 },
Line,
Discard,
}
enum Step {
Again,
Wait,
Frame(Range<usize>),
}
#[derive(Clone, Debug)]
pub struct Decoder {
framing: Framing,
max_message: usize,
max_header_bytes: usize,
max_headers: usize,
max_skip: u64,
chunk: usize,
buf: Vec<u8>,
start: usize,
end: usize,
scan: usize,
state: State,
drained: bool,
failed: Option<FrameError>,
}
impl Decoder {
#[must_use]
pub fn new(framing: Framing, limits: &Limits) -> Self {
Self {
framing,
max_message: limits.max_message_bytes,
max_header_bytes: limits.max_header_bytes,
max_headers: limits.max_headers,
max_skip: limits.max_skip_bytes,
chunk: READ_CHUNK,
buf: Vec::new(),
start: 0,
end: 0,
scan: 0,
state: Self::fresh(framing),
drained: true,
failed: None,
}
}
#[inline]
#[must_use]
pub const fn framing(&self) -> Framing {
self.framing
}
#[must_use]
pub const fn with_read_chunk(mut self, bytes: usize) -> Self {
self.chunk = if bytes == 0 { 1 } else { bytes };
self
}
#[inline]
#[must_use]
pub const fn read_chunk(&self) -> usize {
self.chunk
}
#[inline]
#[must_use]
pub fn capacity(&self) -> usize {
self.buf.capacity()
}
#[inline]
#[must_use]
pub const fn buffered(&self) -> usize {
self.end - self.start
}
#[cfg(feature = "net")]
pub(crate) fn in_message(&self) -> bool {
let fresh = match self.state {
State::Headers {
lines,
bytes,
length,
} => lines == 0 && bytes == 0 && length.is_none(),
State::Line => true,
State::Body { .. } | State::Skip { .. } | State::Discard => false,
};
self.buffered() > 0 || !fresh
}
#[must_use]
pub const fn memory_bound(&self) -> usize {
let message = self.max_message.saturating_add(1);
let largest = if message > self.max_header_bytes {
message
} else {
self.max_header_bytes
};
largest.saturating_add(self.chunk)
}
pub fn space(&mut self) -> &mut [u8] {
if !self.drained || self.failed.is_some() {
return &mut [];
}
if self.start == self.end {
self.start = 0;
self.end = 0;
self.scan = 0;
}
let chunk = self.chunk;
let have = self.end - self.start;
let want = match self.state {
State::Body { length } => {
let need = length.saturating_sub(have);
if need <= chunk {
chunk
} else {
need.min(have.max(chunk))
}
}
_ => chunk,
};
let keep = have.saturating_add(want);
let held = self.buf.capacity();
if held >= chunk.saturating_mul(SHRINK_CHUNKS) && held / 4 >= keep {
self.compact();
self.buf.truncate(keep);
self.buf.shrink_to_fit();
}
if self.buf.len() - self.end < want {
self.compact();
let missing = want.saturating_sub(self.buf.len() - self.end);
if missing > 0 {
let len = self.buf.len();
let target = len.saturating_add(missing);
if target > held {
let grown = len.saturating_mul(2).min(self.memory_bound()).max(target);
self.buf.reserve_exact(grown - len);
}
self.buf.resize(target, 0);
}
}
&mut self.buf[self.end..]
}
pub fn commit(&mut self, n: usize) {
let n = n.min(self.buf.len() - self.end);
if n > 0 {
self.end += n;
self.drained = false;
}
}
pub fn feed(&mut self, bytes: &[u8]) -> usize {
let space = self.space();
let n = bytes.len().min(space.len());
space[..n].copy_from_slice(&bytes[..n]);
self.commit(n);
n
}
pub fn next_frame(&mut self) -> Result<Option<&[u8]>, FrameError> {
match self.next_range() {
Ok(Some(range)) => Ok(Some(&self.buf[range])),
Ok(None) => Ok(None),
Err(error) => Err(error),
}
}
pub fn finish(&mut self) -> Result<Option<&[u8]>, FrameError> {
match self.finish_range() {
Ok(Some(range)) => Ok(Some(&self.buf[range])),
Ok(None) => Ok(None),
Err(error) => Err(error),
}
}
#[cfg(feature = "std")]
pub(crate) fn carried(&self, framing: Framing, limits: &Limits) -> Decoder {
let mut next = Decoder::new(framing, limits).with_read_chunk(self.chunk);
let between = self.failed.is_none() && self.state == Self::fresh(self.framing);
if between && self.start < self.end {
next.buf = self.buf[self.start..self.end].to_vec();
next.end = next.buf.len();
next.drained = false;
}
next
}
fn compact(&mut self) {
if self.start > 0 {
self.buf.copy_within(self.start..self.end, 0);
self.end -= self.start;
self.scan -= self.start;
self.start = 0;
}
}
fn fresh(framing: Framing) -> State {
match framing {
Framing::ContentLength => State::Headers {
lines: 0,
bytes: 0,
length: None,
},
Framing::Newline => State::Line,
}
}
fn fail(&mut self, error: FrameError) -> FrameError {
self.failed = Some(error);
error
}
fn finish_range(&mut self) -> Result<Option<Range<usize>>, FrameError> {
if let Some(range) = self.next_range()? {
return Ok(Some(range));
}
let rest = self.start..self.end;
match self.state {
State::Headers { lines: 0, .. } if is_blank(&self.buf[rest.clone()]) => {
self.start = self.end;
Ok(None)
}
State::Headers { .. } | State::Body { .. } | State::Skip { .. } => {
Err(self.fail(FrameError::Truncated))
}
State::Line => {
self.start = self.end;
self.scan = self.end;
let line = trim_line(&self.buf, rest);
if line.len() > self.max_message {
Err(self.line_too_large())
} else if is_blank(&self.buf[line.clone()]) {
Ok(None)
} else {
Ok(Some(line))
}
}
State::Discard => {
self.start = self.end;
self.scan = self.end;
Ok(None)
}
}
}
fn next_range(&mut self) -> Result<Option<Range<usize>>, FrameError> {
if let Some(error) = self.failed {
return Err(error);
}
loop {
let step = match self.state {
State::Headers {
lines,
bytes,
length,
} => self.step_headers(lines, bytes, length)?,
State::Body { length } => self.step_body(length),
State::Skip { remaining } => self.step_skip(remaining),
State::Line => self.step_line()?,
State::Discard => self.step_discard(),
};
match step {
Step::Again => {}
Step::Wait => return Ok(self.wait()),
Step::Frame(range) => return Ok(Some(range)),
}
}
}
fn step_headers(
&mut self,
lines: usize,
bytes: usize,
length: Option<u64>,
) -> Result<Step, FrameError> {
let Some(at) = find_newline(&self.buf[self.scan..self.end]) else {
self.scan = self.end;
let pending = &self.buf[self.start..self.end];
let pending = if lines == 0 && pending == b"\r" {
0
} else {
pending.len()
};
if bytes.saturating_add(pending) > self.max_header_bytes {
return Err(self.fail(FrameError::HeaderTooLarge {
limit: self.max_header_bytes,
}));
}
return Ok(Step::Wait);
};
let line_end = self.scan + at + 1;
let line_len = line_end - self.start;
let line = trim_line(&self.buf, self.start..line_end - 1);
let bytes = bytes.saturating_add(line_len);
if line.is_empty() {
self.start = line_end;
self.scan = line_end;
if lines > 0 {
if bytes > self.max_header_bytes {
return Err(self.fail(FrameError::HeaderTooLarge {
limit: self.max_header_bytes,
}));
}
self.end_headers(length)?;
}
return Ok(Step::Again);
}
if bytes > self.max_header_bytes {
return Err(self.fail(FrameError::HeaderTooLarge {
limit: self.max_header_bytes,
}));
}
let lines = lines + 1;
if lines > self.max_headers {
return Err(self.fail(FrameError::TooManyHeaders {
limit: self.max_headers,
}));
}
let length = match parse_header(&self.buf[line]) {
Header::ContentLength(_) if length.is_some() => {
return Err(self.fail(FrameError::DuplicateContentLength));
}
Header::ContentLength(n) => Some(n),
Header::Other => length,
Header::Invalid(error) => return Err(self.fail(error)),
};
self.start = line_end;
self.scan = line_end;
self.state = State::Headers {
lines,
bytes,
length,
};
Ok(Step::Again)
}
fn step_body(&mut self, length: usize) -> Step {
if self.end - self.start < length {
return Step::Wait;
}
let body = self.start..self.start + length;
self.start += length;
self.scan = self.start;
self.state = Self::fresh(self.framing);
Step::Frame(body)
}
fn step_skip(&mut self, remaining: u64) -> Step {
let available = (self.end - self.start) as u64;
let take = available.min(remaining);
self.start += take as usize;
self.scan = self.start;
if take == remaining {
self.state = Self::fresh(self.framing);
return Step::Again;
}
self.state = State::Skip {
remaining: remaining - take,
};
Step::Wait
}
fn step_line(&mut self) -> Result<Step, FrameError> {
let Some(at) = find_newline(&self.buf[self.scan..self.end]) else {
self.scan = self.end;
if self.end - self.start > self.max_message.saturating_add(1) {
self.start = self.end;
self.scan = self.end;
self.state = State::Discard;
return Err(self.line_too_large());
}
return Ok(Step::Wait);
};
let newline = self.scan + at;
let line = trim_line(&self.buf, self.start..newline);
self.start = newline + 1;
self.scan = self.start;
if line.len() > self.max_message {
return Err(self.line_too_large());
}
if is_blank(&self.buf[line.clone()]) {
return Ok(Step::Again);
}
Ok(Step::Frame(line))
}
fn step_discard(&mut self) -> Step {
match find_newline(&self.buf[self.scan..self.end]) {
Some(at) => {
self.start = self.scan + at + 1;
self.scan = self.start;
self.state = State::Line;
Step::Again
}
None => {
self.start = self.end;
self.scan = self.end;
Step::Wait
}
}
}
fn end_headers(&mut self, length: Option<u64>) -> Result<(), FrameError> {
let Some(length) = length else {
return Err(self.fail(FrameError::MissingContentLength));
};
match usize::try_from(length) {
Ok(n) if n <= self.max_message => {
self.state = State::Body { length: n };
Ok(())
}
_ if length > self.max_skip => Err(self.fail(FrameError::TooLargeToSkip {
length,
limit: self.max_skip,
})),
_ => {
self.state = State::Skip { remaining: length };
Err(FrameError::TooLarge {
length: Some(length),
limit: self.max_message,
})
}
}
}
fn line_too_large(&self) -> FrameError {
FrameError::TooLarge {
length: None,
limit: self.max_message,
}
}
fn wait<T>(&mut self) -> Option<T> {
self.drained = true;
None
}
}
enum Header {
ContentLength(u64),
Other,
Invalid(FrameError),
}
fn parse_header(line: &[u8]) -> Header {
let Some(colon) = line.iter().position(|&b| b == b':') else {
return Header::Invalid(FrameError::InvalidHeader);
};
let (name, value) = line.split_at(colon);
if name.is_empty() || !name.iter().all(|&b| is_token(b)) {
return Header::Invalid(FrameError::InvalidHeader);
}
if !name.eq_ignore_ascii_case(b"content-length") {
return Header::Other;
}
let value = trim_spaces(&value[1..]);
if value.is_empty() {
return Header::Invalid(FrameError::InvalidContentLength);
}
let mut n: u64 = 0;
for &b in value {
if !b.is_ascii_digit() {
return Header::Invalid(FrameError::InvalidContentLength);
}
let Some(next) = n
.checked_mul(10)
.and_then(|n| n.checked_add(u64::from(b - b'0')))
else {
return Header::Invalid(FrameError::InvalidContentLength);
};
n = next;
}
Header::ContentLength(n)
}
fn is_token(b: u8) -> bool {
b.is_ascii_alphanumeric() || b"!#$%&'*+-.^_`|~".contains(&b)
}
fn trim_spaces(bytes: &[u8]) -> &[u8] {
let start = bytes.iter().position(|&b| b != b' ' && b != b'\t');
let end = bytes.iter().rposition(|&b| b != b' ' && b != b'\t');
match (start, end) {
(Some(start), Some(end)) => &bytes[start..=end],
_ => &[],
}
}
fn trim_line(buf: &[u8], range: Range<usize>) -> Range<usize> {
if range.end > range.start && buf[range.end - 1] == b'\r' {
range.start..range.end - 1
} else {
range
}
}
fn is_blank(bytes: &[u8]) -> bool {
bytes
.iter()
.all(|&b| matches!(b, b' ' | b'\t' | b'\r' | b'\n'))
}
const ONES: u64 = 0x0101_0101_0101_0101;
const HIGHS: u64 = 0x8080_8080_8080_8080;
#[inline]
const fn has_zero(word: u64) -> bool {
word.wrapping_sub(ONES) & !word & HIGHS != 0
}
#[inline]
fn find_with(
hay: &[u8],
word_hit: impl Fn(u64) -> bool,
hit: impl Fn(u8) -> bool,
) -> Option<usize> {
let mut chunks = hay.chunks_exact(8);
let mut base = 0;
for chunk in &mut chunks {
let word = u64::from_le_bytes([
chunk[0], chunk[1], chunk[2], chunk[3], chunk[4], chunk[5], chunk[6], chunk[7],
]);
if word_hit(word) {
return chunk.iter().position(|&b| hit(b)).map(|i| base + i);
}
base += 8;
}
chunks
.remainder()
.iter()
.position(|&b| hit(b))
.map(|i| base + i)
}
pub(crate) fn find_newline(hay: &[u8]) -> Option<usize> {
find_with(
hay,
|w| has_zero(w ^ (ONES * u64::from(b'\n'))),
|b| b == b'\n',
)
}
fn find_line_break(hay: &[u8]) -> Option<usize> {
find_with(
hay,
|w| has_zero(w ^ (ONES * u64::from(b'\n'))) || has_zero(w ^ (ONES * u64::from(b'\r'))),
|b| b == b'\n' || b == b'\r',
)
}
fn decimal(mut n: u64) -> ([u8; 20], usize) {
let mut digits = [0u8; 20];
let mut at = digits.len();
loop {
at -= 1;
digits[at] = b'0' + (n % 10) as u8;
n /= 10;
if n == 0 {
break;
}
}
(digits, at)
}
#[cfg(test)]
#[allow(clippy::panic)]
mod tests {
use alloc::vec;
use proptest::prelude::*;
use super::*;
fn frames(
framing: Framing,
limits: &Limits,
input: &[u8],
chunk: usize,
) -> Vec<Result<Vec<u8>, FrameError>> {
frames_with(&mut framing.decoder(limits), input, chunk)
}
fn frames_with(
d: &mut Decoder,
input: &[u8],
chunk: usize,
) -> Vec<Result<Vec<u8>, FrameError>> {
let mut out = Vec::new();
let mut rest = input;
loop {
loop {
match d.next_frame() {
Ok(Some(f)) => out.push(Ok(f.to_vec())),
Ok(None) => break,
Err(e) => {
out.push(Err(e));
if !e.is_recoverable() {
return out;
}
}
}
assert!(d.buf.len() <= d.memory_bound());
assert!(d.buf.capacity() <= d.memory_bound());
}
if rest.is_empty() {
break;
}
let take = rest.len().min(chunk.max(1));
let n = d.feed(&rest[..take]);
rest = &rest[n..];
assert!(
d.buf.len() <= d.memory_bound(),
"{} > {}",
d.buf.len(),
d.memory_bound()
);
}
loop {
match d.finish() {
Ok(Some(f)) => out.push(Ok(f.to_vec())),
Ok(None) => break,
Err(e) => {
out.push(Err(e));
if !e.is_recoverable() {
break;
}
}
}
}
out
}
#[test]
fn test_content_length_basic() {
let input = b"\r\nContent-Length: 2\r\ncontent-type: x\r\n\r\n{}content-length:3\n\n[1]";
let got = frames(Framing::ContentLength, &Limits::new(), input, 3);
assert_eq!(got, vec![Ok(b"{}".to_vec()), Ok(b"[1]".to_vec())]);
}
#[test]
fn test_content_length_errors() {
let limits = Limits::new().with_max_headers(2).with_max_header_bytes(64);
for (input, error) in [
(
&b"Content-Length: -1\r\n\r\n"[..],
FrameError::InvalidContentLength,
),
(
b"Content-Length: \r\n\r\n",
FrameError::InvalidContentLength,
),
(
b"Content-Length: 99999999999999999999\r\n\r\n",
FrameError::InvalidContentLength,
),
(
b"Content-Length: 1 2\r\n\r\n",
FrameError::InvalidContentLength,
),
(
b"Content-Length: +1\r\n\r\n",
FrameError::InvalidContentLength,
),
(b"X: 1\r\n\r\n", FrameError::MissingContentLength),
(
b"Content-Length: 1\r\nContent-Length: 1\r\n\r\n",
FrameError::DuplicateContentLength,
),
(b"nocolon\r\n\r\n", FrameError::InvalidHeader),
(
b"A: 1\r\nB: 2\r\nC: 3\r\n",
FrameError::TooManyHeaders { limit: 2 },
),
(&[b'x'; 100][..], FrameError::HeaderTooLarge { limit: 64 }),
(b"Content-Length: 5\r\n\r\nab", FrameError::Truncated),
(b"Content-Len", FrameError::Truncated),
] {
let got = frames(Framing::ContentLength, &limits, input, 7);
assert_eq!(
got.last(),
Some(&Err(error)),
"{:?}",
core::str::from_utf8(input)
);
}
}
#[test]
fn test_content_length_overflowing_u64_is_invalid_not_large() {
let got = frames(
Framing::ContentLength,
&Limits::new(),
b"Content-Length: 18446744073709551616\r\n\r\n",
64,
);
assert_eq!(got, vec![Err(FrameError::InvalidContentLength)]);
let got = frames(
Framing::ContentLength,
&Limits::new(),
b"Content-Length: 18446744073709551615\r\n\r\n",
64,
);
assert_eq!(
got,
vec![
Err(FrameError::TooLarge {
length: Some(u64::MAX),
limit: 64 * 1024 * 1024
}),
Err(FrameError::Truncated)
]
);
}
#[test]
fn test_oversized_body_is_skipped_without_buffering() {
let limits = Limits::new().with_max_message_bytes(4);
let mut input = b"Content-Length: 100000\r\n\r\n".to_vec();
input.extend(core::iter::repeat_n(b'x', 100_000));
input.extend_from_slice(b"Content-Length: 2\r\n\r\nok");
let got = frames(Framing::ContentLength, &limits, &input, 4096);
assert_eq!(
got,
vec![
Err(FrameError::TooLarge {
length: Some(100_000),
limit: 4
}),
Ok(b"ok".to_vec())
]
);
}
#[test]
fn test_body_over_the_skip_limit_is_fatal() {
let limits = Limits::new()
.with_max_message_bytes(4)
.with_max_skip_bytes(10);
let mut input = b"Content-Length: 10\r\n\r\n0123456789".to_vec();
input.extend_from_slice(b"Content-Length: 11\r\n\r\n");
let got = frames(Framing::ContentLength, &limits, &input, 5);
let error = FrameError::TooLargeToSkip {
length: 11,
limit: 10,
};
assert_eq!(
got,
vec![
Err(FrameError::TooLarge {
length: Some(10),
limit: 4
}),
Err(error)
]
);
assert!(!error.is_recoverable());
assert_eq!(
alloc::string::ToString::to_string(&error),
"a message of 11 bytes is over the skip limit of 10"
);
}
#[test]
fn test_newline_basic() {
let input = b"\n \r\n{\"a\":1}\r\n[2]\n\n3";
let got = frames(Framing::Newline, &Limits::new(), input, 2);
assert_eq!(
got,
vec![
Ok(b"{\"a\":1}".to_vec()),
Ok(b"[2]".to_vec()),
Ok(b"3".to_vec())
]
);
}
#[test]
fn test_newline_oversized_line_is_skipped() {
let limits = Limits::new().with_max_message_bytes(4);
let mut input = vec![b'y'; 50_000];
input.extend_from_slice(b"\nok\n12345\n");
let got = frames(Framing::Newline, &limits, &input, 1000);
assert_eq!(
got,
vec![
Err(FrameError::TooLarge {
length: None,
limit: 4
}),
Ok(b"ok".to_vec()),
Err(FrameError::TooLarge {
length: None,
limit: 4
}),
]
);
}
#[test]
fn test_body_reserve_grows_with_arrival() {
let mut d = Framing::ContentLength.decoder(&Limits::new());
let _taken = d.feed(b"Content-Length: 60000000\r\n\r\n");
assert_eq!(d.next_frame(), Ok(None));
assert!(d.space().len() <= 2 * READ_CHUNK);
}
#[test]
fn test_buffer_shrinks_after_a_large_message() {
for framing in [Framing::ContentLength, Framing::Newline] {
let mut d = framing.decoder(&Limits::new());
let mut wire = Vec::new();
framing.encode(&vec![b'7'; 10_000_000], &mut wire);
for _ in 0..1000 {
framing.encode(b"[1]", &mut wire);
}
let mut rest = wire.as_slice();
let mut frames = 0;
let mut peak = 0;
while !rest.is_empty() {
let n = d.feed(rest);
rest = &rest[n..];
peak = peak.max(d.capacity());
while let Ok(Some(_)) = d.next_frame() {
frames += 1;
}
}
assert_eq!(frames, 1001, "{framing:?}");
assert!(peak >= 10_000_000, "{framing:?}: {peak}");
assert!(
d.capacity() <= 2 * READ_CHUNK,
"{framing:?}: {}",
d.capacity()
);
}
}
#[test]
fn test_buffer_keeps_its_size_while_a_message_grows() {
let mut d = Framing::Newline.decoder(&Limits::new());
let mut last = 0;
for _ in 0..64 {
let space = d.space();
let n = space.len().min(READ_CHUNK);
space[..n].fill(b'x');
d.commit(n);
assert_eq!(d.next_frame(), Ok(None));
assert!(d.capacity() >= last);
last = d.capacity();
}
assert!(d.buffered() >= 64 * READ_CHUNK - READ_CHUNK);
}
#[test]
fn test_read_chunk_is_configurable() {
let mut d = Framing::Newline.decoder(&Limits::new()).with_read_chunk(0);
assert_eq!(d.read_chunk(), 1);
assert_eq!(d.space().len(), 1);
let mut d = Framing::ContentLength
.decoder(&Limits::new().with_max_message_bytes(10))
.with_read_chunk(3);
assert_eq!(d.memory_bound(), Limits::new().max_header_bytes + 3);
let got = frames_with(&mut d, b"Content-Length: 2\r\n\r\nok", 100);
assert_eq!(got, vec![Ok(b"ok".to_vec())]);
assert!(d.capacity() <= d.memory_bound());
}
#[test]
fn test_encode_newline_replaces_breaks() {
let mut out = Vec::new();
Framing::Newline.encode(b"{\r\n\"a\":\n1}", &mut out);
assert_eq!(out, b"{ \"a\": 1}\n");
}
#[test]
fn test_find_newline_matches_naive() {
let mut hay = vec![b'a'; 40];
assert_eq!(find_newline(&hay), None);
for at in 0..40 {
hay[at] = b'\n';
assert_eq!(find_newline(&hay), Some(at));
hay[at] = 0x8a; assert_eq!(find_newline(&hay), None);
hay[at] = b'a';
}
}
proptest! {
#[test]
fn prop_chunking_does_not_change_frames(
input in proptest::collection::vec(prop_oneof![Just(b'\n'), Just(b'\r'), Just(b':'), Just(b'7'), any::<u8>()], 0..600),
a in 1usize..64,
b in 1usize..64,
newline in any::<bool>(),
) {
let framing = if newline { Framing::Newline } else { Framing::ContentLength };
let limits = Limits::new().with_max_message_bytes(40).with_max_header_bytes(48).with_max_headers(3);
prop_assert_eq!(frames(framing, &limits, &input, a), frames(framing, &limits, &input, b));
}
}
}