use std::{
fmt,
pin::Pin,
task::{Context, Poll},
time::Duration,
};
use bytes::Bytes;
use futures_util::Stream;
use http_body::Body as _;
use serde::de::DeserializeOwned;
use crate::{Body, Error, Result};
const EVENT_LIMIT: usize = 32 * 1024 * 1024;
#[derive(Clone, Eq, PartialEq)]
pub struct Event {
event: Option<String>,
data: String,
id: Option<String>,
retry: Option<Duration>,
}
impl Event {
#[must_use]
pub fn event(&self) -> Option<&str> {
self.event.as_deref()
}
#[must_use]
pub fn data(&self) -> &str {
&self.data
}
#[must_use]
pub fn id(&self) -> Option<&str> {
self.id.as_deref()
}
#[must_use]
pub fn retry(&self) -> Option<Duration> {
self.retry
}
pub fn json<T>(&self) -> Result<T>
where
T: DeserializeOwned,
{
serde_json::from_str(&self.data)
.map_err(|_| Error::decode("server-sent event JSON could not be decoded"))
}
}
impl fmt::Debug for Event {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("Event")
.field("has_event", &self.event.is_some())
.field("data_len", &self.data.len())
.field("has_id", &self.id.is_some())
.field("retry", &self.retry)
.finish()
}
}
pub struct EventStream {
body: Body,
decoder: Decoder,
pending: Option<Bytes>,
pending_offset: usize,
finished: bool,
}
impl EventStream {
pub(crate) fn new(body: Body) -> Self {
Self {
body,
decoder: Decoder::new(EVENT_LIMIT),
pending: None,
pending_offset: 0,
finished: false,
}
}
pub async fn next(&mut self) -> Result<Option<Event>> {
std::future::poll_fn(|context| Pin::new(&mut *self).poll_next(context))
.await
.transpose()
}
}
impl fmt::Debug for EventStream {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("EventStream")
.finish_non_exhaustive()
}
}
impl Stream for EventStream {
type Item = Result<Event>;
fn poll_next(mut self: Pin<&mut Self>, context: &mut Context<'_>) -> Poll<Option<Self::Item>> {
loop {
if let Some(data) = self.pending.take() {
let mut offset = self.pending_offset;
let decoded = self.decoder.push_one(&data, &mut offset);
if offset < data.len() {
self.pending = Some(data);
self.pending_offset = offset;
} else {
self.pending_offset = 0;
}
match decoded {
Ok(Some(event)) => return Poll::Ready(Some(Ok(event))),
Ok(None) => {}
Err(error) => {
self.finished = true;
self.pending = None;
return Poll::Ready(Some(Err(error)));
}
}
}
if self.finished {
return Poll::Ready(None);
}
match Pin::new(&mut self.body).poll_frame(context) {
Poll::Ready(Some(Ok(frame))) => {
if let Ok(data) = frame.into_data() {
self.pending = Some(data);
self.pending_offset = 0;
}
}
Poll::Ready(Some(Err(error))) => {
self.finished = true;
return Poll::Ready(Some(Err(error)));
}
Poll::Ready(None) => {
self.finished = true;
return match self.decoder.finish() {
Ok(Some(event)) => Poll::Ready(Some(Ok(event))),
Ok(None) => Poll::Ready(None),
Err(error) => Poll::Ready(Some(Err(error))),
};
}
Poll::Pending => return Poll::Pending,
}
}
}
}
#[derive(Debug, Default)]
enum BomState {
#[default]
Start,
Ef,
EfBb,
Done,
}
#[derive(Debug)]
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 {
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(),
}
}
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)
}
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)?;
}
BomState::Start | BomState::Done => {}
}
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 {
event: self.event.take(),
data: std::mem::take(&mut self.data),
id: self.last_event_id.clone(),
retry: 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 32 MiB 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::*;
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 mut decoder = Decoder::new(1024);
let events = decode(
&mut decoder,
&[
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].event(), None);
assert_eq!(events[1].data(), "third");
assert_eq!(events[1].id(), Some("event-1"));
assert_eq!(events[1].retry(), Some(Duration::from_millis(1500)));
}
#[test]
fn decoder_classifies_invalid_utf8_and_oversized_events_as_decode_errors() {
let mut invalid_utf8 = Decoder::new(1024);
let error = decode(&mut invalid_utf8, &[b"data: \xff\n\n"]).unwrap_err();
assert!(error.is_decode());
let mut incomplete_utf8 = Decoder::new(1024);
let error = decode(&mut incomplete_utf8, &[b"\xff"]).unwrap_err();
assert!(error.is_decode());
let mut oversized = Decoder::new(8);
let error = decode(&mut oversized, &[b"data: abc\n\n"]).unwrap_err();
assert!(error.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
);
let error = decode(&mut Decoder::new(exact.len() - 1), &[exact]).unwrap_err();
assert!(error.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(EVENT_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.usize(0x20..0x7f) as u8;
}
1 => {
let index = rng.usize(0..input.len() + 1);
input.insert(index, rng.usize(0x20..0x7f) as u8);
}
_ if !input.is_empty() => {
input.remove(rng.usize(0..input.len()));
}
_ => {}
}
}
let _ = decode_in_random_chunks(&mut Decoder::new(EVENT_LIMIT), &input, &mut rng);
}
}
#[test]
fn event_debug_does_not_expose_data_or_identifier_values() {
let event = Event {
event: Some("event secret".to_owned()),
data: "body secret".to_owned(),
id: Some("id secret".to_owned()),
retry: None,
};
let debug = format!("{event:?}");
assert!(!debug.contains("event secret"));
assert!(!debug.contains("body secret"));
assert!(!debug.contains("id secret"));
assert!(debug.contains("has_event"));
assert!(debug.contains("data_len"));
}
}