Skip to main content

ghast_protocol/
io.rs

1//! Async framed reader and writer over tokio's `AsyncRead` / `AsyncWrite`
2//! (feature `tokio`).
3//!
4//! Use them on the two halves of a connection (e.g. `TcpStream::into_split`). Each half
5//! has its own compression/encryption switches; the connection logic flips both at the
6//! protocol-defined points.
7
8use bytes::Buf;
9use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
10
11use crate::error::{EncodeError, FrameError};
12use crate::frame::{FrameDecoder, FrameEncoder};
13use crate::packet::{Packet, PacketSet, RawPacket};
14
15/// Reads packets from an `AsyncRead`.
16#[derive(Debug)]
17pub struct FramedReader<R> {
18    inner: R,
19    decoder: FrameDecoder,
20}
21
22impl<R: AsyncRead + Unpin> FramedReader<R> {
23    /// Wraps a reader.
24    pub fn new(inner: R) -> Self {
25        FramedReader {
26            inner,
27            decoder: FrameDecoder::new(),
28        }
29    }
30
31    /// The frame decoder (compression, encryption, filter, limits, stats).
32    pub fn decoder(&mut self) -> &mut FrameDecoder {
33        &mut self.decoder
34    }
35
36    /// The underlying reader.
37    pub fn get_mut(&mut self) -> &mut R {
38        &mut self.inner
39    }
40
41    /// Reads the next packet that passes the filter. `Ok(None)` on a clean end of
42    /// stream (no partial frame buffered).
43    ///
44    /// Cancel safe: if the future is dropped, no data is lost.
45    pub async fn read_packet(&mut self) -> Result<Option<RawPacket>, FrameError> {
46        loop {
47            if let Some(p) = self.decoder.next_packet()? {
48                return Ok(Some(p));
49            }
50            let buf = self.decoder.reserve_read();
51            let old = buf.len();
52            let n = self.inner.read_buf(buf).await?;
53            if n == 0 {
54                if self.decoder.buffered() == 0 {
55                    return Ok(None);
56                }
57                return Err(FrameError::Io(std::io::ErrorKind::UnexpectedEof.into()));
58            }
59            self.decoder.commit(old);
60        }
61    }
62}
63
64/// Writes packets to an `AsyncWrite`, batching until [`FramedWriter::flush`].
65#[derive(Debug)]
66pub struct FramedWriter<W> {
67    inner: W,
68    encoder: FrameEncoder,
69}
70
71impl<W: AsyncWrite + Unpin> FramedWriter<W> {
72    /// Wraps a writer.
73    pub fn new(inner: W) -> Self {
74        FramedWriter {
75            inner,
76            encoder: FrameEncoder::new(),
77        }
78    }
79
80    /// The frame encoder (compression, encryption).
81    pub fn encoder(&mut self) -> &mut FrameEncoder {
82        &mut self.encoder
83    }
84
85    /// The underlying writer.
86    pub fn get_mut(&mut self) -> &mut W {
87        &mut self.inner
88    }
89
90    /// Queues a typed packet (nothing is written until [`FramedWriter::flush`]).
91    pub fn queue<P: Packet>(&mut self, p: &P) -> Result<(), EncodeError> {
92        self.encoder.write_packet(p)
93    }
94
95    /// Queues a packet-set value.
96    pub fn queue_set<S: PacketSet>(&mut self, p: &S) -> Result<(), EncodeError> {
97        self.encoder.write_set(p)
98    }
99
100    /// Queues a raw packet.
101    pub fn queue_raw(&mut self, p: &RawPacket) -> Result<(), EncodeError> {
102        self.encoder.write_raw(p)
103    }
104
105    /// Writes everything queued and flushes the writer.
106    ///
107    /// Cancel safe in the sense that bytes already written are removed from the queue;
108    /// a dropped flush can be resumed by calling it again.
109    pub async fn flush(&mut self) -> std::io::Result<()> {
110        let out = self.encoder.out_mut();
111        while out.has_remaining() {
112            let n = self.inner.write_buf(out).await?;
113            if n == 0 {
114                return Err(std::io::ErrorKind::WriteZero.into());
115            }
116        }
117        self.inner.flush().await
118    }
119
120    /// Queues a typed packet and flushes.
121    pub async fn send<P: Packet>(&mut self, p: &P) -> Result<(), FrameError> {
122        self.queue(p)
123            .map_err(|e| FrameError::Io(std::io::Error::other(e)))?;
124        self.flush().await?;
125        Ok(())
126    }
127}
128
129#[cfg(test)]
130mod tests {
131    use super::*;
132    use bytes::Bytes;
133
134    #[tokio::test]
135    async fn duplex_roundtrip() {
136        let (a, b) = tokio::io::duplex(64);
137        let mut w = FramedWriter::new(a);
138        let mut r = FramedReader::new(b);
139        let key = [5u8; 16];
140        w.encoder().set_compression(32);
141        w.encoder().enable_encryption(&key);
142        r.decoder().set_compression(32);
143        r.decoder().enable_encryption(&key);
144        let packets: Vec<RawPacket> = (0..20)
145            .map(|i| RawPacket::new(i, Bytes::from(vec![i as u8; (i * 13) as usize])))
146            .collect();
147        let send = packets.clone();
148        let writer = tokio::spawn(async move {
149            for p in &send {
150                w.queue_raw(p).unwrap();
151            }
152            w.flush().await.unwrap();
153            drop(w);
154        });
155        let mut got = Vec::new();
156        while let Some(p) = r.read_packet().await.unwrap() {
157            got.push(p);
158        }
159        writer.await.unwrap();
160        assert_eq!(got, packets);
161    }
162}