Struct BoundedDnsResolver 

pub struct BoundedDnsResolver<R> { /* private fields */ }

Available on crate features dns and std only.

Bound raw results from each DNS lookup, before deduplication.

Implements each resolver trait supported by the wrapped resolver. Each lookup has its own allowance; duplicates and errors both count as raw results. For a bounded type, an additional result produces DnsAnswerLimitReached and ends that stream. Unbounded types impose no result-count limit. Limits do not aggregate across lookups, types, clones or callers.

Pending lookups still require a caller-owned deadline. This adapter bounds stream consumption, not the wrapped resolver’s internal allocation or work. It does not cache, deduplicate, authorize, or validate records. In particular, service-binding RRset validation remains the inner resolver’s responsibility; a consumer requiring a complete RRset must reject it on a limit error.

Implementations

impl<R> BoundedDnsResolver<R>

pub const fn unbounded(inner: R) -> BoundedDnsResolver<R>

Start without result-count limits. Bound selected types or categories with the builder methods.

pub const fn bounded( inner: R, max_answers: NonZero<usize>, ) -> BoundedDnsResolver<R>

Start with the same positive raw-result limit for every type. Override or remove individual/category limits with the builder methods.

pub fn inner(&self) -> &R

Access the wrapped resolver.

pub fn maybe_with_limit( self, limit: Option<NonZero<usize>>, ) -> BoundedDnsResolver<R>

Set all per-type limits together. None makes every type unbounded. Later individual or category settings replace the affected limits.

pub fn maybe_set_limit( &mut self, limit: Option<NonZero<usize>>, ) -> &mut BoundedDnsResolver<R>

Set all per-type limits together. None makes every type unbounded. Later individual or category settings replace the affected limits.

pub fn with_limit(self, limit: NonZero<usize>) -> BoundedDnsResolver<R>

Set all per-type limits together. None makes every type unbounded. Later individual or category settings replace the affected limits.

pub fn set_limit(&mut self, limit: NonZero<usize>) -> &mut BoundedDnsResolver<R>

Set all per-type limits together. None makes every type unbounded. Later individual or category settings replace the affected limits.

pub fn without_limit(self) -> BoundedDnsResolver<R>

Set all per-type limits together. None makes every type unbounded. Later individual or category settings replace the affected limits.

pub fn unset_limit(&mut self) -> &mut BoundedDnsResolver<R>

Set all per-type limits together. None makes every type unbounded. Later individual or category settings replace the affected limits.

pub fn maybe_with_ipv4_limit( self, limit: Option<NonZero<usize>>, ) -> BoundedDnsResolver<R>

Maximum raw results from each A lookup; None leaves it unbounded.

pub fn maybe_set_ipv4_limit( &mut self, limit: Option<NonZero<usize>>, ) -> &mut BoundedDnsResolver<R>

Maximum raw results from each A lookup; None leaves it unbounded.

pub fn with_ipv4_limit(self, limit: NonZero<usize>) -> BoundedDnsResolver<R>

Maximum raw results from each A lookup; None leaves it unbounded.

pub fn set_ipv4_limit( &mut self, limit: NonZero<usize>, ) -> &mut BoundedDnsResolver<R>

Maximum raw results from each A lookup; None leaves it unbounded.

pub fn without_ipv4_limit(self) -> BoundedDnsResolver<R>

Maximum raw results from each A lookup; None leaves it unbounded.

pub fn unset_ipv4_limit(&mut self) -> &mut BoundedDnsResolver<R>

Maximum raw results from each A lookup; None leaves it unbounded.

pub fn maybe_with_ipv6_limit( self, limit: Option<NonZero<usize>>, ) -> BoundedDnsResolver<R>

Maximum raw results from each AAAA lookup; None leaves it unbounded.

pub fn maybe_set_ipv6_limit( &mut self, limit: Option<NonZero<usize>>, ) -> &mut BoundedDnsResolver<R>

Maximum raw results from each AAAA lookup; None leaves it unbounded.

pub fn with_ipv6_limit(self, limit: NonZero<usize>) -> BoundedDnsResolver<R>

Maximum raw results from each AAAA lookup; None leaves it unbounded.

pub fn set_ipv6_limit( &mut self, limit: NonZero<usize>, ) -> &mut BoundedDnsResolver<R>

Maximum raw results from each AAAA lookup; None leaves it unbounded.

pub fn without_ipv6_limit(self) -> BoundedDnsResolver<R>

Maximum raw results from each AAAA lookup; None leaves it unbounded.

pub fn unset_ipv6_limit(&mut self) -> &mut BoundedDnsResolver<R>

Maximum raw results from each AAAA lookup; None leaves it unbounded.

pub fn maybe_with_cname_limit( self, limit: Option<NonZero<usize>>, ) -> BoundedDnsResolver<R>

Maximum raw results from each CNAME lookup; None leaves it unbounded.

pub fn maybe_set_cname_limit( &mut self, limit: Option<NonZero<usize>>, ) -> &mut BoundedDnsResolver<R>

Maximum raw results from each CNAME lookup; None leaves it unbounded.

pub fn with_cname_limit(self, limit: NonZero<usize>) -> BoundedDnsResolver<R>

Maximum raw results from each CNAME lookup; None leaves it unbounded.

pub fn set_cname_limit( &mut self, limit: NonZero<usize>, ) -> &mut BoundedDnsResolver<R>

Maximum raw results from each CNAME lookup; None leaves it unbounded.

pub fn without_cname_limit(self) -> BoundedDnsResolver<R>

Maximum raw results from each CNAME lookup; None leaves it unbounded.

pub fn unset_cname_limit(&mut self) -> &mut BoundedDnsResolver<R>

Maximum raw results from each CNAME lookup; None leaves it unbounded.

pub fn maybe_with_txt_limit( self, limit: Option<NonZero<usize>>, ) -> BoundedDnsResolver<R>

Maximum raw results from each TXT lookup; None leaves it unbounded.

pub fn maybe_set_txt_limit( &mut self, limit: Option<NonZero<usize>>, ) -> &mut BoundedDnsResolver<R>

Maximum raw results from each TXT lookup; None leaves it unbounded.

pub fn with_txt_limit(self, limit: NonZero<usize>) -> BoundedDnsResolver<R>

Maximum raw results from each TXT lookup; None leaves it unbounded.

pub fn set_txt_limit( &mut self, limit: NonZero<usize>, ) -> &mut BoundedDnsResolver<R>

Maximum raw results from each TXT lookup; None leaves it unbounded.

pub fn without_txt_limit(self) -> BoundedDnsResolver<R>

Maximum raw results from each TXT lookup; None leaves it unbounded.

pub fn unset_txt_limit(&mut self) -> &mut BoundedDnsResolver<R>

Maximum raw results from each TXT lookup; None leaves it unbounded.

pub fn maybe_with_svcb_limit( self, limit: Option<NonZero<usize>>, ) -> BoundedDnsResolver<R>

Maximum raw results from each SVCB lookup; None leaves it unbounded.

pub fn maybe_set_svcb_limit( &mut self, limit: Option<NonZero<usize>>, ) -> &mut BoundedDnsResolver<R>

Maximum raw results from each SVCB lookup; None leaves it unbounded.

pub fn with_svcb_limit(self, limit: NonZero<usize>) -> BoundedDnsResolver<R>

Maximum raw results from each SVCB lookup; None leaves it unbounded.

pub fn set_svcb_limit( &mut self, limit: NonZero<usize>, ) -> &mut BoundedDnsResolver<R>

Maximum raw results from each SVCB lookup; None leaves it unbounded.

pub fn without_svcb_limit(self) -> BoundedDnsResolver<R>

Maximum raw results from each SVCB lookup; None leaves it unbounded.

pub fn unset_svcb_limit(&mut self) -> &mut BoundedDnsResolver<R>

Maximum raw results from each SVCB lookup; None leaves it unbounded.

pub fn maybe_with_https_limit( self, limit: Option<NonZero<usize>>, ) -> BoundedDnsResolver<R>

Maximum raw results from each HTTPS lookup; None leaves it unbounded.

pub fn maybe_set_https_limit( &mut self, limit: Option<NonZero<usize>>, ) -> &mut BoundedDnsResolver<R>

Maximum raw results from each HTTPS lookup; None leaves it unbounded.

pub fn with_https_limit(self, limit: NonZero<usize>) -> BoundedDnsResolver<R>

Maximum raw results from each HTTPS lookup; None leaves it unbounded.

pub fn set_https_limit( &mut self, limit: NonZero<usize>, ) -> &mut BoundedDnsResolver<R>

Maximum raw results from each HTTPS lookup; None leaves it unbounded.

pub fn without_https_limit(self) -> BoundedDnsResolver<R>

Maximum raw results from each HTTPS lookup; None leaves it unbounded.

pub fn unset_https_limit(&mut self) -> &mut BoundedDnsResolver<R>

Maximum raw results from each HTTPS lookup; None leaves it unbounded.

pub fn maybe_with_ip_limit( self, limit: Option<NonZero<usize>>, ) -> BoundedDnsResolver<R>

Set the A and AAAA limits together; each lookup retains its own allowance. None removes both limits; later settings replace the affected limits.

pub fn maybe_set_ip_limit( &mut self, limit: Option<NonZero<usize>>, ) -> &mut BoundedDnsResolver<R>

Set the A and AAAA limits together; each lookup retains its own allowance. None removes both limits; later settings replace the affected limits.

pub fn with_ip_limit(self, limit: NonZero<usize>) -> BoundedDnsResolver<R>

Set the A and AAAA limits together; each lookup retains its own allowance. None removes both limits; later settings replace the affected limits.

pub fn set_ip_limit( &mut self, limit: NonZero<usize>, ) -> &mut BoundedDnsResolver<R>

Set the A and AAAA limits together; each lookup retains its own allowance. None removes both limits; later settings replace the affected limits.

pub fn without_ip_limit(self) -> BoundedDnsResolver<R>

Set the A and AAAA limits together; each lookup retains its own allowance. None removes both limits; later settings replace the affected limits.

pub fn unset_ip_limit(&mut self) -> &mut BoundedDnsResolver<R>

Set the A and AAAA limits together; each lookup retains its own allowance. None removes both limits; later settings replace the affected limits.

pub fn maybe_with_service_binding_limit( self, limit: Option<NonZero<usize>>, ) -> BoundedDnsResolver<R>

Set the SVCB and HTTPS limits together; each lookup retains its own allowance. None removes both limits; later settings replace the affected limits.

pub fn maybe_set_service_binding_limit( &mut self, limit: Option<NonZero<usize>>, ) -> &mut BoundedDnsResolver<R>

Set the SVCB and HTTPS limits together; each lookup retains its own allowance. None removes both limits; later settings replace the affected limits.

pub fn with_service_binding_limit( self, limit: NonZero<usize>, ) -> BoundedDnsResolver<R>

Set the SVCB and HTTPS limits together; each lookup retains its own allowance. None removes both limits; later settings replace the affected limits.

pub fn set_service_binding_limit( &mut self, limit: NonZero<usize>, ) -> &mut BoundedDnsResolver<R>

Set the SVCB and HTTPS limits together; each lookup retains its own allowance. None removes both limits; later settings replace the affected limits.

pub fn without_service_binding_limit(self) -> BoundedDnsResolver<R>

Set the SVCB and HTTPS limits together; each lookup retains its own allowance. None removes both limits; later settings replace the affected limits.

pub fn unset_service_binding_limit(&mut self) -> &mut BoundedDnsResolver<R>

Set the SVCB and HTTPS limits together; each lookup retains its own allowance. None removes both limits; later settings replace the affected limits.

Trait Implementations

impl<R> Clone for BoundedDnsResolver<R>

where R: Clone,

fn clone(&self) -> BoundedDnsResolver<R>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<R> Debug for BoundedDnsResolver<R>

where R: Debug,

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

Formats the value using the given formatter.

impl<R> DnsAddressResolver for BoundedDnsResolver<R>

where R: DnsAddressResolver,

type Error = Box<dyn Error + Send + Sync>

Error returned by the DnsAddressResolver

fn lookup_ipv4( &self, domain: Domain, ) -> impl Stream<Item = Result<Ipv4Addr, <BoundedDnsResolver<R> as DnsAddressResolver>::Error>> + Send

Resolve the ‘A’ records accessible by this resolver for the given Domain into Ipv4Addresses.

fn lookup_ipv6( &self, domain: Domain, ) -> impl Stream<Item = Result<Ipv6Addr, <BoundedDnsResolver<R> as DnsAddressResolver>::Error>> + Send

Resolve the ‘AAAA’ records accessible by this resolver for the given Domain into Ipv6Addresses.

fn lookup_ipv4_first( &self, domain: Domain, ) -> impl Future<Output = Option<Result<Ipv4Addr, Self::Error>>> + Send

Resolve the first ‘A’ record found for the resolver.

fn lookup_ipv4_rand( &self, domain: Domain, ) -> impl Future<Output = Option<Result<Ipv4Addr, Self::Error>>> + Send

Resolve to a pseudo-random ‘A’ record found for the resolver.

fn lookup_ipv6_first( &self, domain: Domain, ) -> impl Future<Output = Option<Result<Ipv6Addr, Self::Error>>> + Send

Resolve the first ‘AAAA’ record found for the resolver.

fn lookup_ipv6_rand( &self, domain: Domain, ) -> impl Future<Output = Option<Result<Ipv6Addr, Self::Error>>> + Send

Resolve to a pseudo-random ‘AAAA’ record found for the resolver.

fn into_box_dns_address_resolver(self) -> BoxDnsAddressResolver

Box this resolver to allow for dynamic dispatch.

impl<R> DnsCnameResolver for BoundedDnsResolver<R>

where R: DnsCnameResolver,

type Error = Box<dyn Error + Send + Sync>

Error returned by this resolver.

fn lookup_cname( &self, domain: Domain, ) -> impl Stream<Item = Result<Name, <BoundedDnsResolver<R> as DnsCnameResolver>::Error>> + Send

Resolve CNAME targets for the given domain.

fn into_box_dns_cname_resolver(self) -> BoxDnsCnameResolver

Box this resolver to allow dynamic dispatch.

impl<R> DnsResolver for BoundedDnsResolver<R>

where R: DnsResolver,

fn into_box_dns_resolver(self) -> BoxDnsResolver

where Self: Sized,

Box this aggregate resolver for dynamic dispatch.

impl<R> DnsServiceBindingResolver for BoundedDnsResolver<R>

where R: DnsServiceBindingResolver,

type Error = Box<dyn Error + Send + Sync>

Error returned by this resolver.

fn lookup_svcb( &self, domain: Domain, ) -> impl Stream<Item = Result<ServiceBinding, <BoundedDnsResolver<R> as DnsServiceBindingResolver>::Error>> + Send

Resolve the complete SVCB RRset for the given domain.

fn lookup_https( &self, domain: Domain, ) -> impl Stream<Item = Result<ServiceBinding, <BoundedDnsResolver<R> as DnsServiceBindingResolver>::Error>> + Send

Resolve the complete HTTPS RRset for the given domain.

fn into_box_dns_service_binding_resolver(self) -> BoxDnsServiceBindingResolver

Box this resolver to allow dynamic dispatch.

impl<R> DnsTxtResolver for BoundedDnsResolver<R>

where R: DnsTxtResolver,

type Error = Box<dyn Error + Send + Sync>

Error returned by the DnsTxtResolver

fn lookup_txt( &self, domain: Domain, ) -> impl Stream<Item = Result<Txt, <BoundedDnsResolver<R> as DnsTxtResolver>::Error>> + Send

Resolve the TXT records accessible for the given Domain.

fn into_box_dns_txt_resolver(self) -> BoxDnsTxtResolver

Box this resolver to allow for dynamic dispatch.