Skip to main content

a2s_protocol/transport/
packet_processor.rs

1use std::borrow::Cow;
2use std::collections::HashMap;
3use std::net::SocketAddr;
4
5use crate::transport::{compression};
6use crate::transport::packet::Compression;
7
8use super::packet_assembler::Assembler;
9use super::packet::PacketKind;
10use super::Error;
11
12/// Reassembles fragmented server responses and decompresses compressed packets.
13///
14/// Create one processor for a query session and pass every received UDP datagram
15/// to [`process`](Self::process). The processor keeps incomplete fragments keyed
16/// by source address and packet ID. It does not perform network I/O.
17pub struct PacketProcessor {
18    waiting: HashMap<(SocketAddr, i32), Assembler>
19}
20
21impl PacketProcessor {
22    /// Creates a processor with no pending fragment sequences.
23    pub fn new() -> Self {
24        Self {
25            waiting: HashMap::new()
26        }
27    }
28
29    /// Processes one received UDP datagram.
30    ///
31    /// Returns `Ok(None)` while more fragments are needed. For a complete
32    /// single-packet response, the result borrows from `raw`; assembled or
33    /// decompressed responses are owned. Pass the returned bytes to
34    /// [`crate::parse_payload`] to decode the A2S response.
35    ///
36    /// `addr` should be the datagram's source address. It keeps fragments from
37    /// different servers in separate sequences.
38    ///
39    /// # Errors
40    ///
41    /// Returns an error for an invalid packet header, malformed fragment
42    /// sequence, or failed decompression/checksum validation.
43    pub fn process<'a>(&mut self, addr: SocketAddr, raw: &'a [u8]) -> Result<Option<Cow<'a, [u8]>>, Error> {
44        Ok(match PacketKind::try_from(raw)? {
45            PacketKind::Single => Some(Cow::Borrowed(raw)),
46            PacketKind::Multi(packet) => {
47                let packet_id = packet.id;
48
49                let entry = self.waiting.entry((addr, packet_id)).or_default();
50                let Some((mut payload, compression)) = entry.add_and_try_assemble(packet)? else {
51                    return Ok(None)
52                };
53
54                self.waiting.remove(&(addr, packet_id));
55
56                if let Some(Compression{ size, crc32_sum }) = compression {
57                    payload = compression::decode(&payload, size as usize, crc32_sum as u32)?;
58                }
59
60                Some(Cow::Owned(payload))
61            }
62        })
63    }
64}