nrf-modem 0.10.2

Async modem api for the nRF91xx
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

#[cfg(not(feature = "dns-async"))]
mod dns_blocking;

#[cfg(not(feature = "dns-async"))]
pub use dns_blocking::{
    get_host_by_name, get_host_by_name_with_cancellation, resolve_dns,
    resolve_dns_with_cancellation,
};

#[cfg(feature = "dns-async")]
mod dns_async;

#[cfg(feature = "dns-async")]
mod dns_cache;

#[cfg(feature = "dns-async")]
pub use dns_async::{
    get_host_by_name, get_host_by_name_with_cancellation, resolve_dns,
    resolve_dns_with_cancellation,
};

/// A DNS query.
///
/// Pass to [`resolve_dns()`] or [`resolve_dns_with_cancellation()`].
#[derive(Copy, Clone, Debug)]
pub struct DnsQuery<'a> {
    /// The hostname to resolve.
    hostname: &'a str,

    /// The desired address type.
    addr_type: AddrType,
}

impl<'a> DnsQuery<'a> {
    /// Create a new DNS query to resolve a given hostname.
    ///
    /// Does not restrict the address type to resolve.
    pub fn new(hostname: &'a str) -> Self {
        Self {
            hostname,
            addr_type: AddrType::Any,
        }
    }

    /// Set the address type of the query.
    ///
    /// Can be used to ask only for an IPv4 or IPv6 address.
    #[must_use = "this function returns a new query, it does not modify the existing one"]
    pub fn with_address_type(self, addr_type: AddrType) -> Self {
        let mut out = self;
        out.addr_type = addr_type;
        out
    }

    /// Get the hostname to resolve.
    pub fn hostname(&self) -> &'a str {
        self.hostname
    }

    /// Get the address type of the query.
    pub fn addr_type(&self) -> AddrType {
        self.addr_type
    }
}

/// The address type for a DNS query.
#[derive(Copy, Clone, Debug)]
pub enum AddrType {
    /// Resolve to an IPv4 or IPv6 address.
    Any,

    /// Resolve to an IPv4 address.
    V4,

    /// Resolve to an IPv6 address.
    V6,
}

impl AddrType {
    /// Check if the given IP address matches the address type.
    fn addr_matches(&self, addr: core::net::IpAddr) -> bool {
        match self {
            Self::Any => true,
            Self::V4 => matches!(addr, core::net::IpAddr::V4(_)),
            Self::V6 => matches!(addr, core::net::IpAddr::V6(_)),
        }
    }
}