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

//! DNS configurations

#[cfg(unix)]
use std::{convert::Infallible, path::PathBuf};
use std::{
    fmt::{self, Display},
    net::{IpAddr, SocketAddr},
    str::FromStr,
};

/// DNS name server address
#[derive(Debug, Clone, Eq, PartialEq, Hash)]
pub enum NameServerAddr {
    /// IP address
    SocketAddr(SocketAddr),
    /// Unix Domain Socket address
    ///
    /// Specifically used by Android, which served as a stream protocol based DNS server
    #[cfg(unix)]
    UnixSocketAddr(PathBuf),
}

/// Parse `NameServerAddr` error
#[cfg(unix)]
pub type NameServerAddrError = Infallible;
/// Parse `NameServerAddr` error
#[cfg(not(unix))]
pub type NameServerAddrError = <SocketAddr as FromStr>::Err;

impl FromStr for NameServerAddr {
    type Err = NameServerAddrError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        if let Ok(ip) = s.parse::<IpAddr>() {
            return Ok(NameServerAddr::SocketAddr(SocketAddr::new(ip, 53)));
        }

        match s.parse::<SocketAddr>() {
            Ok(addr) => Ok(NameServerAddr::SocketAddr(addr)),
            #[cfg(unix)]
            Err(..) => Ok(NameServerAddr::UnixSocketAddr(PathBuf::from(s))),
            #[cfg(not(unix))]
            Err(err) => Err(err),
        }
    }
}

impl Display for NameServerAddr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match *self {
            NameServerAddr::SocketAddr(ref sa) => Display::fmt(sa, f),
            #[cfg(unix)]
            NameServerAddr::UnixSocketAddr(ref p) => write!(f, "{}", p.display()),
        }
    }
}