dimpl 0.6.2

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

use arrayvec::ArrayVec;
use nom::error::{ErrorKind, ParseError, make_error};
use nom::{Err, IResult, Input, Parser};

/// A combinator that parses items using the provided parser but only collects
/// items that pass a filter predicate. Allows zero matches.
#[inline(always)]
pub fn many0<I, O, E, F, P, const N: usize>(
    mut parser: F,
    predicate: P,
) -> impl FnMut(I) -> IResult<I, ArrayVec<O, N>, E>
where
    I: Clone + Input,
    F: Parser<I, Output = O, Error = E>,
    P: Fn(&O) -> bool,
    E: ParseError<I>,
{
    move |mut i: I| {
        let mut acc = ArrayVec::new();

        loop {
            let len = i.input_len();
            if len == 0 {
                break;
            }

            match parser.parse(i.clone()) {
                Err(Err::Error(_)) => break,
                Err(e) => return Err(e),
                Ok((i1, o)) => {
                    // infinite loop check: the parser must always consume
                    if i1.input_len() == len {
                        return Err(Err::Error(E::from_error_kind(i, ErrorKind::Many0)));
                    }

                    i = i1;
                    // Only collect items that pass the filter
                    if predicate(&o) && acc.try_push(o).is_err() {
                        return Err(Err::Error(E::from_error_kind(i, ErrorKind::Many0)));
                    }
                }
            }
        }

        Ok((i, acc))
    }
}

/// A combinator that parses items using the provided parser but only collects
/// items that pass a filter predicate. Requires at least one item to pass the filter.
#[inline(always)]
pub fn many1<I, O, E, F, P, const N: usize>(
    mut parser: F,
    predicate: P,
) -> impl FnMut(I) -> IResult<I, ArrayVec<O, N>, E>
where
    I: Clone + Input,
    F: Parser<I, Output = O, Error = E>,
    P: Fn(&O) -> bool,
    E: ParseError<I>,
{
    move |mut i: I| {
        let mut acc = ArrayVec::new();
        let original_input = i.clone();

        loop {
            let len = i.input_len();
            if len == 0 {
                break;
            }

            match parser.parse(i.clone()) {
                Err(Err::Error(_)) => break,
                Err(e) => return Err(e),
                Ok((i1, o)) => {
                    // infinite loop check: the parser must always consume
                    if i1.input_len() == len {
                        return Err(Err::Error(E::from_error_kind(i, ErrorKind::Many1)));
                    }

                    i = i1;
                    // Only collect items that pass the filter
                    if predicate(&o) && acc.try_push(o).is_err() {
                        return Err(Err::Error(E::from_error_kind(i, ErrorKind::Many1)));
                    }
                }
            }
        }

        // Require at least one item to pass the filter
        if acc.is_empty() {
            Err(Err::Error(E::from_error_kind(
                original_input,
                ErrorKind::Many1,
            )))
        } else {
            Ok((i, acc))
        }
    }
}

pub fn be_u48<I, E: ParseError<I>>(input: I) -> IResult<I, u64, E>
where
    I: Input<Item = u8>,
{
    let bound: usize = 6;

    if input.input_len() < bound {
        Err(Err::Error(make_error(input, ErrorKind::Eof)))
    } else {
        let mut res = 0u64;

        for byte in input.iter_elements().take(bound) {
            res = (res << 8) + byte as u64;
        }

        Ok((input.take_from(bound), res))
    }
}