1use 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#[derive(Debug)]
17pub struct FramedReader<R> {
18 inner: R,
19 decoder: FrameDecoder,
20}
21
22impl<R: AsyncRead + Unpin> FramedReader<R> {
23 pub fn new(inner: R) -> Self {
25 FramedReader {
26 inner,
27 decoder: FrameDecoder::new(),
28 }
29 }
30
31 pub fn decoder(&mut self) -> &mut FrameDecoder {
33 &mut self.decoder
34 }
35
36 pub fn get_mut(&mut self) -> &mut R {
38 &mut self.inner
39 }
40
41 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#[derive(Debug)]
66pub struct FramedWriter<W> {
67 inner: W,
68 encoder: FrameEncoder,
69}
70
71impl<W: AsyncWrite + Unpin> FramedWriter<W> {
72 pub fn new(inner: W) -> Self {
74 FramedWriter {
75 inner,
76 encoder: FrameEncoder::new(),
77 }
78 }
79
80 pub fn encoder(&mut self) -> &mut FrameEncoder {
82 &mut self.encoder
83 }
84
85 pub fn get_mut(&mut self) -> &mut W {
87 &mut self.inner
88 }
89
90 pub fn queue<P: Packet>(&mut self, p: &P) -> Result<(), EncodeError> {
92 self.encoder.write_packet(p)
93 }
94
95 pub fn queue_set<S: PacketSet>(&mut self, p: &S) -> Result<(), EncodeError> {
97 self.encoder.write_set(p)
98 }
99
100 pub fn queue_raw(&mut self, p: &RawPacket) -> Result<(), EncodeError> {
102 self.encoder.write_raw(p)
103 }
104
105 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 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}