domain/resolv/lookup/
addr.rs

Help
1//! Looking up host names for addresses.
2
3use crate::base::iana::Rtype;
4use crate::base::message::RecordIter;
5use crate::base::name::{Dname, DnameBuilder, ParsedDname};
6use crate::rdata::Ptr;
7use crate::resolv::resolver::Resolver;
8use octseq::octets::Octets;
9use std::io;
10use std::net::IpAddr;
11use std::str::FromStr;
12
13//------------ Octets128 -----------------------------------------------------
14
15type Octets128 = octseq::array::Array<128>;
16
17//------------ lookup_addr ---------------------------------------------------
18
19/// Resolves the host names of an IP address.
20///
21/// The function will query DNS using the resolver represented by `resolv`.
22/// It will query DNS only and not consider any other database the system
23/// may have.
24///
25/// The value returned upon success can be turned into an iterator over
26/// host names via its `iter()` method. This is due to lifetime issues.
27pub async fn lookup_addr<R: Resolver>(
28    resolv: &R,
29    addr: IpAddr,
30) -> Result<FoundAddrs<R>, io::Error> {
31    let name = dname_from_addr(addr);
32    resolv.query((name, Rtype::Ptr)).await.map(FoundAddrs)
33}
34
35//------------ FoundAddrs ----------------------------------------------------
36
37/// The success type of the `lookup_addr()` function.
38///
39/// The only purpose of this type is to return an iterator over host names
40/// via its `iter()` method.
41pub struct FoundAddrs<R: Resolver>(R::Answer);
42
43impl<R: Resolver> FoundAddrs<R> {
44    /// Returns an iterator over the host names.
45    pub fn iter(&self) -> FoundAddrsIter<'_, R::Octets>
46    where
47        R::Octets: Octets,
48    {
49        FoundAddrsIter {
50            name: self.0.as_ref().canonical_name(),
51            answer: {
52                self.0
53                    .as_ref()
54                    .answer()
55                    .ok()
56                    .map(|sec| sec.limit_to::<Ptr<_>>())
57            },
58        }
59    }
60}
61
62impl<'a, R: Resolver> IntoIterator for &'a FoundAddrs<R>
63where
64    R::Octets: Octets,
65{
66    type Item = ParsedDname<<<R as Resolver>::Octets as Octets>::Range<'a>>;
67    type IntoIter = FoundAddrsIter<'a, R::Octets>;
68
69    fn into_iter(self) -> Self::IntoIter {
70        self.iter()
71    }
72}
73
74//------------ FoundAddrsIter ------------------------------------------------
75
76/// An iterator over host names returned by address lookup.
77pub struct FoundAddrsIter<'a, Octs: Octets> {
78    name: Option<ParsedDname<Octs::Range<'a>>>,
79    answer: Option<RecordIter<'a, Octs, Ptr<ParsedDname<Octs::Range<'a>>>>>,
80}
81
82impl<'a, Octs: Octets> Iterator for FoundAddrsIter<'a, Octs> {
83    type Item = ParsedDname<Octs::Range<'a>>;
84
85    #[allow(clippy::while_let_on_iterator)]
86    fn next(&mut self) -> Option<Self::Item> {
87        let name = self.name.as_ref()?;
88        let answer = self.answer.as_mut()?;
89        while let Some(Ok(record)) = answer.next() {
90            if record.owner() == name {
91                return Some(record.into_data().into_ptrdname());
92            }
93        }
94        None
95    }
96}
97
98//------------ Helper Functions ---------------------------------------------
99
100/// Translates an IP address into a domain name.
101fn dname_from_addr(addr: IpAddr) -> Dname<Octets128> {
102    match addr {
103        IpAddr::V4(addr) => {
104            let octets = addr.octets();
105            Dname::from_str(&format!(
106                "{}.{}.{}.{}.in-addr.arpa.",
107                octets[3], octets[2], octets[1], octets[0]
108            ))
109            .unwrap()
110        }
111        IpAddr::V6(addr) => {
112            let mut res = DnameBuilder::<Octets128>::new();
113            for &item in addr.octets().iter().rev() {
114                res.append_label(&[hexdigit(item)]).unwrap();
115                res.append_label(&[hexdigit(item >> 4)]).unwrap();
116            }
117            res.append_label(b"ip6").unwrap();
118            res.append_label(b"arpa").unwrap();
119            res.into_dname().unwrap()
120        }
121    }
122}
123
124fn hexdigit(nibble: u8) -> u8 {
125    match nibble & 0x0F {
126        0 => b'0',
127        1 => b'1',
128        2 => b'2',
129        3 => b'3',
130        4 => b'4',
131        5 => b'5',
132        6 => b'6',
133        7 => b'7',
134        8 => b'8',
135        9 => b'9',
136        10 => b'A',
137        11 => b'B',
138        12 => b'C',
139        13 => b'D',
140        14 => b'E',
141        15 => b'F',
142        _ => unreachable!(),
143    }
144}
145
146//============ Tests =========================================================
147
148#[cfg(test)]
149mod test {
150    use super::*;
151    use core::str::FromStr;
152
153    #[test]
154    fn test_dname_from_addr() {
155        assert_eq!(
156            dname_from_addr([192, 0, 2, 12].into()),
157            Dname::<Octets128>::from_str("12.2.0.192.in-addr.arpa").unwrap()
158        );
159        assert_eq!(
160            dname_from_addr(
161                [0x2001, 0xdb8, 0x1234, 0x0, 0x5678, 0x1, 0x9abc, 0xdef]
162                    .into()
163            ),
164            Dname::<Octets128>::from_str(
165                "f.e.d.0.c.b.a.9.1.0.0.0.8.7.6.5.\
166                 0.0.0.0.4.3.2.1.8.b.d.0.1.0.0.2.\
167                 ip6.arpa"
168            )
169            .unwrap()
170        );
171    }
172}
domain/resolv/lookup/addr.rs

domain/resolv/lookup/
addr.rs
