use std::pin::Pin;
use std::task::{Context, Poll};
use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
use crate::error::Result;
use crate::mse::carrier::MseCarrier;
use crate::mse::handshake::CryptoSelect;
use crate::mse::rc4::Rc4;
pub struct MseStream {
inner: MseCarrier,
select: CryptoSelect,
enc: Option<Rc4>,
dec: Option<Rc4>,
}
impl MseStream {
pub(crate) fn new(
inner: MseCarrier,
select: CryptoSelect,
enc: Option<Rc4>,
dec: Option<Rc4>,
) -> Self {
Self {
inner,
select,
enc,
dec,
}
}
pub fn crypto_select(&self) -> CryptoSelect {
self.select
}
pub async fn read_exact(&mut self, buf: &mut [u8]) -> Result<()> {
self.inner.read_exact(buf).await?;
if let Some(dec) = &mut self.dec {
dec.process(buf);
}
Ok(())
}
pub async fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
let n = self.inner.read(buf).await?;
if let Some(dec) = &mut self.dec {
dec.process(&mut buf[..n]);
}
Ok(n)
}
pub async fn write_all(&mut self, buf: &[u8]) -> Result<()> {
if let Some(enc) = &mut self.enc {
let mut tmp = buf.to_vec();
enc.process(&mut tmp);
self.inner.write_all(&tmp).await
} else {
self.inner.write_all(buf).await
}
}
}
impl AsyncRead for MseStream {
fn poll_read(
mut self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &mut ReadBuf<'_>,
) -> Poll<std::io::Result<()>> {
let filled_before = buf.filled().len();
match Pin::new(&mut self.inner).poll_read(cx, buf) {
Poll::Ready(Ok(())) => {
if let Some(dec) = &mut self.dec {
let filled = buf.filled_mut();
if filled.len() > filled_before {
dec.process(&mut filled[filled_before..]);
}
}
Poll::Ready(Ok(()))
}
other => other,
}
}
}
impl AsyncWrite for MseStream {
fn poll_write(
mut self: Pin<&mut Self>,
cx: &mut Context<'_>,
data: &[u8],
) -> Poll<std::io::Result<usize>> {
if self.enc.is_none() {
return Pin::new(&mut self.inner).poll_write(cx, data);
}
let mut tmp = data.to_vec();
if let Some(enc) = &mut self.enc {
enc.process(&mut tmp);
}
match Pin::new(&mut self.inner).poll_write(cx, &tmp) {
Poll::Ready(Ok(n)) if n == tmp.len() => Poll::Ready(Ok(data.len())),
Poll::Ready(Ok(_)) => Poll::Ready(Err(std::io::Error::other(
"MSE RC4 requires full-buffer writes",
))),
Poll::Ready(Err(err)) => Poll::Ready(Err(err)),
Poll::Pending => Poll::Ready(Err(std::io::Error::new(
std::io::ErrorKind::WouldBlock,
"MSE RC4 poll_write would block; use write_all",
))),
}
}
fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
Pin::new(&mut self.inner).poll_flush(cx)
}
fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
Pin::new(&mut self.inner).poll_shutdown(cx)
}
}