peel-ip 0.2.0

Packet parsing for the Internet Protocol Suite
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

//! Network Time Protocol related packet processing
use prelude::*;

/// The UDP parser
pub struct NtpParser;

impl Parsable<PathIp> for NtpParser {

    /// Parse a `NtpPacket` from an `&[u8]`
    fn parse<'a>(&mut self,
                 input: &'a [u8],
                 result: Option<&ParserResultVec>,
                 _: Option<&mut PathIp>)
                 -> IResult<&'a [u8], ParserResult> {
        do_parse!(input,
            // Check the transport protocol from the parent parser (UDP)
            expr_opt!(match result {
                Some(vector) => {
                    match vector.last() {
                        // Check the parent node for the correct transport protocol
                        Some(ref any) => if let Some(_) = any.downcast_ref::<UdpPacket>() {
                            Some(())
                        } else {
                            None
                        },

                        // Previous result found, but not correct parent
                        _ => None,
                    }
                },
                // Parse also if no result is given, for testability
                None => Some(()),
            }) >>

            b0: bits!(tuple!(take_bits!(u8, 2),
                             take_bits!(u8, 3),
                             take_bits!(u8, 3))) >>
            st: be_u8 >>
            pl: be_i8 >>
            pr: be_i8 >>
            rde: be_u32 >>
            rdi: be_u32 >>
            rid: be_u32 >>
            tsr: be_u64 >>
            tso: be_u64 >>
            tsv: be_u64 >>
            tsx: be_u64 >>
            auth: opt!(complete!(pair!(be_u32,
                                 map!(take!(16), Vec::from)))) >>

            (Box::new(NtpPacket {
                li: b0.0,
                version: b0.1,
                mode: b0.2,
                stratum: st,
                poll: pl,
                precision: pr,
                root_delay: rde,
                root_dispersion: rdi,
                ref_id: rid,
                ts_ref: tsr,
                ts_orig: tso,
                ts_recv: tsv,
                ts_xmit: tsx,
                auth: auth,
            }))
        )
    }
}

impl fmt::Display for NtpParser {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "NTP")
    }
}

#[derive(Debug, Eq, PartialEq)]
/// Representation of a Network Time Protocol packet
pub struct NtpPacket {
    /// Leap Indicator (2 Bit)
    /// This field is used to warn of an impending leap second
    pub li: u8,

    /// NTP version number (3 Bit)
    pub version: u8,

    /// Mode (3 Bit)
    pub mode: u8,

    /// Stratum level of the local clock
    pub stratum: u8,

    /// The maximum interval between messages in seconds to the nearest power of two
    pub poll: i8,

    /// Precision of the local clock in seconds to the nearest power of two
    pub precision: i8,

    /// The total round trip delay to the primary reference source, in seconds with the fraction
    /// point between bits 15 and 16. Positive and negative values are valid
    pub root_delay: u32,

    /// The maximum error relative to the primary reference source in seconds with the fraction
    /// point between bits 15 and 16. Only positive values greater than zero are valid
    pub root_dispersion: u32,

    /// Reference clock identifier. Used to identify the particular reference clock.
    pub ref_id: u32,

    /// Reference timestamp. The local time at which the local clock was last set or corrected.
    pub ts_ref: u64,

    /// Originate timestamp. The local time when the client sent the request.
    pub ts_orig: u64,

    /// Receive timestamp. The local time when the request was received by the server.
    pub ts_recv: u64,

    /// Transmit timestamp. The local time when the reply was sent from the server.
    pub ts_xmit: u64,

    /// Authenticator. (0 or 96 Bit) See section 7.5 of [RFC5905] and [RFC7822]
    pub auth: Option<(u32, Vec<u8>)>,
}