a2s-protocol 0.1.0

A protocol core for building A2S server query clients
Documentation
use std::cmp::Ordering;
use crate::transport::packet::{FromUnchecked};
use super::packet::{Compression, MultiPacketId, MultiPacketKind, SourceMultiPacket, MultiPacket};
use super::Error;

#[derive(Default)]
pub struct Assembler {
    fragments: Vec<MultiPacketId>
}

impl Assembler {
    pub fn add_and_try_assemble(&mut self, packet: MultiPacketId) -> Result<Option<(Vec<u8>, Option<Compression>)>, Error> {
        self.add(packet);
        self.try_assemble()
    }

    fn packet_kind(&self) -> Result<Option<MultiPacketKind<'_>>, Error> {
        debug_assert!(self.fragments.len() > 0);

        // see comment in the function
        if let Some(packet) = SourceMultiPacket::as_single_multipacket(&self.fragments[0])?.map(MultiPacketKind::Source) {
            return Ok(Some(packet));
        }

        let [first, second, ..] = self.fragments.as_slice() else {
            return Ok(None);
        };

        Ok(Some(first.kind(second)?))
    }

    fn add(&mut self, packet: MultiPacketId) {
        // we will have some problems if there is for instance, a duplicate packet
        if !self.fragments.contains(&packet) {
            self.fragments.push(packet);
        }
    }

    fn collect<'a, T>(&'a self) -> Result<Option<Vec<MultiPacket<'a, T>>>, Error>
        where
            MultiPacket<'a, T>: FromUnchecked<'a>
        {
            let mut fragments = self.fragments
                .iter()
                .map(MultiPacket::from_unchecked)
                .collect::<Result<Vec<_>, _>>()?;

            fragments.sort_by_key(|f| f.number);
            if !fragments.windows(2).all(|w| w[0].number < w[1].number) {
                return Err(Error::InvalidOrder)
            }

            Ok(Some(fragments))
        }

    fn try_assemble(&self) -> Result<Option<(Vec<u8>, Option<Compression>)>, Error> {
        let Some(kind) = self.packet_kind()? else {
            return Ok(None);
        };

        let current_total = self.fragments.len() as u8;

        match current_total.cmp(&kind.total()) {
            Ordering::Less => return Ok(None),
            Ordering::Greater => return Err(Error::ManyPackets { num: current_total, expected: kind.total() }.into()),
            _ => { }
        }

        match kind {
            MultiPacketKind::Source(_) => {
                let Some(fragments) = self.collect()? else {
                    return Ok(None)
                };

                let info = fragments[0].as_first()?.expect("it follows from successful collection");

                let mut data = Vec::new();
                for fragment in &fragments {
                    data.extend_from_slice(fragment.payload_unchecked(info.is_orangebox())?);
                }

                Ok(Some((data, info.compression)))
            }
            MultiPacketKind::GoldSrc(_) => {
                let Some(fragments) = self.collect()? else {
                    return Ok(None)
                };

                let mut data = Vec::new();
                for fragment in fragments {
                    data.extend_from_slice(fragment.payload());
                }

                Ok(Some((data, None)))
            }
        }
    }
}