sctp-proto 0.9.1

A pure Rust implementation of SCTP in Sans-IO style
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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

use super::{chunk_header::*, chunk_type::*, *};

///chunkSelectiveAck represents an SCTP Chunk of type SACK
///
///This chunk is sent to the peer endpoint to acknowledge received DATA
///chunks and to inform the peer endpoint of gaps in the received
///subsequences of DATA chunks as represented by their TSNs.
///0                   1                   2                   3
///0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
///+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
///|   Type = 3    |Chunk  Flags   |      Chunk Length             |
///+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
///|                      Cumulative TSN Ack                       |
///+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
///|          Advertised Receiver Window Credit (a_rwnd)           |
///+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
///| Number of Gap Ack Blocks = N  |  Number of Duplicate TSNs = X |
///+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
///|  Gap Ack Block #1 Start       |   Gap Ack Block #1 End        |
///+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
///|                                                               |
///|                              ...                              |
///|                                                               |
///+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
///|   Gap Ack Block #N Start      |  Gap Ack Block #N End         |
///+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
///|                       Duplicate TSN 1                         |
///+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
///|                                                               |
///|                              ...                              |
///|                                                               |
///+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
///|                       Duplicate TSN X                         |
///+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
#[derive(Debug, Default, Copy, Clone)]
pub(crate) struct GapAckBlock {
    pub(crate) start: u16,
    pub(crate) end: u16,
}

/// makes gapAckBlock printable
impl fmt::Display for GapAckBlock {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{} - {}", self.start, self.end)
    }
}

#[derive(Default, Debug)]
pub(crate) struct ChunkSelectiveAck {
    pub(crate) cumulative_tsn_ack: u32,
    pub(crate) advertised_receiver_window_credit: u32,
    pub(crate) gap_ack_blocks: Vec<GapAckBlock>,
    pub(crate) duplicate_tsn: Vec<u32>,
}

/// makes chunkSelectiveAck printable
impl fmt::Display for ChunkSelectiveAck {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let mut res = format!(
            "SACK cumTsnAck={} arwnd={} dupTsn={:?}",
            self.cumulative_tsn_ack, self.advertised_receiver_window_credit, self.duplicate_tsn
        );

        for gap in &self.gap_ack_blocks {
            res += format!("\n gap ack: {}", gap).as_str();
        }

        write!(f, "{}", res)
    }
}

pub(crate) const SELECTIVE_ACK_HEADER_SIZE: usize = 12;

impl Chunk for ChunkSelectiveAck {
    fn header(&self) -> ChunkHeader {
        ChunkHeader {
            typ: CT_SACK,
            flags: 0,
            value_length: self.value_length() as u16,
        }
    }

    fn unmarshal(raw: &Bytes) -> Result<Self> {
        let header = ChunkHeader::unmarshal(raw)?;

        if header.typ != CT_SACK {
            return Err(Error::ErrChunkTypeNotSack);
        }

        if header.value_length() < SELECTIVE_ACK_HEADER_SIZE {
            return Err(Error::ErrSackSizeNotLargeEnoughInfo);
        }

        let reader = &mut raw.slice(CHUNK_HEADER_SIZE..CHUNK_HEADER_SIZE + header.value_length());

        let cumulative_tsn_ack = reader.get_u32();
        let advertised_receiver_window_credit = reader.get_u32();
        let gap_ack_blocks_len = reader.get_u16() as usize;
        let duplicate_tsn_len = reader.get_u16() as usize;

        // The reader is bounded by header.value_length(), so we
        // must check against that, not raw.len() which may include
        // subsequent chunks.
        if header.value_length()
            < SELECTIVE_ACK_HEADER_SIZE + (4 * gap_ack_blocks_len + 4 * duplicate_tsn_len)
        {
            return Err(Error::ErrSackSizeNotLargeEnoughInfo);
        }

        let mut gap_ack_blocks = vec![];
        let mut duplicate_tsn = vec![];
        for _ in 0..gap_ack_blocks_len {
            let start = reader.get_u16();
            let end = reader.get_u16();
            gap_ack_blocks.push(GapAckBlock { start, end });
        }
        for _ in 0..duplicate_tsn_len {
            duplicate_tsn.push(reader.get_u32());
        }

        Ok(ChunkSelectiveAck {
            cumulative_tsn_ack,
            advertised_receiver_window_credit,
            gap_ack_blocks,
            duplicate_tsn,
        })
    }

    fn marshal_to(&self, writer: &mut BytesMut) -> Result<usize> {
        self.header().marshal_to(writer)?;

        writer.put_u32(self.cumulative_tsn_ack);
        writer.put_u32(self.advertised_receiver_window_credit);
        writer.put_u16(self.gap_ack_blocks.len() as u16);
        writer.put_u16(self.duplicate_tsn.len() as u16);
        for g in &self.gap_ack_blocks {
            writer.put_u16(g.start);
            writer.put_u16(g.end);
        }
        for t in &self.duplicate_tsn {
            writer.put_u32(*t);
        }

        Ok(writer.len())
    }

    fn check(&self) -> Result<()> {
        Ok(())
    }

    fn value_length(&self) -> usize {
        SELECTIVE_ACK_HEADER_SIZE + self.gap_ack_blocks.len() * 4 + self.duplicate_tsn.len() * 4
    }

    fn as_any(&self) -> &(dyn Any + Send + Sync) {
        self
    }
}