use bytes::{BufMut, Bytes, BytesMut};
use tokio_tungstenite::tungstenite::protocol::Message;
pub(crate) enum WsFrame {
Msg(Message),
Seal(Bytes),
InstallSeal(Box<super::e2e_session::SendState>),
}
#[inline]
pub(super) fn ws_frame_size(frame: &WsFrame) -> usize {
match frame {
WsFrame::Seal(plaintext) => plaintext.len() + 36,
WsFrame::InstallSeal(_) => 0,
WsFrame::Msg(msg) => match msg {
Message::Text(s) => s.len() + 4,
Message::Binary(b) => b.len() + 4,
Message::Ping(p) | Message::Pong(p) => p.len() + 4,
Message::Close(frame) => 8 + frame.as_ref().map_or(0, |f| f.reason.len()),
Message::Frame(_) => 16,
},
}
}
const SHARE_FRAMES_ABOVE: usize = 1024;
#[derive(Default)]
pub(crate) struct BroadcastQueue {
frames: std::collections::VecDeque<Bytes>,
small: BytesMut,
}
impl BroadcastQueue {
pub(crate) fn is_empty(&self) -> bool {
self.frames.is_empty() && self.small.is_empty()
}
pub(crate) fn push(&mut self, frame: &Bytes) {
if frame.len() <= SHARE_FRAMES_ABOVE {
self.small.extend_from_slice(frame);
} else {
self.seal_small();
self.frames.push_back(frame.clone());
}
}
pub(crate) fn swap_into(&mut self, out: &mut std::collections::VecDeque<Bytes>) {
debug_assert!(out.is_empty());
self.seal_small();
std::mem::swap(&mut self.frames, out);
}
fn seal_small(&mut self) {
if !self.small.is_empty() {
self.frames.push_back(self.small.split().freeze());
}
}
}
pub(super) async fn write_all_frames<W: tokio::io::AsyncWrite + Unpin>(
w: &mut W,
frames: &std::collections::VecDeque<Bytes>,
) -> std::io::Result<()> {
use tokio::io::AsyncWriteExt;
const MAX_IOV: usize = 16;
let mut index = 0; let mut offset = 0; while index < frames.len() {
let mut slices = [std::io::IoSlice::new(&[]); MAX_IOV];
slices[0] = std::io::IoSlice::new(&frames[index][offset..]);
let mut count = 1;
for frame in frames.iter().skip(index + 1).take(MAX_IOV - 1) {
slices[count] = std::io::IoSlice::new(frame);
count += 1;
}
let mut written = w.write_vectored(&slices[..count]).await?;
if written == 0 {
return Err(std::io::ErrorKind::WriteZero.into());
}
while written > 0 {
let left = frames[index].len() - offset;
if written >= left {
written -= left;
index += 1;
offset = 0;
} else {
offset += written;
written = 0;
}
}
}
Ok(())
}
pub(crate) fn encode_ws_frame(opcode: u8, payload: &[u8]) -> Bytes {
let len = payload.len();
let header_len = if len < 126 {
2
} else if len < 65536 {
4
} else {
10
};
let mut buf = BytesMut::with_capacity(header_len + len);
buf.put_u8(0x80 | opcode); if len < 126 {
buf.put_u8(len as u8);
} else if len < 65536 {
buf.put_u8(126);
buf.put_u16(len as u16);
} else {
buf.put_u8(127);
buf.put_u64(len as u64);
}
buf.extend_from_slice(payload);
buf.freeze()
}
pub(crate) fn close_frame(code: u16, reason: &str) -> Bytes {
let mut end = reason.len().min(123);
while !reason.is_char_boundary(end) {
end -= 1;
}
let mut payload = Vec::with_capacity(2 + end);
payload.extend_from_slice(&code.to_be_bytes());
payload.extend_from_slice(&reason.as_bytes()[..end]);
encode_ws_frame(0x08, &payload)
}
pub(crate) fn encode_message(msg: &Message) -> Option<Bytes> {
Some(match msg {
Message::Text(text) => encode_ws_frame(0x01, text.as_bytes()),
Message::Binary(data) => encode_ws_frame(0x02, data),
Message::Ping(data) => encode_ws_frame(0x09, data),
Message::Pong(data) => encode_ws_frame(0x0A, data),
Message::Close(Some(frame)) => close_frame(u16::from(frame.code), &frame.reason),
Message::Close(None) => encode_ws_frame(0x08, &[]),
Message::Frame(_) => return None,
})
}
pub(crate) fn pre_frame_text(data: &str) -> Bytes {
encode_ws_frame(0x01, data.as_bytes())
}
#[cfg(test)]
pub(crate) fn pre_frame_binary(data: &[u8]) -> Bytes {
encode_ws_frame(0x02, data)
}