Struct DnsConfig 

pub struct DnsConfig {
    pub name_servers: Vec<SocketAddr>,
    pub search: Vec<String>,
    pub n_dots: u32,
    pub timeout: Duration,
    pub attempts: u32,
    pub rotate: bool,
    pub use_inet6: bool,
}

Configures the behavior of DNS requests

Fields

name_servers: Vec<SocketAddr>

List of name servers; must not be empty

search: Vec<String>

List of search domains

n_dots: u32

Minimum number of dots in a name to trigger an initial absolute query

timeout: Duration

Duration before retrying or failing an unanswered request

attempts: u32

Number of attempts made before returning an error

rotate: bool

Whether to rotate through available nameservers

use_inet6: bool

If true, perform AAAA queries first and return IPv4 addresses as IPv4-mapped IPv6 addresses.

Implementations

impl DnsConfig

pub fn load_default() -> Result<DnsConfig>

Returns the default system configuration for DNS requests.

Examples found in repository

examples/lookup_srv.rs (line 15)

fn main() {
    let args = args().collect::<Vec<_>>();

    if args.len() != 4 {
        println!("Usage: {} <service> <proto> <name>", args[0]);
        println!(" e.g.  {} _http _tcp example.com", args[0]);
        return;
    }

    let config = match DnsConfig::load_default() {
        Ok(config) => config,
        Err(e) => {
            println!("failed to load system configuration: {}", e);
            return;
        }
    };

    let resolver = match DnsResolver::new(config) {
        Ok(resolver) => resolver,
        Err(e) => {
            println!("failed to create DNS resolver: {}", e);
            return;
        }
    };

    let name = format!("{}.{}.{}", args[1], args[2], args[3]);

    match resolver.resolve_record::<Srv>(&name) {
        Ok(records) => {
            for srv in records {
                println!(
                    "SRV priority={} weight={} port={} target={}",
                    srv.priority, srv.weight, srv.port, srv.target
                );
            }
        }
        Err(e) => {
            println!("{}", e);
            return;
        }
    }
}

examples/lookup_txt.rs (line 16)

fn main() {
    let args = args().collect::<Vec<_>>();

    if args.len() != 2 {
        println!("Usage: {} <name>", args[0]);
        println!(" e.g.  {} example.com", args[0]);
        return;
    }

    let config = match DnsConfig::load_default() {
        Ok(config) => config,
        Err(e) => {
            println!("Failed to load system configuration: {}", e);
            return;
        }
    };

    let resolver = match DnsResolver::new(config) {
        Ok(resolver) => resolver,
        Err(e) => {
            println!("Failed to create DNS resolver: {}", e);
            return;
        }
    };

    match resolver.resolve_record::<Txt>(&args[1]) {
        Ok(records) => {
            for txt in records {
                let data = match str::from_utf8(&txt.data) {
                    Ok(string) => string,
                    Err(e) => {
                        println!("Failed to decode UTF8 data: {}", e);
                        return;
                    }
                };
                println!("TXT data={}", data);
            }
        }
        Err(e) => {
            println!("{}", e);
            return;
        }
    }
}

pub fn with_name_servers(name_servers: Vec<SocketAddr>) -> DnsConfig

Returns a DnsConfig using the given set of name servers, setting all other fields to generally sensible default values.

Examples found in repository

examples/resolver.rs (lines 8-12)

fn main() {
    let config = DnsConfig::with_name_servers(vec![
        // Use Google's public DNS servers instead of the system default.
        "8.8.8.8:53".parse().unwrap(),
        "8.8.4.4:53".parse().unwrap(),
    ]);

    let resolver = match DnsResolver::new(config) {
        Ok(r) => r,
        Err(e) => {
            println!("failed to create DNS resolver: {}", e);
            return;
        }
    };

    let args = args().collect::<Vec<_>>();

    if args.len() == 1 {
        println!("Usage: {} <host name> [...]", args[0]);
        return;
    }

    for arg in &args[1..] {
        match resolver.resolve_host(&arg) {
            Ok(mut addrs) => {
                let addr = addrs.next().expect("empty ResolveHost");
                let n = addrs.count();

                if n == 0 {
                    println!("\"{}\" resolved to {}", arg, addr);
                } else {
                    println!("\"{}\" resolved to {} ({} more)", arg, addr, n);
                }
            }
            Err(e) => println!("failed to resolve \"{}\": {}", arg, e),
        }
    }
}

Trait Implementations

impl Clone for DnsConfig

fn clone(&self) -> DnsConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DnsConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.