Skip to main content

rtc_dtls/handshake/
handshake_header.rs

1use super::*;
2
3use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
4use std::io::{Read, Write};
5
6// msg_len for Handshake messages assumes an extra 12 bytes for
7// sequence, Fragment and version information
8pub(crate) const HANDSHAKE_HEADER_LENGTH: usize = 12;
9
10#[derive(Copy, Clone, PartialEq, Eq, Debug, Default)]
11/// The header on every handshake message: type, length, message sequence, and the fragment
12/// offset and length that let one message span datagrams.
13pub struct HandshakeHeader {
14    pub(crate) handshake_type: HandshakeType,
15    pub(crate) length: u32, // uint24 in spec
16    pub(crate) message_sequence: u16,
17    pub(crate) fragment_offset: u32, // uint24 in spec
18    pub(crate) fragment_length: u32, // uint24 in spec
19}
20
21impl HandshakeHeader {
22    /// The encoded size of this message in bytes.
23    pub fn size(&self) -> usize {
24        1 + 3 + 2 + 3 + 3
25    }
26
27    /// Encodes this message to `writer`.
28    ///
29    /// # Errors
30    ///
31    /// Fails on a write error, or if a field exceeds the length its wire format allows.
32    pub fn marshal<W: Write>(&self, writer: &mut W) -> Result<()> {
33        writer.write_u8(self.handshake_type as u8)?;
34        writer.write_u24::<BigEndian>(self.length)?;
35        writer.write_u16::<BigEndian>(self.message_sequence)?;
36        writer.write_u24::<BigEndian>(self.fragment_offset)?;
37        writer.write_u24::<BigEndian>(self.fragment_length)?;
38
39        Ok(writer.flush()?)
40    }
41
42    /// Decodes one of these messages from `reader`.
43    ///
44    /// # Errors
45    ///
46    /// Fails if `reader` is truncated or its contents are not a valid encoding.
47    pub fn unmarshal<R: Read>(reader: &mut R) -> Result<Self> {
48        let handshake_type = reader.read_u8()?.into();
49        let length = reader.read_u24::<BigEndian>()?;
50        let message_sequence = reader.read_u16::<BigEndian>()?;
51        let fragment_offset = reader.read_u24::<BigEndian>()?;
52        let fragment_length = reader.read_u24::<BigEndian>()?;
53
54        Ok(HandshakeHeader {
55            handshake_type,
56            length,
57            message_sequence,
58            fragment_offset,
59            fragment_length,
60        })
61    }
62}