rtc-sctp 0.7.0

RTC SCTP 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

use super::{param_type::*, *};

use bytes::{Buf, BufMut, Bytes, BytesMut};
use std::fmt;

#[derive(Debug, Clone, PartialEq)]
pub(crate) struct ParamHeader {
    pub(crate) typ: ParamType,
    pub(crate) value_length: u16,
}

pub(crate) const PARAM_HEADER_LENGTH: usize = 4;

/// String makes paramHeader printable
impl fmt::Display for ParamHeader {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.typ)
    }
}

impl Param for ParamHeader {
    fn header(&self) -> ParamHeader {
        self.clone()
    }

    fn unmarshal(raw: &Bytes) -> Result<Self> {
        if raw.len() < PARAM_HEADER_LENGTH {
            return Err(Error::ErrParamHeaderTooShort);
        }

        let reader = &mut raw.clone();

        let typ: ParamType = reader.get_u16().into();

        let len = reader.get_u16() as usize;
        if len < PARAM_HEADER_LENGTH || raw.len() < len {
            return Err(Error::ErrParamHeaderTooShort);
        }

        Ok(ParamHeader {
            typ,
            value_length: (len - PARAM_HEADER_LENGTH) as u16,
        })
    }

    fn marshal_to(&self, writer: &mut BytesMut) -> Result<usize> {
        writer.put_u16(self.typ.into());
        writer.put_u16(self.value_length + PARAM_HEADER_LENGTH as u16);
        Ok(writer.len())
    }

    fn value_length(&self) -> usize {
        self.value_length as usize
    }

    fn clone_to(&self) -> Box<dyn Param> {
        Box::new(self.clone())
    }

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