Struct resolv_conf::Config

pub struct Config {
    pub nameservers: Vec<ScopedIp>,
    pub sortlist: Vec<Network>,
    pub debug: bool,
    pub ndots: u32,
    pub timeout: u32,
    pub attempts: u32,
    pub rotate: bool,
    pub no_check_names: bool,
    pub inet6: bool,
    pub ip6_bytestring: bool,
    pub ip6_dotint: bool,
    pub edns0: bool,
    pub single_request: bool,
    pub single_request_reopen: bool,
    pub no_tld_query: bool,
    pub use_vc: bool,
    // some fields omitted
}

Represent a resolver configuration, as described in man 5 resolv.conf. The options and defaults match those in the linux man page.

Note: while most fields in the structure are public the search and domain fields must be accessed via methods. This is because there are few different ways to treat domain field. In GNU libc search and domain replace each other (get_last_search_or_domain). In MacOS /etc/resolve/* files domain is treated in entirely different way.

Also consider using glibc_normalize and get_system_domain to match behavior of GNU libc. (latter requires system feature enabled)

extern crate resolv_conf;

use std::net::Ipv4Addr;
use resolv_conf::{Config, ScopedIp};

fn main() {
    // Create a new config
    let mut config = Config::new();
    config.nameservers.push(ScopedIp::V4(Ipv4Addr::new(8, 8, 8, 8)));
    config.set_search(vec!["example.com".into()]);

    // Parse a config
    let parsed = Config::parse("nameserver 8.8.8.8\nsearch example.com").unwrap();
    assert_eq!(parsed, config);
}

Fields

nameservers: Vec<ScopedIp>

List of nameservers

sortlist: Vec<Network>

List of preferred addresses

debug: bool

Enable DNS resolve debugging

ndots: u32

Number of dots in name to try absolute resolving first (default 1)

timeout: u32

Dns query timeout (default 5 [sec])

attempts: u32

Number of attempts to resolve name if server is inaccesible (default 2)

rotate: bool

Round-robin selection of servers (default false)

no_check_names: bool

Don't check names for validity (default false)

inet6: bool

Try AAAA query before A

ip6_bytestring: bool

Use reverse lookup of ipv6 using bit-label format described instead of nibble format

ip6_dotint: bool

Do ipv6 reverse lookups in ip6.int zone instead of ip6.arpa (default false)

edns0: bool

Enable dns extensions described in RFC 2671

single_request: bool

Don't make ipv4 and ipv6 requests simultaneously

single_request_reopen: bool

Use same socket for the A and AAAA requests

no_tld_query: bool

Don't resolve unqualified name as top level domain

use_vc: bool

Force using TCP for DNS resolution

Methods

impl Config

fn new() -> Config

Create a new Config object with default values.

use resolv_conf::Config;
let config = Config::new();
assert_eq!(config.nameservers, vec![]);
assert!(config.get_domain().is_none());
assert!(config.get_search().is_none());
assert_eq!(config.sortlist, vec![]);
assert_eq!(config.debug, false);
assert_eq!(config.ndots, 1);
assert_eq!(config.timeout, 5);
assert_eq!(config.attempts, 2);
assert_eq!(config.rotate, false);
assert_eq!(config.no_check_names, false);
assert_eq!(config.inet6, false);
assert_eq!(config.ip6_bytestring, false);
assert_eq!(config.ip6_dotint, false);
assert_eq!(config.edns0, false);
assert_eq!(config.single_request, false);
assert_eq!(config.single_request_reopen, false);
assert_eq!(config.no_tld_query, false);
assert_eq!(config.use_vc, false);

fn parse<T: AsRef<[u8]>>(buf: T) -> Result<Config, ParseError>

Parse a buffer and return the corresponding Config object.

use resolv_conf::{ScopedIp, Config};
let config_str = "# /etc/resolv.conf
nameserver  8.8.8.8
nameserver  8.8.4.4
search      example.com sub.example.com
options     ndots:8 attempts:8";

// Parse the config
let parsed_config = Config::parse(&config_str).expect("Failed to parse config");

// Print the config
println!("{:?}", parsed_config);

fn get_last_search_or_domain<'a>(&'a self) -> DomainIter<'a>

Return the suffixes declared in the last "domain" or "search" directive.

use resolv_conf::{ScopedIp, Config};
let config_str = "search example.com sub.example.com\ndomain localdomain";
let parsed_config = Config::parse(&config_str).expect("Failed to parse config");
let domains = parsed_config.get_last_search_or_domain()
                           .map(|domain| domain.clone())
                           .collect::<Vec<String>>();
assert_eq!(domains, vec![String::from("localdomain")]);

let config_str = "domain localdomain\nsearch example.com sub.example.com";
let parsed_config = Config::parse(&config_str).expect("Failed to parse config");
let domains = parsed_config.get_last_search_or_domain()
                           .map(|domain| domain.clone())
                           .collect::<Vec<String>>();
assert_eq!(domains, vec![String::from("example.com"), String::from("sub.example.com")]);

fn get_domain(&self) -> Option<&String>

Return the domain declared in the last "domain" directive.

fn get_search(&self) -> Option<&Vec<String>>

Return the domains declared in the last "search" directive.

fn set_domain(&mut self, domain: String)

Set the domain corresponding to the "domain" directive.

fn set_search(&mut self, search: Vec<String>)

Set the domains corresponding the "search" directive.

fn glibc_normalize(&mut self)

Normalize config according to glibc rulees

Currently this method does the following things:

1. Truncates list of nameservers to 3 at max
2. Truncates search list to 6 at max

Other normalizations may be added in future as long as they hold true for a particular GNU libc implementation.

Note: this method is not called after parsing, because we think it's not forward-compatible to rely on such small and ugly limits. Still, it's useful to keep implementation as close to glibc as possible.

fn get_nameservers_or_local(&self) -> Vec<ScopedIp>

Get nameserver or on the local machine

Trait Implementations

impl Clone for Config

fn clone(&self) -> Config

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Config

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl PartialEq for Config

fn eq(&self, __arg_0: &Config) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, __arg_0: &Config) -> bool

This method tests for !=.

impl Eq for Config