Hickory Resolver

https://docs.rs/hickory-resolver/latest/
Admin
Hickory Resolver is a 100% in-process DNS resolver designed for performing recursive queries to...
Tokens:394,193
Snippets:2,901
Trust Score:9.7
Update:2 months ago
Show doc for...
Tokens:
Raw
### DNS Message Construction for preserve_intermediates=true

Source: https://docs.rs/hickory-resolver/latest/src/hickory_resolver/caching_client.rs.html?search=std%3A%3Avec

Sets up a DNS message identical to the previous example, including CNAME and A records in the ANSWER section. This setup is used to test the behavior when preserve_intermediates is set to true.

```rust
        // Same response as Test 2.1
        let mut message = Message::response(0, OpCode::Query);
        message.add_query(Query::query(
            Name::from_str("www.example.com.").unwrap(),
            RecordType::A,
        ));

        message.insert_answers(vec![
            Record::from_rdata(
                Name::from_str("www.example.com.").unwrap(),
                300,
                RData::CNAME(CNAME(Name::from_str("v4.example.com.").unwrap())),
            ),
            Record::from_rdata(
                Name::from_str("v4.example.com.").unwrap(),
                300,
                RData::A(A::new(192, 0, 2, 1)),
            ),
        ]);

        message.insert_authorities(vec![Record::from_rdata(
            Name::from_str("example.com.").unwrap(),
            3600,

```

--------------------------------

### Example Searches for Hickory Resolver

Source: https://docs.rs/hickory-resolver/latest/src/hickory_resolver/config.rs.html?search=

Provides examples of search queries that can be used within the Hickory Resolver. These demonstrate common search patterns for vectors, type conversions, and option transformations.

```text
Example searches:
  * std::vec
  * u32 -> bool
  * Option<T>, (T -> U) -> Option<U>
```

--------------------------------

### Test Building Names with Search List

Source: https://docs.rs/hickory-resolver/latest/src/hickory_resolver/resolver.rs.html

Demonstrates building a `ResolverConfig` and adding a search domain using `Name::from_ascii`. This snippet is part of a test setup.

```rust
    #[test]
    fn test_build_names() {
        use std::str::FromStr;

        let handle = TokioRuntimeProvider::default();
        let mut config = ResolverConfig::udp_and_tcp(&GOOGLE);
        config.add_search(Name::from_ascii("example.com.").unwrap());
```

--------------------------------

### IPv4 then IPv6 Lookup Example

Source: https://docs.rs/hickory-resolver/latest/src/hickory_resolver/lookup_ip.rs.html

Demonstrates a test case for the `ipv4_then_ipv6` method, asserting the expected IPv6 address after resolution.

```rust
cx.client = CachingClient::new(0, mock(vec![v6_message(), error()]), false);
        assert_eq!(
            block_on(cx.ipv4_then_ipv6(Name::root()))
                .unwrap()
                .answers()
                .iter()
                .map(|r| r.data.ip_addr().unwrap())
                .collect::<Vec<IpAddr>>(),
            vec![Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1)]
        );
    }
```

--------------------------------

### Sending a DNS Request

Source: https://docs.rs/hickory-resolver/latest/src/hickory_resolver/name_server.rs.html?search=

This example demonstrates sending a DNS request with specific options and a connection policy. It uses a NameServer instance and a PoolContext.

```rust
let mut request_options = DnsRequestOptions::default();
        request_options.case_randomization = true;
        let ns = Arc::new(NameServer::new([], config, &cx.options, provider));
        let response = ns
            .send(
                DnsRequest::from_query(
                    Query::query(name.clone(), RecordType::NULL),
                    request_options,
                ),
                ConnectionPolicy::default(),
                &cx,
            )
            .await
            .unwrap();
```

--------------------------------

### Using Host System Config (Unix)

Source: https://docs.rs/hickory-resolver/latest/src/hickory_resolver/lib.rs.html?search=std%3A%3Avec

Demonstrates how to initialize the Resolver using the host OS's configuration, typically found in /etc/resolv.conf on Unix systems. This example requires the 'tokio' and 'system-config' features.

```rust
# fn main() {
# #[cfg(all(unix, feature = "tokio", feature = "system-config"))] 
# {
# use std::net::*
# use tokio::runtime::Runtime;
# Runtime::new().unwrap().block_on(async {
use hickory_resolver::Resolver;
// Use the host OS'es `/etc/resolv.conf`
#[cfg(unix)]
let resolver = Resolver::builder_tokio().unwrap().build().unwrap();
#[cfg(unix)]
let response = resolver.lookup_ip("www.example.com.").await.unwrap();
# })
# }
# }

```

--------------------------------

### start

Source: https://docs.rs/hickory-resolver/latest/hickory_resolver/struct.OpportunisticEncryptionStatePersistTask.html

Starts the background task for periodically saving opportunistic encryption state.

```APIDOC
## pub async fn start<P: RuntimeProvider>(config: OpportunisticEncryptionPersistence, pool_context: &Arc<PoolContext>, conn_provider: P) -> Result<Option<P::Handle>, String>

### Description
Starts the persistence task based on the given configuration.

### Parameters
- **config** (OpportunisticEncryptionPersistence) - The configuration for the persistence task.
- **pool_context** (&Arc<PoolContext>) - The context for the connection pool.
- **conn_provider** (P) - The runtime provider for the connection.

### Returns
- **Result<Option<P::Handle>, String>** - Returns a handle to the task if successfully started, or an error string.
```

--------------------------------

### Basic NameServer Query Test

Source: https://docs.rs/hickory-resolver/latest/src/hickory_resolver/name_server.rs.html

Demonstrates how to create a NameServer instance for a specific IP address (Google DNS) and send a DNS query for 'www.example.com'. Asserts that the query is successful and returns no error.

```rust
subscribe();

        let options = ResolverOpts::default();
        let config = NameServerConfig::udp(IpAddr::V4(Ipv4Addr::new(8, 8, 8, 8)));
        let name_server = Arc::new(NameServer::new(
            [].into_iter(),
            config,
            &options,
            TokioRuntimeProvider::default(),
        ));

        let cx = Arc::new(PoolContext::new(options, TlsConfig::new().unwrap()));
        let name = Name::parse("www.example.com.", None).unwrap();
        let response = name_server
            .send(
                DnsRequest::from_query(
                    Query::query(name.clone(), RecordType::A),
                    DnsRequestOptions::default(),
                ),
                ConnectionPolicy::default(),
                &cx,
            )
            .await
            .expect("query failed");
        assert_eq!(response.response_code, ResponseCode::NoError);
```

--------------------------------

### Lookup a.example.com A Record

Source: https://docs.rs/hickory-resolver/latest/src/hickory_resolver/hosts.rs.html?search=

Demonstrates looking up the A record for a subdomain 'a.example.com'. This tests the resolution of subdomains.

```rust
        let mut name = Name::from_str("a.example.com").unwrap();
        name.set_fqdn(true);
        assert_eq!(
            hosts
                .lookup_static_host(&Query::query(name.clone(), RecordType::A))
                .unwrap()
                .answers(),
            &[Record::from_rdata(
                name,
                MAX_TTL,
                RData::A(Ipv4Addr::new(10, 0, 1, 111).into())
            )]
        );
```

--------------------------------

### Starting the Persistence Task

Source: https://docs.rs/hickory-resolver/latest/hickory_resolver/struct.OpportunisticEncryptionStatePersistTask.html

Starts the background task using the provided configuration, pool context, and connection provider.

```rust
pub async fn start<P: RuntimeProvider>( config: OpportunisticEncryptionPersistence, pool_context: &Arc<PoolContext>, conn_provider: P, ) -> Result<Option<P::Handle>, String>
```

--------------------------------

### Successful DNS Query with NameServer

Source: https://docs.rs/hickory-resolver/latest/src/hickory_resolver/name_server.rs.html?search=u32+-%3E+bool

Demonstrates a successful DNS query for 'www.example.com.' using the NameServer. It sets up a default UDP configuration and asserts that the response code is 'NoError'.

```rust
    #[tokio::test]
    async fn test_name_server() {
        subscribe();

        let options = ResolverOpts::default();
        let config = NameServerConfig::udp(IpAddr::V4(Ipv4Addr::new(8, 8, 8, 8)));
        let name_server = Arc::new(NameServer::new(
            [].into_iter(),
            config,
            &options,
            TokioRuntimeProvider::default(),
        ));

        let cx = Arc::new(PoolContext::new(options, TlsConfig::new().unwrap()));
        let name = Name::parse("www.example.com.", None).unwrap();
        let response = name_server
            .send(
                DnsRequest::from_query(
                    Query::query(name.clone(), RecordType::A),
                    DnsRequestOptions::default(),
                ),
                ConnectionPolicy::default(),
                &cx,
            )
            .await
            .expect("query failed");
        assert_eq!(response.response_code, ResponseCode::NoError);
    }
```

--------------------------------

### Get Pool Context

Source: https://docs.rs/hickory-resolver/latest/src/hickory_resolver/recursor/handle.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Returns a reference to the `PoolContext` associated with the recursor.

```rust
    pub(crate) fn pool_context(&self) -> &Arc<PoolContext> {
        &self.pool_context
    }

```

--------------------------------

### Create a new NameServer

Source: https://docs.rs/hickory-resolver/latest/hickory_resolver/struct.NameServer.html

Initializes a new NameServer instance with provided connections, configuration, and options.

```rust
pub fn new( connections: impl IntoIterator<Item = (Protocol, P::Conn)>, config: NameServerConfig, options: &ResolverOpts, connection_provider: P, ) -> Self
```

--------------------------------

### Use host system configuration

Source: https://docs.rs/hickory-resolver/latest/hickory_resolver/index.html

Initialize a resolver using the host OS's /etc/resolv.conf file.

```rust
use hickory_resolver::Resolver;
// Use the host OS'es `/etc/resolv.conf`
let resolver = Resolver::builder_tokio().unwrap().build().unwrap();
let response = resolver.lookup_ip("www.example.com.").await.unwrap();
```

--------------------------------

### Implement ConnectionProvider for RuntimeProvider

Source: https://docs.rs/hickory-resolver/latest/hickory_resolver/trait.ConnectionProvider.html

Example implementation of the ConnectionProvider trait for a generic RuntimeProvider.

```rust
impl<P: RuntimeProvider> ConnectionProvider for P
Source§
#### type Conn = DnsExchange<P>
Source§
#### type FutureConn = Pin<Box<dyn Future<Output = Result<<P as ConnectionProvider>::Conn, NetError>> + Send>>
Source§
#### type RuntimeProvider = P
```

--------------------------------

### Get Expiration Instant

Source: https://docs.rs/hickory-resolver/latest/src/hickory_resolver/lookup.rs.html?search=

Returns the Instant at which this Lookup result becomes invalid.

```rust
pub fn valid_until(&self) -> Instant {
        self.valid_until
    }
```

--------------------------------

### Lookup example.com A Record

Source: https://docs.rs/hickory-resolver/latest/src/hickory_resolver/hosts.rs.html?search=

Shows how to perform a lookup for the A record of 'example.com'. This is a standard lookup for a domain name.

```rust
        let mut name = Name::from_str("example.com").unwrap();
        name.set_fqdn(true);
        assert_eq!(
            hosts
                .lookup_static_host(&Query::query(name.clone(), RecordType::A))
                .unwrap()
                .answers(),
            &[Record::from_rdata(
                name,
                MAX_TTL,
                RData::A(Ipv4Addr::new(10, 0, 1, 102).into())
            )]
        );
```

--------------------------------

### Get Query from Lookup

Source: https://docs.rs/hickory-resolver/latest/src/hickory_resolver/lookup.rs.html?search=

Retrieves the Query that was used to generate this Lookup result.

```rust
pub fn query(&self) -> &Query {
        self.message
            .queries
            .first()
            .expect("Lookup message always has a query")
    }
```

--------------------------------

### Get name servers from ResolverConfig

Source: https://docs.rs/hickory-resolver/latest/src/hickory_resolver/config.rs.html?search=u32+-%3E+bool

Returns a slice of the configured `NameServerConfig` objects.

```rust
pub fn name_servers(&self) -> &[NameServerConfig] {
        &self.name_servers
    }
```

--------------------------------

### Async Resolver with Tokio and Custom Config

Source: https://docs.rs/hickory-resolver/latest/src/hickory_resolver/lib.rs.html?search=

This example shows how to set up an asynchronous DNS resolver using Tokio. It configures the resolver to use Google's DNS servers via UDP and TCP and performs an IP lookup.

```rust
# fn main() {
# #[cfg(feature = "tokio")]
# {
use std::net::*
use tokio::runtime::Runtime;
use hickory_resolver::Resolver;
use hickory_resolver::net::runtime::TokioRuntimeProvider;
use hickory_resolver::config::*

// We need a Tokio Runtime to run the resolver
//  this is responsible for running all Future tasks and registering interest in IO channels
let mut io_loop = Runtime::new().unwrap();

// Construct a new Resolver with default configuration options
let resolver = Resolver::builder_with_config(
    ResolverConfig::udp_and_tcp(&GOOGLE),
    TokioRuntimeProvider::default()
).build().unwrap();

// Lookup the IP addresses associated with a name.
// This returns a future that will lookup the IP addresses, it must be run in the Core to
//  to get the actual result.
let lookup_future = resolver.lookup_ip("www.example.com.");

// Run the lookup until it resolves or errors
let mut response = io_loop.block_on(lookup_future).unwrap();

// There can be many addresses associated with the name,
//  this can return IPv4 and/or IPv6 addresses
let _address = response.iter().next().expect("no addresses returned!");
# }
# }

```

--------------------------------

### Get Entry Count from Cache

Source: https://docs.rs/hickory-resolver/latest/src/hickory_resolver/cache.rs.html?search=std%3A%3Avec

Retrieves the current number of entries in the cache.

```rust
self.cache.entry_count()
```

--------------------------------

### Creating a LookupIpFuture

Source: https://docs.rs/hickory-resolver/latest/src/hickory_resolver/lookup_ip.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows how to initiate an IP address lookup using LookupIpFuture. This involves specifying the names to resolve, the strategy, the caching client, and DNS request options.

```rust
impl<C: DnsHandle + 'static> LookupIpFuture<C> {
    /// Perform a lookup from a hostname to a set of IPs
    ///
    /// # Arguments
    ///
    /// * `names` - a set of DNS names to attempt to resolve, they will be attempted in queue order, i.e. the first is `names.pop()`. Upon each failure, the next will be attempted.
    /// * `strategy` - the lookup IP strategy to use
    /// * `client_cache` - cache with a connection to use for performing all lookups
    pub fn lookup(
        names: Vec<Name>,
        strategy: LookupIpStrategy,
        client_cache: CachingClient<C>,
        options: DnsRequestOptions,
        hosts: Arc<Hosts>,
        finally_ip_addr: Option<RData>,
    ) -> Self {
        Self {
            names,
            strategy,
            client_cache,
            // If there are no names remaining, this will be returned immediately,
            // otherwise, it will be retried.
            query: future::err("can not lookup IPs for no names".into()).boxed(),
        }
    }
}
```

--------------------------------

### Build Resolver Configuration with Search Domain

Source: https://docs.rs/hickory-resolver/latest/src/hickory_resolver/resolver.rs.html?search=

Demonstrates building a resolver configuration with UDP and TCP enabled, and adding a search domain. It uses `Name::from_ascii` for domain parsing and `Resolver::builder_with_config` to construct the resolver.

```rust
    #[test]
    fn test_build_names() {
        use std::str::FromStr;

        let handle = TokioRuntimeProvider::default();
        let mut config = ResolverConfig::udp_and_tcp(&GOOGLE);
        config.add_search(Name::from_ascii("example.com.").unwrap());
        let resolver = Resolver::builder_with_config(config, handle)
            .build()
            .unwrap();

```

--------------------------------

### Get Server IP Address

Source: https://docs.rs/hickory-resolver/latest/src/hickory_resolver/name_server.rs.html

Retrieves the IP address of the name server configuration.

```rust
pub(super) fn ip(&self) -> IpAddr {
        self.config.ip
    }
```

--------------------------------

### NameServer::new

Source: https://docs.rs/hickory-resolver/latest/hickory_resolver/struct.NameServer.html

Creates a new instance of a NameServer with the specified connections, configuration, and provider.

```APIDOC
## NameServer::new

### Description
Creates a new `NameServer` with the given connections and configuration. The `connections` parameter will usually be empty.

### Signature
`pub fn new(connections: impl IntoIterator<Item = (Protocol, P::Conn)>, config: NameServerConfig, options: &ResolverOpts, connection_provider: P) -> Self`

### Parameters
- **connections** (impl IntoIterator<Item = (Protocol, P::Conn)>) - A collection of existing connections.
- **config** (NameServerConfig) - Configuration for the name server.
- **options** (&ResolverOpts) - Resolver options.
- **connection_provider** (P) - The connection provider instance.
```

--------------------------------

### Get Validity Deadline

Source: https://docs.rs/hickory-resolver/latest/src/hickory_resolver/lookup.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Returns the Instant at which this Lookup result is no longer considered valid.

```rust
    pub fn valid_until(&self) -> Instant {
        self.valid_until
    }
```

--------------------------------

### Get Query from Lookup

Source: https://docs.rs/hickory-resolver/latest/src/hickory_resolver/lookup.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Retrieves a reference to the Query that was used to generate this Lookup result.

```rust
    pub fn query(&self) -> &Query {
        self.message
            .queries
            .first()
            .expect("Lookup message always has a query")
    }
```

--------------------------------

### NameServer::new

Source: https://docs.rs/hickory-resolver/latest/hickory_resolver/struct.NameServer.html?search=std%3A%3Avec

Creates a new NameServer instance with the provided connections, configuration, resolver options, and connection provider.

```APIDOC
## NameServer::new

### Description
Creates a new `NameServer` instance. This struct represents a remote DNS server and manages its connections.

### Signature
`pub fn new(connections: impl IntoIterator<Item = (Protocol, P::Conn)>, config: NameServerConfig, options: &ResolverOpts, connection_provider: P) -> Self`

### Parameters
- **connections** (impl IntoIterator<Item = (Protocol, P::Conn)>) - A collection of existing connections to the server.
- **config** (NameServerConfig) - Configuration settings for the name server.
- **options** (&ResolverOpts) - Resolver options to apply.
- **connection_provider** (P) - The provider used to manage connections.
```

--------------------------------

### Perform asynchronous connection

Source: https://docs.rs/hickory-resolver/latest/hickory_resolver/index.html

Example of using resolved IP addresses to establish a TCP connection.

```rust
let ips = resolver.lookup_ip("www.example.com.").await.unwrap();

let ip = ips.iter().next().unwrap();
let conn = TcpStream::connect((ip, 443)).unwrap();
/* do something with the connection... */
```

--------------------------------

### Build Names with Resolver Configuration

Source: https://docs.rs/hickory-resolver/latest/src/hickory_resolver/resolver.rs.html

Demonstrates building a Resolver instance with a specific configuration and handle, then testing name building with different inputs.

```rust
let resolver = Resolver::builder_with_config(config, handle)
            .build()
            .unwrap();

        assert_eq!(resolver.build_names(Name::from_str("").unwrap()).len(), 2);
        assert_eq!(resolver.build_names(Name::from_str(".").unwrap()).len(), 1);

        let fqdn = Name::from_str("foo.example.com.").unwrap();
        let name_list = resolver.build_names(Name::from_str("foo").unwrap());
        assert!(name_list.contains(&fqdn));

        let name_list = resolver.build_names(fqdn.clone());
        assert_eq!(name_list.len(), 1);
        assert_eq!(name_list.first(), Some(&fqdn));
```

--------------------------------

### Get Zone

Source: https://docs.rs/hickory-resolver/latest/src/hickory_resolver/name_server_pool.rs.html?search=

Retrieves an Option<&Name> representing the zone associated with the NameServerPool, if one has been set.

```rust
pub fn zone(&self) -> Option<&Name> {
        self.zone.as_ref()
    }
```

--------------------------------

### Using Host System Config (Unix)

Source: https://docs.rs/hickory-resolver/latest/src/hickory_resolver/lib.rs.html?search=

On Unix systems, this snippet demonstrates how to use the host OS's /etc/resolv.conf for DNS resolution configuration. Note that not all options from resolv.conf may be supported.

```rust
# fn main() {
# #[cfg(all(unix, feature = "tokio", feature = "system-config"))]
# {
# use std::net::*
# use tokio::runtime::Runtime;
# Runtime::new().unwrap().block_on(async {
use hickory_resolver::Resolver;
// Use the host OS'es `/etc/resolv.conf`
# #[cfg(unix)]
let resolver = Resolver::builder_tokio().unwrap().build().unwrap();
# #[cfg(unix)]
let response = resolver.lookup_ip("www.example.com.").await.unwrap();
# })
# }
# }

```

--------------------------------

### Get Decayed SRTT

Source: https://docs.rs/hickory-resolver/latest/src/hickory_resolver/name_server.rs.html

Returns the current decayed smoothed round-trip time (SRTT) for the server.

```rust
pub(crate) fn decayed_srtt(&self) -> f64 {
        self.server_srtt.current()
    }
```

--------------------------------

### Configure and Send DNS Request with NameServer

Source: https://docs.rs/hickory-resolver/latest/src/hickory_resolver/name_server.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to configure a NameServer, create a DNS request with specific options, and send it using a provided connection policy and context. This is useful for simulating client-side DNS lookups.

```rust
        let config = NameServerConfig {
            ip: server_addr.ip(),
            trust_negative_responses: true,
            connections: vec![ConnectionConfig {
                port: server_addr.port(),
                protocol: ProtocolConfig::Udp,
                bind_addr: None,
            }],
        };

        let resolver_opts = ResolverOpts {
            case_randomization: true,
            ..Default::default()
        };

        let cx = Arc::new(PoolContext::new(resolver_opts, TlsConfig::new().unwrap()));
        let mut request_options = DnsRequestOptions::default();
        request_options.case_randomization = true;
        let ns = Arc::new(NameServer::new([], config, &cx.options, provider));
        let response = ns
            .send(
                DnsRequest::from_query(
                    Query::query(name.clone(), RecordType::NULL),
                    request_options,
                ),
                ConnectionPolicy::default(),
                &cx,
            )
            .await
            .unwrap();

        let response_query_name = response.queries.first().unwrap().name();
        assert!(response_query_name.eq_case(&name));
```

--------------------------------

### Get Unix Hosts Path

Source: https://docs.rs/hickory-resolver/latest/src/hickory_resolver/hosts.rs.html

Returns the standard path for the hosts file on Unix-like systems.

```Rust
fn hosts_path() -> &'static str {
    "/etc/hosts"
}
```

--------------------------------

### Get Answer Records

Source: https://docs.rs/hickory-resolver/latest/src/hickory_resolver/lookup.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Returns a slice of Record objects representing the answers in the DNS message.

```rust
    pub fn answers(&self) -> &[Record] {
        &self.message.answers
    }
```

--------------------------------

### NameServer::new

Source: https://docs.rs/hickory-resolver/latest/hickory_resolver/struct.NameServer.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a new NameServer instance with the specified connections, configuration, options, and connection provider.

```APIDOC
## pub fn new<P: ConnectionProvider>(connections: impl IntoIterator<Item = (Protocol, P::Conn)>, config: NameServerConfig, options: &ResolverOpts, connection_provider: P) -> Self

### Description
Creates a new `NameServer` with the given connections and configuration. The `connections` parameter will usually be empty upon initialization.

### Parameters
- **connections** (impl IntoIterator<Item = (Protocol, P::Conn)>) - The initial set of connections to the DNS server.
- **config** (NameServerConfig) - Configuration settings for the NameServer.
- **options** (&ResolverOpts) - Resolver options to apply.
- **connection_provider** (P) - The provider used to manage connections.
```

--------------------------------

### Initialize Connection Meta

Source: https://docs.rs/hickory-resolver/latest/src/hickory_resolver/name_server.rs.html

Provides a default ConnectionMeta, initializing the status to 'Init' and the SRTT with a random, low value to encourage early server probing.

```rust
fn default() -> Self {
        // Initialize the SRTT to a randomly generated value that represents a
        // very low RTT. Such a value helps ensure that each server is attempted
        // early.
        Self {
            status: AtomicU8::new(Status::Init.into()),
            srtt: DecayingSrtt::new(Duration::from_micros(rand::random_range(1..32))),
        }
    }
```

--------------------------------

### Get Additional Records

Source: https://docs.rs/hickory-resolver/latest/src/hickory_resolver/lookup.rs.html?search=

Returns a slice of the additional records contained within the DNS message.

```rust
pub fn additionals(&self) -> &[Record] {
        &self.message.additionals
    }
```

--------------------------------

### Get Authority Records

Source: https://docs.rs/hickory-resolver/latest/src/hickory_resolver/lookup.rs.html?search=

Returns a slice of the authority records contained within the DNS message.

```rust
pub fn authorities(&self) -> &[Record] {
        &self.message.authorities
    }
```

--------------------------------

### Resolver::new

Source: https://docs.rs/hickory-resolver/latest/src/hickory_resolver/resolver.rs.html

Constructs a new Resolver instance. This method initializes the resolver with provided configuration, including name servers, options, and provider details.

```APIDOC
## Resolver::new

### Description
Constructs a new Resolver instance. This method initializes the resolver with provided configuration, including name servers, options, and provider details.

### Method
Associated function (constructor)

### Parameters
- **name_servers**: `Vec<NameServer>` - A list of name servers to use for DNS resolution.
- **options**: `ResolverOptions` - Configuration options for the resolver.
- **provider**: `Provider` - The DNS provider to use.
- **#[cfg(feature = "__tls")] tls**: `Option<TlsConfig>` - Optional TLS configuration.
- **#[cfg(feature = "__dnssec")] trust_anchor**: `Option<Arc<TrustAnchors>>` - Optional trust anchor for DNSSEC validation.
- **#[cfg(feature = "__dnssec")] nsec3_soft_iteration_limit**: `u8` - Soft iteration limit for NSEC3.
- **#[cfg(feature = "__dnssec")] nsec3_hard_iteration_limit**: `u8` - Hard iteration limit for NSEC3.
- **opportunistic_encryption**: `OpportunisticEncryption` - Configuration for opportunistic encryption.
- **encrypted_transport_state**: `AsyncMutex<EncryptedTransportState>` - State for encrypted transport.

### Returns
- `Result<Resolver, NetError>` - A `Result` containing the new `Resolver` instance or a `NetError` if initialization fails.
```

--------------------------------

### Create New NameServer

Source: https://docs.rs/hickory-resolver/latest/src/hickory_resolver/name_server.rs.html?search=

Initializes a new NameServer instance with provided connections, configuration, options, and a connection provider. Connections are reordered to prioritize UDP unless a user-provided order is specified.

```rust
pub fn new(
        connections: impl IntoIterator<Item = (Protocol, P::Conn)>,
        config: NameServerConfig,
        options: &ResolverOpts,
        connection_provider: P,
    ) -> Self {
        let mut connections = connections
            .into_iter()
            .map(|(protocol, handle)| ConnectionState::new(handle, protocol))
            .collect::<Vec<_>>();

        // Unless the user specified that we should follow the configured order,
        // re-order the connections to prioritize UDP.
        if options.server_ordering_strategy != ServerOrderingStrategy::UserProvidedOrder {
            connections.sort_by_key(|ns| ns.protocol != Protocol::Udp);
        }

        Self {
            config,
            connections: AsyncMutex::new(connections),
            server_srtt: DecayingSrtt::new(Duration::from_micros(rand::random_range(1..32))),
            #[cfg(all(feature = "metrics", any(feature = "__tls", feature = "__quic")))]
            opportunistic_probe_metrics: ProbeMetrics::default(),
            #[cfg(feature = "metrics")]
            resolver_metrics: ResolverMetrics::default(),
            connection_provider,
        }
    }
```

--------------------------------

### Get Answer Records

Source: https://docs.rs/hickory-resolver/latest/src/hickory_resolver/lookup.rs.html?search=

Returns a slice of the answer records contained within the DNS message.

```rust
pub fn answers(&self) -> &[Record] {
        &self.message.answers
    }
```

--------------------------------

### Get Underlying DNS Message

Source: https://docs.rs/hickory-resolver/latest/src/hickory_resolver/lookup.rs.html?search=

Provides access to the raw DNS Message associated with this Lookup.

```rust
pub fn message(&self) -> &Message {
        &self.message
    }
```

--------------------------------

### Configure and Initialize Resolver

Source: https://docs.rs/hickory-resolver/latest/src/hickory_resolver/resolver.rs.html

Initializes a new Resolver instance with various configuration options, including DNSSEC validation, caching, and host file usage. This is the primary entry point for setting up the resolver.

```rust
let context = Arc::new(PoolContext {
            answer_address_filter: options.answer_address_filter(),
            options,
            #[cfg(feature = "__tls")]
            tls: match tls {
                Some(config) => config,
                None => TlsConfig::new()?.config,
            },
            opportunistic_probe_budget: AtomicU8::new(
                opportunistic_encryption
                    .max_concurrent_probes()
                    .unwrap_or_default(),
            ),
            opportunistic_encryption,
            transport_state: AsyncMutex::new(encrypted_transport_state),
        });

        let pool = NameServerPool::from_config(name_servers, context.clone(), provider);

        let client = RetryDnsHandle::new(pool, context.options.attempts);

        #[cfg(feature = "__dnssec")]
        let either = if context.options.validate {
            let trust_anchor = trust_anchor.unwrap_or_else(|| Arc::new(TrustAnchors::default()));

            LookupEither::Secure(
                DnssecDnsHandle::with_trust_anchor(client, trust_anchor)
                    .nsec3_iteration_limits(nsec3_soft_iteration_limit, nsec3_hard_iteration_limit),
            )
        } else {
            LookupEither::Retry(client)
        };
        #[cfg(not(feature = "__dnssec"))]
        let either = LookupEither::Retry(client);

        let cache = ResponseCache::new(
            context.options.cache_size,
            TtlConfig::from_opts(&context.options),
        );
        let client_cache = CachingClient::with_cache(cache, either, context.options.preserve_intermediates);

        let hosts = Arc::new(match context.options.use_hosts_file {
            ResolveHosts::Always | ResolveHosts::Auto => Hosts::from_system().unwrap_or_default(),
            ResolveHosts::Never => Hosts::default(),
        });

        Ok(Resolver {
            domain,
            search,
            context,
            client_cache,
            hosts,
        })
```

--------------------------------

### Get Transport State Mutex Guard

Source: https://docs.rs/hickory-resolver/latest/src/hickory_resolver/name_server_pool.rs.html?search=std%3A%3Avec

Provides asynchronous access to the `NameServerTransportState` via a mutex guard.

```rust
    pub(crate) async fn transport_state(&self) -> MutexGuard<'_, NameServerTransportState> {
        self.transport_state.lock().await
    }

```

--------------------------------

### Performing and Verifying DNS Lookup with Caching Client (preserve_intermediates=false)

Source: https://docs.rs/hickory-resolver/latest/src/hickory_resolver/caching_client.rs.html?search=std%3A%3Avec

Performs a DNS lookup for 'www.example.com.' using the initialized CachingClient. Verifies that only the A record is present in the ANSWER section, and that AUTHORITY and ADDITIONAL sections are preserved, as intermediate CNAMEs are filtered out when preserve_intermediates is false.

```rust
        let lookup = block_on(CachingClient::inner_lookup(
            Query::query(Name::from_str("www.example.com.").unwrap(), RecordType::A),
            DnsRequestOptions::default(),
            client,
            vec![],
            DepthTracker::default(),
        ))
        .expect("lookup failed");

        // Verify ANSWER: Only A record (CNAME filtered out because target was found)
        let answers = lookup.answers().iter().collect::<Vec<_>>();
        assert_eq!(
            answers.len(),
            1,
            "ANSWER should have 1 record (CNAME filtered)"
        );
        assert_eq!(
            answers[0].record_type(),
            RecordType::A,
            "ANSWER should contain only the A record"
        );
        match answers[0].data {
            RData::A(a) => assert_eq!(a, A::new(192, 0, 2, 1), "A record should have correct IP"),
            _ => panic!("wrong rdata type"),
        }

        // Verify AUTHORITY: NS record preserved
        let authorities = lookup.authorities().iter().collect::<Vec<_>>();
        assert_eq!(
            authorities.len(),
            1,
            "AUTHORITY section should be preserved"
        );
        assert_eq!(
            authorities[0].record_type(),
            RecordType::NS,
            "AUTHORITY should contain NS record"
        );

        // Verify ADDITIONAL: Glue preserved
        let additionals = lookup.additionals().iter().collect::<Vec<_>>();
        assert_eq!(
            additionals.len(),
            1,
            "ADDITIONAL section should be preserved"
        );
        assert_eq!(
            additionals[0].record_type(),
            RecordType::A,
            "ADDITIONAL should contain glue A record"
        );
        match additionals[0].data {
            RData::A(a) => assert_eq!(
                a,
                A::new(192, 0, 2, 10),
                "Glue record should have correct IP"
            ),
            _ => panic!("wrong rdata type"),
        }
```

--------------------------------

### Get Additional Records

Source: https://docs.rs/hickory-resolver/latest/src/hickory_resolver/lookup.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Returns a slice of Record objects representing the additional records in the DNS message.

```rust
    pub fn additionals(&self) -> &[Record] {
        &self.message.additionals
    }
```

--------------------------------

### Resolver Builder with System Configuration

Source: https://docs.rs/hickory-resolver/latest/src/hickory_resolver/resolver.rs.html?search=

Initializes a Resolver using the operating system's DNS configuration (e.g., /etc/resolv.conf or Windows registry). This method is available on Unix and Windows.

```rust
use hickory_resolver::Resolver;
use hickory_resolver::TokioRuntimeProvider;

#[cfg(any(unix, target_os = "windows"))]
#[cfg(feature = "system-config")]
fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resolver_builder = Resolver::<TokioRuntimeProvider>::builder(TokioRuntimeProvider::default())?;
    // Further configure the builder or build the resolver
    Ok(())
}
```

--------------------------------

### pub fn from_system() -> Result<Self>

Source: https://docs.rs/hickory-resolver/latest/hickory_resolver/struct.Hosts.html?search=

Creates a new Hosts configuration from the system's hosts file. This function is available on Unix and Windows operating systems. On other OSes, it returns an empty configuration.

```APIDOC
## pub fn from_system() -> Result<Self>

### Description
Creates a new configuration from the system hosts file, only works for Windows and Unix-like OSes, will return empty configuration on others.

### Method
`from_system`

### Parameters
None

### Returns
- `Result<Self>`: A `Result` containing the `Hosts` configuration if successful, or an error if creation fails.
```

--------------------------------

### Get Authority Records

Source: https://docs.rs/hickory-resolver/latest/src/hickory_resolver/lookup.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Returns a slice of Record objects representing the authority records in the DNS message.

```rust
    pub fn authorities(&self) -> &[Record] {
        &self.message.authorities
    }
```

--------------------------------

### Construct DNS-over-QUIC Connection Configuration

Source: https://docs.rs/hickory-resolver/latest/src/hickory_resolver/config.rs.html

Creates a new ConnectionConfig for DNS-over-QUIC. Requires the `__quic` feature flag.

```rust
ConnectionConfig::quic(Arc::from(ip.to_string()))

```
Tokens:
Raw