Struct DnsResolver 

pub struct DnsResolver { /* private fields */ }

Performs resolution operations

Implementations

impl DnsResolver

pub fn new(config: DnsConfig) -> Result<DnsResolver>

Constructs a DnsResolver using the given configuration.

Examples found in repository

examples/resolver.rs (line 14)

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),
        }
    }
}

examples/lookup_srv.rs (line 23)

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 24)

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 bind<A: ToSocketAddrs>(addr: A, config: DnsConfig) -> Result<DnsResolver>

Constructs a DnsResolver using the given configuration and bound to the given address.

pub fn resolve_addr(&self, addr: &IpAddr) -> Result<String>

Resolves an IPv4 or IPv6 address to a hostname.

pub fn resolve_host(&self, host: &str) -> Result<ResolveHost>

Resolves a hostname to a series of IPv4 or IPv6 addresses.

Examples found in repository

examples/resolver.rs (line 30)

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),
        }
    }
}

pub fn resolve_record<Rec: Record>(&self, name: &str) -> Result<Vec<Rec>>

Requests a type of record from the DNS server and returns the results.

Examples found in repository

examples/lookup_srv.rs (line 33)

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 32)

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 send_message<'buf>( &self, out_msg: &Message<'_>, buf: &'buf mut [u8], ) -> Result<Message<'buf>, Error>

Sends a message to the DNS server and attempts to read a response.