use crate::error::{Error, Result};
use crate::handle::WakeHandle;
use crate::wake::Payload96;
use futures_util::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
use serde::{Deserialize, Serialize};
pub const PROTOCOL: &str = "/weirdnet/wake/1";
pub const MAX_FRAME: usize = 2048;
pub const MAX_HANDLES: usize = 8;
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case", tag = "t")]
pub enum ToRelay {
Subscribe {
handles: Vec<WakeHandle>,
},
Deliver {
handle: WakeHandle,
payload: Payload96,
},
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Delivery {
Delivered,
Held,
Offline,
TooMany,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case", tag = "t")]
pub enum FromRelay {
Subscribed {
handles: usize,
keepalive_s: u32,
},
Wake {
handle: WakeHandle,
payload: Payload96,
},
Keepalive,
Delivered {
status: Delivery,
},
Error {
error: String,
},
}
pub async fn write<W: AsyncWrite + Unpin, T: Serialize>(w: &mut W, msg: &T) -> Result<()> {
let body = serde_json::to_vec(msg).map_err(|e| Error::Invalid(e.to_string()))?;
if body.len() > MAX_FRAME {
return Err(Error::Invalid("frame too large".into()));
}
let mut b = (body.len() as u16).to_be_bytes().to_vec();
b.extend(body);
w.write_all(&b).await?;
w.flush().await?;
Ok(())
}
pub async fn read<R: AsyncRead + Unpin, T: for<'de> Deserialize<'de>>(r: &mut R) -> Result<Option<T>> {
let mut len = [0u8; 2];
match r.read_exact(&mut len).await {
Ok(()) => {}
Err(e) if e.kind() == std::io::ErrorKind::UnexpectedEof => return Ok(None),
Err(e) => return Err(e.into()),
}
let n = u16::from_be_bytes(len) as usize;
if n == 0 || n > MAX_FRAME {
return Err(Error::Invalid("bad frame length".into()));
}
let mut body = vec![0u8; n];
r.read_exact(&mut body).await?;
serde_json::from_slice(&body).map(Some).map_err(|e| Error::Invalid(format!("bad frame: {e}")))
}
pub struct Subscription<S> {
io: S,
pub keepalive_s: u32,
}
impl<S: AsyncRead + AsyncWrite + Unpin> Subscription<S> {
pub async fn start(mut io: S, handles: &[WakeHandle]) -> Result<Self> {
if handles.is_empty() || handles.len() > MAX_HANDLES {
return Err(Error::Invalid(format!("subscribe 1 to {MAX_HANDLES} handles")));
}
write(&mut io, &ToRelay::Subscribe { handles: handles.to_vec() }).await?;
match read(&mut io).await? {
Some(FromRelay::Subscribed { keepalive_s, .. }) => Ok(Self { io, keepalive_s }),
Some(FromRelay::Error { error }) => Err(Error::Delivery(error)),
_ => Err(Error::Invalid("unexpected answer to subscribe".into())),
}
}
pub async fn next(&mut self) -> Result<Option<(WakeHandle, Payload96)>> {
loop {
match read(&mut self.io).await? {
None => return Ok(None),
Some(FromRelay::Wake { handle, payload }) => return Ok(Some((handle, payload))),
Some(FromRelay::Keepalive) => continue,
Some(FromRelay::Error { error }) => return Err(Error::Delivery(error)),
Some(_) => return Err(Error::Invalid("unexpected frame".into())),
}
}
}
pub async fn next_frame(&mut self) -> Result<Option<FromRelay>> {
read(&mut self.io).await
}
}
pub async fn deliver<S: AsyncRead + AsyncWrite + Unpin>(mut io: S, handle: &WakeHandle, payload: Payload96) -> Result<Delivery> {
write(&mut io, &ToRelay::Deliver { handle: handle.clone(), payload }).await?;
let r = read(&mut io).await?;
let _ = io.close().await;
match r {
Some(FromRelay::Delivered { status }) => Ok(status),
Some(FromRelay::Error { error }) => Err(Error::Delivery(error)),
_ => Err(Error::Invalid("unexpected answer to deliver".into())),
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn frames_round_trip_and_are_bounded() {
futures_util::FutureExt::now_or_never(async {
let h = WakeHandle::generate();
let p = Payload96::from_slice(&[[1u8].as_slice(), &[7u8; 95]].concat()).unwrap();
let mut buf = Vec::new();
write(&mut buf, &ToRelay::Deliver { handle: h.clone(), payload: p }).await.unwrap();
write(&mut buf, &FromRelay::Keepalive).await.unwrap();
let mut r = futures_util::io::Cursor::new(buf);
assert_eq!(read::<_, ToRelay>(&mut r).await.unwrap(), Some(ToRelay::Deliver { handle: h, payload: p }));
assert_eq!(read::<_, FromRelay>(&mut r).await.unwrap(), Some(FromRelay::Keepalive));
assert_eq!(read::<_, FromRelay>(&mut r).await.unwrap(), None);
let mut big = futures_util::io::Cursor::new([0xffu8, 0xff].to_vec());
assert!(read::<_, FromRelay>(&mut big).await.is_err());
let mut zero = futures_util::io::Cursor::new([0u8, 0].to_vec());
assert!(read::<_, FromRelay>(&mut zero).await.is_err());
let bad = br#"{"t":"deliver","handle":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA","payload":"AA"}"#;
let mut b = (bad.len() as u16).to_be_bytes().to_vec();
b.extend(bad);
assert!(read::<_, ToRelay>(&mut futures_util::io::Cursor::new(b)).await.is_err());
})
.unwrap();
}
}