c-ares 13.0.0

A Rust wrapper for the c-ares library, for asynchronous DNS requests.
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

use bitflags::bitflags;
bitflags!(
    /// Flags that may be provided on a call to `get_name_info()`.
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
    pub struct NIFlags: i32 {
        /// Only the nodename portion of the FQDN is returned for local hosts.
        const NOFQDN = c_ares_sys::ARES_NI_NOFQDN;

        /// The numeric form of the hostname is returned rather than the name.
        const NUMERICHOST = c_ares_sys::ARES_NI_NUMERICHOST;

        /// An error is returned if the hostname cannot be found in the DNS.
        const NAMEREQD = c_ares_sys::ARES_NI_NAMEREQD;

        /// The numeric form of the service is returned rather than the name.
        const NUMERICSERV = c_ares_sys::ARES_NI_NUMERICSERV;

        /// The service name is to be looked up for the TCP protocol.
        const TCP = c_ares_sys::ARES_NI_TCP;

        /// The service name is to be looked up for the UDP protocol.
        const UDP = c_ares_sys::ARES_NI_UDP;

        /// The service name is to be looked up for the SCTP protocol.
        const SCTP = c_ares_sys::ARES_NI_SCTP;

        /// The service name is to be looked up for the DCCP protocol.
        const DCCP = c_ares_sys::ARES_NI_DCCP;

        /// The numeric form of the scope ID is returned rather than the name.
        const NUMERICSCOPE = c_ares_sys::ARES_NI_NUMERICSCOPE;

        /// A hostname lookup is being requested.
        const LOOKUPHOST = c_ares_sys::ARES_NI_LOOKUPHOST;

        /// A service name lookup is being requested.
        const LOOKUPSERVICE = c_ares_sys::ARES_NI_LOOKUPSERVICE;
    }
);

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn empty() {
        let flags = NIFlags::empty();
        assert!(flags.is_empty());
    }

    #[test]
    fn single() {
        let flags = NIFlags::NOFQDN;
        assert!(flags.contains(NIFlags::NOFQDN));
        assert!(!flags.contains(NIFlags::NUMERICHOST));
    }

    #[test]
    fn combine() {
        let flags = NIFlags::NUMERICHOST | NIFlags::NUMERICSERV;
        assert!(flags.contains(NIFlags::NUMERICHOST));
        assert!(flags.contains(NIFlags::NUMERICSERV));
    }

    #[test]
    fn protocol_flags() {
        let tcp_flags = NIFlags::TCP | NIFlags::LOOKUPSERVICE;
        assert!(tcp_flags.contains(NIFlags::TCP));
        assert!(!tcp_flags.contains(NIFlags::UDP));
    }

    #[test]
    fn debug() {
        let flags = NIFlags::TCP | NIFlags::LOOKUPHOST;
        let debug = format!("{flags:?}");
        assert!(!debug.is_empty());
    }
}