use std::{error::Error as StdError, time::Duration};
use bytes::Bytes;
use futures_util::{Stream, StreamExt as _};
use crate::{Body, Error, Event, Result};
pub(crate) const CONTENT_TYPE: &str = "text/event-stream; charset=utf-8";
pub(crate) fn encode<S, E>(stream: S, item_limit: usize) -> Body
where
S: Stream<Item = std::result::Result<Event, E>> + Send + 'static,
E: StdError + Send + Sync + 'static,
{
Body::stream(stream.map(move |item| {
item.map_err(|_| Error::body())
.and_then(|event| encode_event(event, item_limit))
}))
}
fn encode_event(event: Event, limit: usize) -> Result<Bytes> {
if event
.event()
.is_some_and(|name| name.bytes().any(|byte| matches!(byte, b'\r' | b'\n')))
|| event
.id()
.is_some_and(|id| id.bytes().any(|byte| matches!(byte, b'\0' | b'\r' | b'\n')))
{
return Err(Error::body());
}
let capacity = encoded_length(&event)
.filter(|length| *length <= limit)
.ok_or_else(Error::body)?;
let mut encoded = Vec::with_capacity(capacity);
if let Some(name) = event.event() {
field(&mut encoded, b"event: ", name);
}
if let Some(id) = event.id() {
field(&mut encoded, b"id: ", id);
}
if let Some(retry) = event.retry() {
encoded.extend_from_slice(b"retry: ");
encoded.extend_from_slice(retry.as_millis().to_string().as_bytes());
encoded.push(b'\n');
}
data_fields(&mut encoded, event.data());
encoded.push(b'\n');
Ok(Bytes::from(encoded))
}
fn encoded_length(event: &Event) -> Option<usize> {
let mut length = 1_usize;
if let Some(name) = event.event() {
length = length.checked_add(8)?.checked_add(name.len())?;
}
if let Some(id) = event.id() {
length = length.checked_add(5)?.checked_add(id.len())?;
}
if let Some(retry) = event.retry() {
length = length
.checked_add(8)?
.checked_add(decimal_digits(retry.as_millis()))?;
}
let bytes = event.data().as_bytes();
let mut data_length = 0_usize;
let mut start = 0;
let mut index = 0;
while index < bytes.len() {
if matches!(bytes[index], b'\r' | b'\n') {
data_length = data_length.checked_add(7)?.checked_add(index - start)?;
if bytes[index] == b'\r' && bytes.get(index + 1) == Some(&b'\n') {
index += 1;
}
start = index + 1;
}
index += 1;
}
data_length = data_length
.checked_add(7)?
.checked_add(bytes.len().checked_sub(start)?)?;
length.checked_add(data_length)
}
fn decimal_digits(mut value: u128) -> usize {
let mut digits = 1;
while value >= 10 {
value /= 10;
digits += 1;
}
digits
}
fn field(output: &mut Vec<u8>, prefix: &[u8], value: &str) {
output.extend_from_slice(prefix);
output.extend_from_slice(value.as_bytes());
output.push(b'\n');
}
fn data_fields(output: &mut Vec<u8>, data: &str) {
let bytes = data.as_bytes();
let mut start = 0;
let mut index = 0;
while index < bytes.len() {
if matches!(bytes[index], b'\r' | b'\n') {
field_bytes(output, &bytes[start..index]);
if bytes[index] == b'\r' && bytes.get(index + 1) == Some(&b'\n') {
index += 1;
}
start = index + 1;
}
index += 1;
}
field_bytes(output, &bytes[start..]);
}
fn field_bytes(output: &mut Vec<u8>, data: &[u8]) {
output.extend_from_slice(b"data: ");
output.extend_from_slice(data);
output.push(b'\n');
}
#[derive(Debug, Default)]
enum BomState {
#[default]
Start,
Ef,
EfBb,
Done,
}
#[derive(Debug)]
pub(super) struct Decoder {
line: Vec<u8>,
data: String,
event: Option<String>,
last_event_id: Option<String>,
retry: Option<Duration>,
event_bytes: usize,
event_limit: usize,
pending_cr: bool,
bom: BomState,
}
impl Decoder {
pub(super) fn new(event_limit: usize) -> Self {
Self {
line: Vec::new(),
data: String::new(),
event: None,
last_event_id: None,
retry: None,
event_bytes: 0,
event_limit,
pending_cr: false,
bom: BomState::default(),
}
}
pub(super) fn push_one(&mut self, bytes: &[u8], offset: &mut usize) -> Result<Option<Event>> {
while let Some(&byte) = bytes.get(*offset) {
*offset += 1;
if let Some(event) = self.byte(byte)? {
return Ok(Some(event));
}
}
Ok(None)
}
pub(super) fn finish(&mut self) -> Result<Option<Event>> {
match std::mem::replace(&mut self.bom, BomState::Done) {
BomState::Ef => self.event_byte(0xef)?,
BomState::EfBb => {
self.event_byte(0xef)?;
self.event_byte(0xbb)?;
None
}
BomState::Start | BomState::Done => None,
};
let event = if self.pending_cr {
self.pending_cr = false;
self.finish_line()?
} else {
if !self.line.is_empty() {
std::str::from_utf8(&self.line)
.map_err(|_| Error::decode("server-sent event field is not valid UTF-8"))?;
}
None
};
self.reset();
Ok(event)
}
fn byte(&mut self, byte: u8) -> Result<Option<Event>> {
match std::mem::replace(&mut self.bom, BomState::Done) {
BomState::Start if byte == 0xef => {
self.bom = BomState::Ef;
return Ok(None);
}
BomState::Ef if byte == 0xbb => {
self.bom = BomState::EfBb;
return Ok(None);
}
BomState::EfBb if byte == 0xbf => return Ok(None),
BomState::Ef => {
self.event_byte(0xef)?;
}
BomState::EfBb => {
self.event_byte(0xef)?;
self.event_byte(0xbb)?;
}
BomState::Start | BomState::Done => {}
}
self.event_byte(byte)
}
fn event_byte(&mut self, byte: u8) -> Result<Option<Event>> {
let mut event = None;
if self.pending_cr {
self.pending_cr = false;
if byte == b'\n' {
self.count_byte()?;
return self.finish_line();
}
event = self.finish_line()?;
}
self.count_byte()?;
match byte {
b'\r' => self.pending_cr = true,
b'\n' => return self.finish_line(),
_ => self.line.push(byte),
}
Ok(event)
}
fn finish_line(&mut self) -> Result<Option<Event>> {
let line = std::mem::take(&mut self.line);
if line.is_empty() {
let event = self.dispatch();
self.event_bytes = 0;
return Ok(event);
}
let line = std::str::from_utf8(&line)
.map_err(|_| Error::decode("server-sent event field is not valid UTF-8"))?;
if line.starts_with(':') {
return Ok(None);
}
let (field, mut value) = line.split_once(':').unwrap_or((line, ""));
if let Some(stripped) = value.strip_prefix(' ') {
value = stripped;
}
match field {
"data" => {
self.data.push_str(value);
self.data.push('\n');
}
"event" => self.event = (!value.is_empty()).then(|| value.to_owned()),
"id" if !value.contains('\0') => self.last_event_id = Some(value.to_owned()),
"retry" if !value.is_empty() && value.bytes().all(|byte| byte.is_ascii_digit()) => {
if let Ok(retry) = value.parse::<u64>() {
self.retry = Some(Duration::from_millis(retry));
}
}
_ => {}
}
Ok(None)
}
fn dispatch(&mut self) -> Option<Event> {
if self.data.is_empty() {
self.event = None;
return None;
}
self.data.pop();
Some(Event::with_metadata(
std::mem::take(&mut self.data),
self.event.take(),
self.last_event_id.clone(),
self.retry,
))
}
fn count_byte(&mut self) -> Result<()> {
self.event_bytes = self
.event_bytes
.checked_add(1)
.filter(|bytes| *bytes <= self.event_limit)
.ok_or_else(|| {
Error::decode("server-sent event exceeds the configured stream limit")
})?;
Ok(())
}
fn reset(&mut self) {
self.line.clear();
self.data.clear();
self.event = None;
self.event_bytes = 0;
self.pending_cr = false;
}
}
#[cfg(test)]
mod tests {
use super::*;
use http_body_util::BodyExt as _;
use std::convert::Infallible;
const TEST_ITEM_LIMIT: usize = 32 * 1024 * 1024;
fn decode(decoder: &mut Decoder, chunks: &[&[u8]]) -> Result<Vec<Event>> {
let mut events = Vec::new();
for chunk in chunks {
let mut offset = 0;
while offset < chunk.len() {
if let Some(event) = decoder.push_one(chunk, &mut offset)? {
events.push(event);
}
}
}
if let Some(event) = decoder.finish()? {
events.push(event);
}
Ok(events)
}
#[test]
fn decoder_handles_chunked_bom_line_endings_and_persistent_fields() {
let events = decode(
&mut Decoder::new(1024),
&[
b"\xef",
b"\xbb",
b"\xbf: ready\r",
b"\nid: event-1\revent: update\rretry: 1500\rdata: first\rdata:",
b" second\r\rdata: third\n\n",
],
)
.unwrap();
assert_eq!(events.len(), 2);
assert_eq!(events[0].event(), Some("update"));
assert_eq!(events[0].data(), "first\nsecond");
assert_eq!(events[0].id(), Some("event-1"));
assert_eq!(events[0].retry(), Some(Duration::from_millis(1500)));
assert_eq!(events[1].data(), "third");
assert_eq!(events[1].id(), Some("event-1"));
}
#[test]
fn decoder_classifies_invalid_utf8_and_oversized_events_as_decode_errors() {
assert!(
decode(&mut Decoder::new(1024), &[b"data: \xff\n\n"])
.unwrap_err()
.is_decode()
);
assert!(
decode(&mut Decoder::new(1024), &[b"\xff"])
.unwrap_err()
.is_decode()
);
assert!(
decode(&mut Decoder::new(8), &[b"data: abc\n\n"])
.unwrap_err()
.is_decode()
);
}
#[test]
fn decoder_follows_event_stream_conformance_cases() {
type Expected<'a> = (&'a str, Option<&'a str>);
type Case<'a> = (&'a str, &'a [&'a [u8]], &'a [Expected<'a>]);
let cases: &[Case<'_>] = &[
(
"empty data fields",
&[b"data\n\ndata\ndata:\n\n"],
&[("", None), ("\n", None)],
),
(
"comments and unknown fields",
&[b": heartbeat\nignored: value\ndata: kept\n\n"],
&[("kept", None)],
),
(
"empty and NUL identifiers",
&[b"id: before\ndata: first\n\nid\ndata: second\n\nid: ignored\0value\ndata: third\n\n"],
&[
("first", Some("before")),
("second", Some("")),
("third", Some("")),
],
),
("unterminated event at EOF", &[b"data: discarded"], &[]),
(
"UTF-8 split across chunks",
&[b"data: \xe2", b"\x82", b"\xac\n\n"],
&[("\u{20ac}", None)],
),
];
for (name, chunks, expected) in cases {
let events = decode(&mut Decoder::new(1024), chunks)
.unwrap_or_else(|error| panic!("{name}: {error}"));
let actual = events
.iter()
.map(|event| (event.data(), event.id()))
.collect::<Vec<_>>();
assert_eq!(actual, *expected, "{name}");
}
let exact = b"data:\n\n";
assert_eq!(
decode(&mut Decoder::new(exact.len()), &[exact])
.unwrap()
.len(),
1
);
assert!(
decode(&mut Decoder::new(exact.len() - 1), &[exact])
.unwrap_err()
.is_decode()
);
}
fn decode_in_random_chunks(
decoder: &mut Decoder,
input: &[u8],
rng: &mut fastrand::Rng,
) -> Result<()> {
let mut start = 0;
while start < input.len() {
let end = (start + rng.usize(1..128)).min(input.len());
let chunk = &input[start..end];
let mut offset = 0;
while offset < chunk.len() {
let _ = decoder.push_one(chunk, &mut offset)?;
}
start = end;
}
let _ = decoder.finish()?;
Ok(())
}
#[test]
fn decoder_handles_seeded_mutations_across_chunk_boundaries() {
const SEEDS: &[&[u8]] = &[
b"data: message\n\n",
b": heartbeat\r\nid: event-1\r\nevent: update\r\nretry: 1500\r\ndata: first\r\ndata: second\r\n\r\n",
b"\xef\xbb\xbfdata: \xe2\x82\xac\n\n",
b"id\nretry: 0\ndata:\n\n",
];
let mut rng = fastrand::Rng::with_seed(0);
for (index, seed) in SEEDS.iter().enumerate() {
for _ in 0..32 {
decode_in_random_chunks(&mut Decoder::new(TEST_ITEM_LIMIT), seed, &mut rng)
.unwrap_or_else(|error| panic!("valid SSE seed {index} failed: {error}"));
}
}
for _ in 0..1024 {
let mut input = Vec::new();
for _ in 0..rng.usize(1..8) {
input.extend_from_slice(SEEDS[rng.usize(0..SEEDS.len())]);
}
for _ in 0..rng.usize(0..16) {
match rng.usize(0..3) {
0 if !input.is_empty() => {
let index = rng.usize(0..input.len());
input[index] = rng.u8(0x20..0x7f);
}
1 => {
let index = rng.usize(0..=input.len());
input.insert(index, rng.u8(0x20..0x7f));
}
_ if !input.is_empty() => {
input.remove(rng.usize(0..input.len()));
}
_ => {}
}
}
let _ = decode_in_random_chunks(&mut Decoder::new(TEST_ITEM_LIMIT), &input, &mut rng);
}
}
#[tokio::test]
async fn encoder_preserves_metadata_and_normalizes_data_line_endings() {
let event = Event::new("first\r\nsecond\rthird\nfourth")
.with_event("update")
.with_id("event-1")
.with_retry(Duration::from_millis(1250));
let expected = "event: update\nid: event-1\nretry: 1250\ndata: first\ndata: second\ndata: third\ndata: fourth\n\n";
assert_eq!(encoded_length(&event), Some(expected.len()));
let stream = futures_util::stream::iter([Ok::<_, Infallible>(event)]);
let frames = encode(stream, expected.len())
.collect()
.await
.unwrap()
.to_bytes();
assert_eq!(frames, expected);
}
#[tokio::test]
async fn encoder_rejects_fields_that_could_inject_protocol_lines() {
let stream = futures_util::stream::iter([Ok::<_, Infallible>(
Event::new("safe").with_id("unsafe\nid"),
)]);
assert!(
encode(stream, 1024)
.frame()
.await
.unwrap()
.unwrap_err()
.is_body()
);
}
#[tokio::test]
async fn encoder_rejects_one_event_beyond_the_item_limit() {
let stream = futures_util::stream::iter([Ok::<_, Infallible>(Event::new("1234"))]);
assert!(
encode(stream, 3)
.frame()
.await
.unwrap()
.unwrap_err()
.is_body()
);
}
}