dns-message-parser 0.2.0

Libary to encode and decode DNS packets
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 bytes::BytesMut;

use crate::{Class, RData};

use super::{EncodeData, EncodeError, EncodeResult};

use std::collections::HashMap;

impl RData {
    pub fn encode(
        &self,
        bytes: &mut BytesMut,
        class: &Class,
        ttl: u32,
        compression: &mut HashMap<String, usize>,
    ) -> EncodeResult {
        let mut encode_data = EncodeData::new(bytes, class, ttl);
        match self {
            RData::A(ipv4_addr) => encode_data.encode_a(ipv4_addr)?,
            RData::NS(ns_d_name) => encode_data.encode_ns(ns_d_name, compression)?,
            RData::MD(mad_name) => encode_data.encode_md(mad_name, compression)?,
            RData::MF(mad_name) => encode_data.encode_mf(mad_name, compression)?,
            RData::CNAME(c_name) => encode_data.encode_cname(c_name, compression)?,
            RData::SOA(m_name, r_name, serial, refresh, retry, expire, min_ttl) => encode_data
                .encode_soa(
                    m_name,
                    r_name,
                    *serial,
                    *refresh,
                    *retry,
                    *expire,
                    *min_ttl,
                    compression,
                )?,
            RData::MB(mad_name) => encode_data.encode_mb(mad_name, compression)?,
            RData::MG(mgm_name) => encode_data.encode_mg(mgm_name, compression)?,
            RData::MR(new_name) => encode_data.encode_mr(new_name, compression)?,
            RData::NULL(vec) => encode_data.encode_null(vec)?,
            RData::WKS(ipv4_addr, protocol, bit_map) => {
                encode_data.encode_wks(ipv4_addr, *protocol, bit_map)?
            }
            RData::PTR(ptr_d_name) => encode_data.encode_ptr(ptr_d_name, compression)?,
            RData::HINFO(cpu, os) => encode_data.encode_hinfo(cpu, os)?,
            RData::MINFO(r_mail_bx, e_mail_bx) => {
                encode_data.encode_minfo(r_mail_bx, e_mail_bx, compression)?
            }
            RData::MX(preference, exchange) => {
                encode_data.encode_mx(*preference, exchange, compression)?
            }
            RData::TXT(string) => encode_data.encode_txt(string)?,
            RData::RP(mbox_dname, txt_dname) => {
                encode_data.encode_rp(mbox_dname, txt_dname, compression)?
            }
            RData::AFSDB(subtype, hostname) => {
                encode_data.encode_afsdb(subtype, hostname, compression)?
            }
            RData::X25(psdn_address) => encode_data.encode_x25(psdn_address)?,
            RData::ISDN(isdn_address, sa) => encode_data.encode_isdn(isdn_address, sa)?,
            RData::RT(preference, intermediate_host) => {
                encode_data.encode_rt(*preference, intermediate_host, compression)?
            }
            RData::NSAP(nsap) => encode_data.encode_nsap(nsap)?,
            // TODO NSAP-PTR
            // TODO SIG
            // TODO KEY
            RData::PX(preference, map_822, map_x_400) => {
                encode_data.encode_px(*preference, map_822, map_x_400, compression)?
            }
            RData::GPOS(longitude, latitude, altitude) => {
                encode_data.encode_gpos(longitude, latitude, altitude)?
            }
            RData::AAAA(ipv6_addr) => encode_data.encode_aaaa(ipv6_addr)?,
            RData::LOC(version, size, horiz_pre, vert_pre, latitube, longitube, altitube) => {
                encode_data.encode_loc(
                    *version, *size, *horiz_pre, *vert_pre, *latitube, *longitube, *altitube,
                )?
            }
            // TODO NXT
            RData::EID(endpoint_identifier) => encode_data.encode_eid(endpoint_identifier)?,
            RData::NIMLOC(nimrod_locator) => encode_data.encode_nimloc(nimrod_locator)?,
            RData::SRV(priority, weight, port, target) => {
                encode_data.encode_srv(*priority, *weight, *port, target, compression)?
            }
            // TODO ATMA
            // TODO NAPTR
            RData::KX(preference, exchanger) => {
                encode_data.encode_kx(*preference, exchanger, compression)?
            }
            // TODO CERT
            // TODO A6
            RData::DNAME(target) => encode_data.encode_dname(target, compression)?,
            // TODO SINK
            RData::OPT => encode_data.encode_opt()?,
            // TODO APL
            // TODO DS
            RData::SSHFP(algorithm, type_, fingerprint) => {
                encode_data.encode_sshfp(algorithm, type_, fingerprint)?
            }
            // TODO IPSECKEY
            // TODO
            _ => return Err(EncodeError::NotYetImplemented),
        }

        encode_data.add_rdata()
    }
}