Struct trust_dns::client::SecureClientHandle

#[must_use = "queries can only be sent through a ClientHandle"]
pub struct SecureClientHandle<H: ClientHandle + 'static> { /* fields omitted */ }

Performs DNSSec validation of all DNS responses from the wrapped ClientHandle

This wraps a ClientHandle, changing the implementation send() to validate all message responses for Query operations. Update operation responses are not validated by this process.

Methods

impl<H> SecureClientHandle<H> where
    H: ClientHandle + 'static, 

fn new(client: H) -> SecureClientHandle<H>

Create a new SecureClientHandle wrapping the speicified client.

This uses the compiled in TrustAnchor default trusted keys.

Arguments

• client - client to use for all connections to a remote server.

fn with_trust_anchor(
    client: H,
    trust_anchor: TrustAnchor
) -> SecureClientHandle<H>

Create a new SecureClientHandle wrapping the speicified client.

This allows a custom TrustAnchor to be define.

Arguments

• client - client to use for all connections to a remote server.
• trust_anchor - custom DNSKEYs that will be trusted, can be used to pin trusted keys.

Trait Implementations

impl<H: Clone + ClientHandle + 'static> Clone for SecureClientHandle<H>

fn clone(&self) -> SecureClientHandle<H>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<H> ClientHandle for SecureClientHandle<H> where
    H: ClientHandle + 'static, 

fn is_verifying_dnssec(&self) -> bool

Ony returns true if and only if this client is validating DNSSec.

fn send(
    &mut self,
    message: Message
) -> Box<Future<Item = Message, Error = ClientError>>

Send a message via the channel in the client

fn lookup(
    &mut self,
    query: Query
) -> Box<Future<Item = Message, Error = ClientError>>

A classic DNS query

fn query(
    &mut self,
    name: Name,
    query_class: DNSClass,
    query_type: RecordType
) -> Box<Future<Item = Message, Error = ClientError>>

A classic DNS query

fn notify<R>(
    &mut self,
    name: Name,
    query_class: DNSClass,
    query_type: RecordType,
    rrset: Option<R>
) -> Box<Future<Item = Message, Error = ClientError>> where
    R: IntoRecordSet, 

Sends a NOTIFY message to the remote system

fn create<R>(
    &mut self,
    rrset: R,
    zone_origin: Name
) -> Box<Future<Item = Message, Error = ClientError>> where
    R: IntoRecordSet, 

Sends a record to create on the server, this will fail if the record exists (atomicity depends on the server)

fn append<R>(
    &mut self,
    rrset: R,
    zone_origin: Name,
    must_exist: bool
) -> Box<Future<Item = Message, Error = ClientError>> where
    R: IntoRecordSet, 

Appends a record to an existing rrset, optionally require the rrset to exis (atomicity depends on the server)

fn compare_and_swap<C, N>(
    &mut self,
    current: C,
    new: N,
    zone_origin: Name
) -> Box<Future<Item = Message, Error = ClientError>> where
    C: IntoRecordSet,
    N: IntoRecordSet, 

Compares and if it matches, swaps it for the new value (atomicity depends on the server)

fn delete_by_rdata<R>(
    &mut self,
    rrset: R,
    zone_origin: Name
) -> Box<Future<Item = Message, Error = ClientError>> where
    R: IntoRecordSet, 

Deletes a record (by rdata) from an rrset, optionally require the rrset to exist.

fn delete_rrset(
    &mut self,
    record: Record,
    zone_origin: Name
) -> Box<Future<Item = Message, Error = ClientError>>

Deletes an entire rrset, optionally require the rrset to exist.

fn delete_all(
    &mut self,
    name_of_records: Name,
    zone_origin: Name,
    dns_class: DNSClass
) -> Box<Future<Item = Message, Error = ClientError>>

Deletes all records at the specified name