dns-parser-revived 0.10.0

Pure-rust DNS protocol parser library. This does not support network, only raw protocol parser.
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

use crate::{Error, Name};
use byteorder::{BigEndian, ByteOrder};

/// The SOA (Start of Authority) record
#[derive(Debug, Clone, Copy)]
pub struct Record<'a> {
    pub primary_ns: Name<'a>,
    pub mailbox: Name<'a>,
    pub serial: u32,
    pub refresh: u32,
    pub retry: u32,
    pub expire: u32,
    pub minimum_ttl: u32,
}

impl<'a> super::Record<'a> for Record<'a> {
    const TYPE: isize = 6;

    fn parse(rdata: &'a [u8], original: &'a [u8]) -> super::RDataResult<'a> {
        let mut pos = 0;
        let primary_name_server = Name::scan(rdata, original)?;
        pos += primary_name_server.byte_len();
        let mailbox = Name::scan(&rdata[pos..], original)?;
        pos += mailbox.byte_len();
        if rdata[pos..].len() < 20 {
            return Err(Error::WrongRdataLength);
        }
        let record = Record {
            primary_ns: primary_name_server,
            mailbox,
            serial: BigEndian::read_u32(&rdata[pos..(pos + 4)]),
            refresh: BigEndian::read_u32(&rdata[(pos + 4)..(pos + 8)]),
            retry: BigEndian::read_u32(&rdata[(pos + 8)..(pos + 12)]),
            expire: BigEndian::read_u32(&rdata[(pos + 12)..(pos + 16)]),
            minimum_ttl: BigEndian::read_u32(&rdata[(pos + 16)..(pos + 20)]),
        };
        Ok(super::RData::SOA(record))
    }
}

#[cfg(test)]
mod test {

    use crate::Class as C;
    use crate::Opcode::*;
    use crate::QueryClass as QC;
    use crate::QueryType as QT;
    use crate::RData;
    use crate::ResponseCode::NameError;
    use crate::{Header, Packet};

    #[test]
    fn parse_response() {
        let response = b"\x9f\xc5\x85\x83\x00\x01\x00\x00\x00\x01\x00\x00\
                          \x0edlkfjkdjdslfkj\x07youtube\x03com\x00\x00\x01\x00\x01\
                          \xc0\x1b\x00\x06\x00\x01\x00\x00\x2a\x30\x00\x1e\xc0\x1b\
                          \x05admin\xc0\x1b\x77\xed\x2a\x73\x00\x00\x51\x80\x00\x00\
                          \x0e\x10\x00\x00\x3a\x80\x00\x00\x2a\x30";
        let packet = Packet::parse(response).unwrap();
        assert_eq!(
            packet.header,
            Header {
                id: 40901,
                query: false,
                opcode: StandardQuery,
                authoritative: true,
                truncated: false,
                recursion_desired: true,
                recursion_available: true,
                authenticated_data: false,
                checking_disabled: false,
                response_code: NameError,
                questions: 1,
                answers: 0,
                nameservers: 1,
                additional: 0,
            }
        );
        assert_eq!(packet.questions.len(), 1);
        assert_eq!(packet.questions[0].qtype, QT::A);
        assert_eq!(packet.questions[0].qclass, QC::IN);
        assert_eq!(
            &packet.questions[0].qname.to_string()[..],
            "dlkfjkdjdslfkj.youtube.com"
        );
        assert_eq!(packet.answers.len(), 0);

        assert_eq!(packet.nameservers.len(), 1);
        assert_eq!(&packet.nameservers[0].name.to_string()[..], "youtube.com");
        assert_eq!(packet.nameservers[0].cls, C::IN);
        assert!(!packet.nameservers[0].multicast_unique);
        assert_eq!(packet.nameservers[0].ttl, 10800);
        match packet.nameservers[0].data {
            RData::SOA(ref soa_rec) => {
                assert_eq!(&soa_rec.primary_ns.to_string()[..], "youtube.com");
                assert_eq!(&soa_rec.mailbox.to_string()[..], "admin.youtube.com");
                assert_eq!(soa_rec.serial, 2012031603);
                assert_eq!(soa_rec.refresh, 20864);
                assert_eq!(soa_rec.retry, 3600);
                assert_eq!(soa_rec.expire, 14976);
                assert_eq!(soa_rec.minimum_ttl, 10800);
            }
            ref x => panic!("Wrong rdata {:?}", x),
        }
    }
}