Struct trust_dns::client::SecureSyncClient

pub struct SecureSyncClient { /* fields omitted */ }

A DNS client which will validate DNSSec records upon receipt

Methods

impl SecureSyncClient

fn new<CC>(client_connection: CC) -> SecureSyncClientBuilder<CC> where
    CC: ClientConnection,
    <CC as ClientConnection>::MessageStream: Stream<Item = Vec<u8>, Error = Error> + 'static, 

Creates a new DNS client with the specified connection type

Arguments

• client_connection - the client_connection to use for all communication

fn secure_query(
    &self,
    query_name: &Name,
    query_class: DNSClass,
    query_type: RecordType
) -> ClientResult<Message>

Deprecated

DNSSec validating query, this will return an error if the requested records can not be validated against the trust_anchor.

Deprecated This function only exists for backward compatibility. It's just a wrapper around Client::query at this point

When the resolver receives an answer via the normal DNS lookup process, it then checks to make sure that the answer is correct. Then starts with verifying the DS and DNSKEY records at the DNS root. Then use the DS records for the top level domain found at the root, e.g. 'com', to verify the DNSKEY records in the 'com' zone. From there see if there is a DS record for the subdomain, e.g. 'example.com', in the 'com' zone, and if there is use the DS record to verify a DNSKEY record found in the 'example.com' zone. Finally, verify the RRSIG record found in the answer for the rrset, e.g. 'www.example.com'.

Note As of now, this will not recurse on PTR or CNAME record responses, that is up to the caller.

Arguments

• query_name - the label to lookup
• query_class - most likely this should always be DNSClass::IN
• query_type - record type to lookup

Trait Implementations

impl Client<SecureClientHandle<BasicClientHandle>> for SecureSyncClient

fn get_io_loop(&self) -> RefMut<Core>

get a mutable reference to the tokio Core associated to the Client

fn get_client_handle(&self) -> RefMut<SecureClientHandle<BasicClientHandle>>

Get a mutable handle reference tot the Core assiated to the Client

fn query(
    &self,
    name: &Name,
    query_class: DNSClass,
    query_type: RecordType
) -> ClientResult<Message>

A classic DNS query, i.e. does not perform and DNSSec operations

fn notify<R>(
    &mut self,
    name: Name,
    query_class: DNSClass,
    query_type: RecordType,
    rrset: Option<R>
) -> ClientResult<Message> where
    R: IntoRecordSet, 

Sends a NOTIFY message to the remote system

fn create<R>(&self, rrset: R, zone_origin: Name) -> ClientResult<Message> 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>(
    &self,
    rrset: R,
    zone_origin: Name,
    must_exist: bool
) -> ClientResult<Message> 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<CR, NR>(
    &self,
    current: CR,
    new: NR,
    zone_origin: Name
) -> ClientResult<Message> where
    CR: IntoRecordSet,
    NR: IntoRecordSet, 

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

fn delete_by_rdata<R>(
    &self,
    record: R,
    zone_origin: Name
) -> ClientResult<Message> where
    R: IntoRecordSet, 

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

fn delete_rrset(
    &self,
    record: Record,
    zone_origin: Name
) -> ClientResult<Message>

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

fn delete_all(
    &self,
    name_of_records: Name,
    zone_origin: Name,
    dns_class: DNSClass
) -> ClientResult<Message>

Deletes all records at the specified name