Struct resolv_conf::Config
source · [−]pub struct Config {Show 20 fields
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,
pub no_reload: bool,
pub trust_ad: bool,
pub lookup: Vec<Lookup>,
pub family: Vec<Family>,
/* private fields */
}
Expand description
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
no_reload: bool
Disable the automatic reloading of a changed configuration file
trust_ad: bool
Optionally send the AD (authenticated data) bit in queries
lookup: Vec<Lookup>
The order in which databases should be searched during a lookup (openbsd-only)
family: Vec<Family>
The order in which internet protocol families should be prefered (openbsd-only)
Implementations
sourceimpl Config
impl Config
sourcepub fn new() -> Config
pub 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);
sourcepub fn parse<T: AsRef<[u8]>>(buf: T) -> Result<Config, ParseError>
pub 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);
sourcepub fn get_last_search_or_domain<'a>(&'a self) -> DomainIter<'a>ⓘNotable traits for DomainIter<'a>impl<'a> Iterator for DomainIter<'a> type Item = &'a String;
pub fn get_last_search_or_domain<'a>(&'a self) -> DomainIter<'a>ⓘNotable traits for DomainIter<'a>impl<'a> Iterator for DomainIter<'a> type Item = &'a String;
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")]);
sourcepub fn get_domain(&self) -> Option<&String>
pub fn get_domain(&self) -> Option<&String>
Return the domain declared in the last “domain” directive.
sourcepub fn get_search(&self) -> Option<&Vec<String>>
pub fn get_search(&self) -> Option<&Vec<String>>
Return the domains declared in the last “search” directive.
sourcepub fn set_domain(&mut self, domain: String)
pub fn set_domain(&mut self, domain: String)
Set the domain corresponding to the “domain” directive.
sourcepub fn set_search(&mut self, search: Vec<String>)
pub fn set_search(&mut self, search: Vec<String>)
Set the domains corresponding the “search” directive.
sourcepub fn glibc_normalize(&mut self)
pub fn glibc_normalize(&mut self)
Normalize config according to glibc rulees
Currently this method does the following things:
- Truncates list of nameservers to 3 at max
- 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.
sourcepub fn get_nameservers_or_local(&self) -> Vec<ScopedIp>
pub fn get_nameservers_or_local(&self) -> Vec<ScopedIp>
Get nameserver or on the local machine
sourcepub fn get_system_domain(&self) -> Option<String>
pub fn get_system_domain(&self) -> Option<String>
Get domain from config or fallback to the suffix of a hostname
This is how glibc finds out a hostname. This method requires
system
feature enabled.
Trait Implementations
impl Eq for Config
impl StructuralEq for Config
impl StructuralPartialEq for Config
Auto Trait Implementations
impl RefUnwindSafe for Config
impl Send for Config
impl Sync for Config
impl Unpin for Config
impl UnwindSafe for Config
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> ToOwned for T where
T: Clone,
impl<T> ToOwned for T where
T: Clone,
type Owned = T
type Owned = T
The resulting type after obtaining ownership.
sourcefn clone_into(&self, target: &mut T)
fn clone_into(&self, target: &mut T)
toowned_clone_into
)Uses borrowed data to replace owned data, usually by cloning. Read more