torrentdht 0.1.1

DHT discovery with mTLS handshake handoff; optional BitTorrent when the host opts in
Documentation
//! Bidirectional MSE stream (RC4 or plaintext) over TCP or uTP.

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)
    }
}