laminar/packet/header/
acked_packet_header.rs

1use std::io::Cursor;
2
3use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
4
5use crate::error::Result;
6use crate::net::constants::ACKED_PACKET_HEADER;
7
8use super::{HeaderReader, HeaderWriter};
9
10#[derive(Copy, Clone, Debug)]
11/// This header provides reliability information.
12pub struct AckedPacketHeader {
13    /// This is the sequence number so that we can know where in the sequence of packages this packet belongs.
14    pub seq: u16,
15    // This is the last acknowledged sequence number.
16    ack_seq: u16,
17    // This is an bitfield of all last 32 acknowledged packages
18    ack_field: u32,
19}
20
21impl AckedPacketHeader {
22    /// When we compose packet headers, the local sequence becomes the sequence number of the packet, and the remote sequence becomes the ack.
23    /// The ack bitfield is calculated by looking into a queue of up to 33 packets, containing sequence numbers in the range [remote sequence - 32, remote sequence].
24    /// We set bit n (in [1,32]) in ack bits to 1 if the sequence number remote sequence - n is in the received queue.
25    pub fn new(seq_num: u16, last_seq: u16, bit_field: u32) -> AckedPacketHeader {
26        AckedPacketHeader {
27            seq: seq_num,
28            ack_seq: last_seq,
29            ack_field: bit_field,
30        }
31    }
32
33    /// Returns the sequence number from this packet.
34    #[allow(dead_code)]
35    pub fn sequence(&self) -> u16 {
36        self.seq
37    }
38
39    /// Returns bit field of all last 32 acknowledged packages.
40    pub fn ack_field(&self) -> u32 {
41        self.ack_field
42    }
43
44    /// Returns last acknowledged sequence number.
45    pub fn ack_seq(&self) -> u16 {
46        self.ack_seq
47    }
48}
49
50impl HeaderWriter for AckedPacketHeader {
51    type Output = Result<()>;
52
53    fn parse(&self, buffer: &mut Vec<u8>) -> Self::Output {
54        buffer.write_u16::<BigEndian>(self.seq)?;
55        buffer.write_u16::<BigEndian>(self.ack_seq)?;
56        buffer.write_u32::<BigEndian>(self.ack_field)?;
57        Ok(())
58    }
59}
60
61impl HeaderReader for AckedPacketHeader {
62    type Header = Result<AckedPacketHeader>;
63
64    fn read(rdr: &mut Cursor<&[u8]>) -> Self::Header {
65        let seq = rdr.read_u16::<BigEndian>()?;
66        let ack_seq = rdr.read_u16::<BigEndian>()?;
67        let ack_field = rdr.read_u32::<BigEndian>()?;
68
69        Ok(AckedPacketHeader {
70            seq,
71            ack_seq,
72            ack_field,
73        })
74    }
75
76    fn size() -> u8 {
77        ACKED_PACKET_HEADER
78    }
79}
80
81#[cfg(test)]
82mod tests {
83    use std::io::Cursor;
84
85    use crate::net::constants::ACKED_PACKET_HEADER;
86    use crate::packet::header::{AckedPacketHeader, HeaderReader, HeaderWriter};
87
88    #[test]
89    fn serialize() {
90        let mut buffer = Vec::new();
91        let header = AckedPacketHeader::new(1, 2, 3);
92        assert![header.parse(&mut buffer).is_ok()];
93
94        assert_eq!(buffer[1], 1);
95        assert_eq!(buffer[3], 2);
96        assert_eq!(buffer[7], 3);
97        assert_eq!(buffer.len() as u8, AckedPacketHeader::size());
98    }
99
100    #[test]
101    fn deserialize() {
102        let buffer = vec![0, 1, 0, 2, 0, 0, 0, 3];
103
104        let mut cursor = Cursor::new(buffer.as_slice());
105
106        let header = AckedPacketHeader::read(&mut cursor).unwrap();
107
108        assert_eq!(header.sequence(), 1);
109        assert_eq!(header.ack_seq(), 2);
110        assert_eq!(header.ack_field(), 3);
111    }
112
113    #[test]
114    fn size() {
115        assert_eq!(AckedPacketHeader::size(), ACKED_PACKET_HEADER);
116    }
117}
laminar/packet/header/acked_packet_header.rs

laminar/packet/header/
acked_packet_header.rs
