turn-server 4.0.1

A pure rust-implemented turn server.
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

use bytes::{BufMut, BytesMut};

use super::Error;

/// The ChannelData Message
///
/// The ChannelData message is used to carry application data between the
/// client and the server.
///
/// The Channel Number field specifies the number of the channel on which
/// the data is traveling, and thus, the address of the peer that is
/// sending or is to receive the data.
///
/// The Length field specifies the length in bytes of the application
/// data field (i.e., it does not include the size of the ChannelData
/// header).  Note that 0 is a valid length.
///
/// The Application Data field carries the data the client is trying to
/// send to the peer, or that the peer is sending to the client.
pub struct ChannelData<'a> {
    bytes: &'a [u8],
    number: u16,
}

impl<'a> ChannelData<'a> {
    pub fn new(number: u16, bytes: &'a [u8]) -> Self {
        Self { number, bytes }
    }

    pub fn number(&self) -> u16 {
        self.number
    }

    pub fn bytes(&self) -> &'a [u8] {
        self.bytes
    }

    /// # Test
    ///
    /// ```
    /// use bytes::{BufMut, BytesMut};
    /// use turn_server::codec::channel_data::ChannelData;
    ///
    /// let data: [u8; 4] = [0x40, 0x00, 0x00, 0x40];
    /// let mut bytes = BytesMut::with_capacity(1500);
    ///
    /// ChannelData::new(16384, &data[..]).encode(&mut bytes);
    ///
    /// let size = ChannelData::message_size(&bytes[..], false).unwrap();
    ///
    /// assert_eq!(size, 8);
    /// ```
    pub fn message_size(bytes: &[u8], is_tcp: bool) -> Result<usize, Error> {
        if bytes.len() < 4 {
            return Err(Error::InvalidInput);
        }

        if !(1..3).contains(&(bytes[0] >> 6)) {
            return Err(Error::InvalidInput);
        }

        let mut size = (u16::from_be_bytes(bytes[2..4].try_into()?) + 4) as usize;
        if is_tcp && !size.is_multiple_of(4) {
            size += 4 - (size % 4);
        }

        Ok(size)
    }

    /// # Test
    ///
    /// ```
    /// use bytes::{BufMut, BytesMut};
    /// use turn_server::codec::channel_data::ChannelData;
    ///
    /// let data: [u8; 4] = [0x40, 0x00, 0x00, 0x40];
    /// let mut bytes = BytesMut::with_capacity(1500);
    ///
    /// ChannelData::new(16384, &data[..]).encode(&mut bytes);
    ///
    /// let ret = ChannelData::decode(&bytes[..]).unwrap();
    ///
    /// assert_eq!(ret.number(), 16384);
    /// assert_eq!(ret.bytes(), &data[..]);
    /// ```
    pub fn encode(self, bytes: &mut BytesMut) {
        bytes.clear();
        bytes.put_u16(self.number);
        bytes.put_u16(self.bytes.len() as u16);
        bytes.extend_from_slice(self.bytes);
    }

    /// # Test
    ///
    /// ```
    /// use bytes::{BufMut, BytesMut};
    /// use turn_server::codec::channel_data::ChannelData;
    ///
    /// let data: [u8; 4] = [0x40, 0x00, 0x00, 0x40];
    /// let mut bytes = BytesMut::with_capacity(1500);
    ///
    /// ChannelData::new(16384, &data[..]).encode(&mut bytes);
    ///
    /// let ret = ChannelData::decode(&bytes[..]).unwrap();
    ///
    /// assert_eq!(ret.number(), 16384);
    /// assert_eq!(ret.bytes(), &data[..]);
    /// ```
    pub fn decode(bytes: &'a [u8]) -> Result<Self, Error> {
        if bytes.len() < 4 {
            return Err(Error::InvalidInput);
        }

        let number = u16::from_be_bytes(bytes[..2].try_into()?);
        if !(0x4000..0xFFFF).contains(&number) {
            return Err(Error::InvalidInput);
        }

        let size = u16::from_be_bytes(bytes[2..4].try_into()?) as usize;
        if size > bytes.len() - 4 {
            return Err(Error::InvalidInput);
        }

        Ok(Self {
            bytes: &bytes[4..],
            number,
        })
    }
}