rlibdns 0.1.211

Rust DNS Library
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 std::fmt;
use std::fmt::Formatter;

#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
pub enum OptCodes {
    Llq,
    Ul,
    Nsid,
    Dau,
    Dhu,
    N3u,
    Ecs,
    Expire,
    Cookie,
    TcpKeepalive,
    Padding,
    Chain,
    KeyTag,
    Ede,
    DnsSecTrustedKey,
    DnsSecValidated,
    AdaptiveDnsDiscovery,
    DoH,
    MultiUserClientSubnet
}

impl OptCodes {

    pub fn get_code(&self) -> u16 {
        match self {
            Self::Llq => 1,
            Self::Ul => 2,
            Self::Nsid => 3,
            Self::Dau => 5,
            Self::Dhu => 6,
            Self::N3u => 7,
            Self::Ecs => 8,
            Self::Expire => 9,
            Self::Cookie => 10,
            Self::TcpKeepalive => 11,
            Self::Padding => 12,
            Self::Chain => 13,
            Self::KeyTag => 14,
            Self::Ede => 15,
            Self::DnsSecTrustedKey => 17,
            Self::DnsSecValidated => 18,
            Self::AdaptiveDnsDiscovery => 19,
            Self::DoH => 20,
            Self::MultiUserClientSubnet => 21
        }
    }
}

#[derive(Debug, Clone, Eq, PartialEq)]
pub struct OptCodeParseError(u16);

impl fmt::Display for OptCodeParseError {

    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        write!(f, "unknown opt code: {}", self.0)
    }
}

impl TryFrom<u16> for OptCodes {

    type Error = OptCodeParseError;

    fn try_from(v: u16) -> Result<Self, Self::Error> {
        Ok(match v {
            1 => Self::Llq,
            2 => Self::Ul,
            3 => Self::Nsid,
            5 => Self::Dau,
            6 => Self::Dhu,
            7 => Self::N3u,
            8 => Self::Ecs,
            9 => Self::Expire,
            10 => Self::Cookie,
            11 => Self::TcpKeepalive,
            12 => Self::Padding,
            13 => Self::Chain,
            14 => Self::KeyTag,
            15 => Self::Ede,
            17 => Self::DnsSecTrustedKey,
            18 => Self::DnsSecValidated,
            19 => Self::AdaptiveDnsDiscovery,
            20 => Self::DoH,
            21 => Self::MultiUserClientSubnet,
            _  => return Err(OptCodeParseError(v))
        })
    }
}

impl fmt::Display for OptCodes {

    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        write!(f, "{}", match self {
            Self::Llq => "LLQ",
            Self::Ul => "UL",
            Self::Nsid => "NSID",
            Self::Dau => "DAU",
            Self::Dhu => "DHU",
            Self::N3u => "N3U",
            Self::Ecs => "ECS",
            Self::Expire => "EXPIRE",
            Self::Cookie => "COOKIE",
            Self::TcpKeepalive => "TCP_KEEP_ALIVE",
            Self::Padding => "PADDING",
            Self::Chain => "CHAIN",
            Self::KeyTag => "KEYTAG",
            Self::Ede => "EDE",
            Self::DnsSecTrustedKey => "DNSSEC_TRUSTED_KEY",
            Self::DnsSecValidated => "DNSSEC_VALIDATED",
            Self::AdaptiveDnsDiscovery => "ADAPTIVE_DNS_DISCOVERY",
            Self::DoH => "DOH",
            Self::MultiUserClientSubnet => "MULTI_USER_CLIENT_SUBNET"
        })
    }
}