dimpl 0.7.0

DTLS 1.2/1.3 implementation (Sans‑IO, Sync)
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

use nom::bytes::complete::take;
use nom::error::{Error, ErrorKind};
use nom::number::complete::be_u8;
use nom::{Err, IResult};
use std::fmt;
use std::ops::Deref;

pub struct InvalidLength(&'static str, IdType, usize);

impl fmt::Debug for InvalidLength {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self)
    }
}

impl std::error::Error for InvalidLength {}

impl fmt::Display for InvalidLength {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self.1 {
            IdType::Fixed(len) => write!(
                f,
                "Incorrect fixed ID ({}) length: {} should be {}",
                self.0, self.2, len
            ),
            IdType::Variable(min, max) => write!(
                f,
                "Incorrect variable ID ({}) length: {} <= {} <= {}",
                self.0, min, self.2, max,
            ),
        }
    }
}

#[derive(Clone, Copy, PartialEq, Eq)]
enum IdType {
    #[allow(unused)]
    Fixed(usize),
    Variable(usize, usize),
}

macro_rules! var_array {
    ($name:ident, $min:expr, $max:expr) => {
        #[derive(Clone, Copy)]
        pub struct $name([u8; $max], usize);

        impl $name {
            pub fn try_new(data: &[u8]) -> Result<Self, InvalidLength> {
                #[allow(unused_comparisons)]
                if data.len() < $min || data.len() > $max {
                    return Err(InvalidLength(
                        stringify!($name),
                        IdType::Variable($min, $max),
                        data.len(),
                    ));
                }
                let mut array = [0; $max];
                array[..data.len()].copy_from_slice(data);
                Ok($name(array, data.len()))
            }

            pub fn empty() -> Self {
                if $min > 0 {
                    panic!("{}::empty() is not valid", stringify!($name));
                }
                Self([0; $max], 0)
            }

            pub fn parse(input: &[u8]) -> IResult<&[u8], Self> {
                let (input, len) = be_u8(input)?;
                if len < $min as u8 || len > $max as u8 {
                    return Err(Err::Failure(Error::new(input, ErrorKind::LengthValue)));
                }
                let (input, data) = take(len as usize)(input)?;
                // unwrap() is ok because we check the size above.
                let instance = Self::try_new(data).unwrap();
                Ok((input, instance))
            }
        }

        impl fmt::Debug for $name {
            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                write!(f, "{}", self)
            }
        }

        impl fmt::Display for $name {
            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                write!(f, "{}({:02x?})", stringify!($name), &self.0[..self.1])
            }
        }

        impl PartialEq for $name {
            fn eq(&self, other: &Self) -> bool {
                self.deref() == other.deref()
            }
        }

        impl Eq for $name {}

        impl Deref for $name {
            type Target = [u8];

            fn deref(&self) -> &Self::Target {
                &self.0[..self.1]
            }
        }

        impl<'a> TryFrom<&'a [u8]> for $name {
            type Error = InvalidLength;

            fn try_from(value: &'a [u8]) -> Result<Self, Self::Error> {
                Self::try_new(value)
            }
        }

        impl<'a> TryFrom<&'a str> for $name {
            type Error = InvalidLength;

            fn try_from(value: &'a str) -> Result<Self, Self::Error> {
                Self::try_new(value.as_bytes())
            }
        }
    };
}

var_array!(SessionId, 0, 32);
var_array!(Cookie, 0, 255);