ruknet 0.1.2

The perfect reimplementation of the RakNet protocol in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

use bytes::Bytes;

use crate::reliability::fragment::Reliability;

#[derive(Debug)]
pub enum Datagram {
    Ack {
        arrival_rate: Option<f32>,
        seqs: Vec<u32>,
    },
    Nak {
        seqs: Vec<u32>,
    },
    Packet {
        is_packet_pair: bool,
        is_continuous_send: bool,
        needs_arrival_rate: bool,
        seq: u32,
        fragments: Vec<Fragment>,
    },
}

impl Datagram {
    pub const HEADER_SIZE: usize = 1;
    pub const PACKET_HEADER_SIZE: usize = 3;

    pub const IS_VALID: u8 = 0b1000_0000;
    pub const IS_ACK: u8 = 0b0100_0000;
    pub const IS_NAK: u8 = 0b0010_0000;
    pub const HAS_ARRIVAL_RATE: u8 = 0b0010_0000;
    pub const IS_PACKET_PAIR: u8 = 0b0001_0000;
    pub const IS_CONTINUOUS_SEND: u8 = 0b0000_1000;
    pub const NEEDS_ARRIVAL_RATE: u8 = 0b0000_0100;
}

#[derive(Debug, Clone, PartialEq)]
pub struct Fragment {
    pub reliability: Reliability,
    pub reliable_index: Option<u32>,
    pub sequence_index: Option<u32>,
    pub ordering_info: Option<OrderingInfo>,
    pub split_info: Option<SplitInfo>,
    pub data: Bytes,
}

#[derive(Debug, Clone, PartialEq)]
pub struct OrderingInfo {
    pub index: u32,
    pub channel: u8,
}

#[derive(Debug, Clone, PartialEq)]
pub struct SplitInfo {
    pub size: u32,
    pub id: u16,
    pub index: u32,
}

impl Fragment {
    pub const SPLIT_INFO_SIZE: usize = 10;

    pub const RELIABILITY_MASK: u8 = 0b1110_0000;
    pub const IS_SPLIT: u8 = 0b0001_0000;

    pub fn calc_header_size(&self) -> usize {
        let mut size = 1 + 2;

        if self.reliability.is_reliable() {
            size += 3;
        }
        if self.reliability.is_sequenced() {
            size += 3;
            size += 4;
        } else if self.reliability.is_ordered() {
            size += 4;
        }
        if self.split_info.is_some() {
            size += 10;
        }

        size
    }

    pub fn calc_full_size(&self) -> usize {
        self.calc_header_size() + self.data.len()
    }
}