Struct hickory_proto::rr::resource::Record

pub struct Record<R: RecordData = RData> { /* private fields */ }

Resource records are storage value in DNS, into which all key/value pair data is stored.

Generic type

• R - the RecordData type this resource record represents, if unknown at runtime use the RData abstract enum type

RFC 1035, DOMAIN NAMES - IMPLEMENTATION AND SPECIFICATION, November 1987

4.1.3. Resource record format

The answer, authority, and additional sections all share the same
format: a variable number of resource records, where the number of
records is specified in the corresponding count field in the header.
Each resource record has the following format:
                                    1  1  1  1  1  1
      0  1  2  3  4  5  6  7  8  9  0  1  2  3  4  5
    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
    |                                               |
    /                                               /
    /                      NAME                     /
    |                                               |
    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
    |                      TYPE                     |
    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
    |                     CLASS                     |
    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
    |                      TTL                      |
    |                                               |
    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
    |                   RDLENGTH                    |
    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--|
    /                     RDATA                     /
    /                                               /
    +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+

Implementations

impl Record

pub fn update0(name: Name, ttl: u32, rr_type: RecordType) -> Self

Creates an update record with RDLENGTH=0

pub fn try_borrow<T>(&self) -> Option<RecordRef<'_, T>>

where T: RecordData,

Tries the borrow this record as the specific record type, T

impl<R: RecordData> Record<R>

pub fn from_rdata(name: Name, ttl: u32, rdata: R) -> Self

Create a record with the specified initial values.

Arguments

• name - name of the resource records
• ttl - time-to-live is the amount of time this record should be cached before refreshing
• rdata - record data to associate with the Record

pub fn try_from(record: Record<RData>) -> Result<Self, Record<RData>>

Attempts to convert the generic RData based Record into this one with the interior R

pub fn into_record_of_rdata(self) -> Record<RData>

Converts this Record into a generic version of RData

pub fn set_name(&mut self, name: Name) -> &mut Self

NAME            a domain name to which this resource record pertains.

pub fn set_dns_class(&mut self, dns_class: DNSClass) -> &mut Self

CLASS           two octets which specify the class of the data in the
                RDATA field.

pub fn set_ttl(&mut self, ttl: u32) -> &mut Self

TTL             a 32 bit unsigned integer that specifies the time
                interval (in seconds) that the resource record may be
                cached before it should be discarded.  Zero values are
                interpreted to mean that the RR can only be used for the
                transaction in progress, and should not be cached.

pub fn set_data(&mut self, rdata: R) -> &mut Self

RDATA           a variable length string of octets that describes the
                resource.  The format of this information varies
                according to the TYPE and CLASS of the resource record.
                For example, the if the TYPE is A and the CLASS is IN,
                the RDATA field is a 4 octet ARPA Internet address.

pub fn set_mdns_cache_flush(&mut self, flag: bool) -> &mut Self

Available on crate feature mdns only.

Changes mDNS cache-flush bit See RFC 6762

pub fn set_proof(&mut self, proof: Proof) -> &mut Self

Available on crate feature dnssec only.

Set the DNSSEC Proof for this record, after it’s been verified

pub fn name(&self) -> &Name

Returns the name of the record

pub fn record_type(&self) -> RecordType

Returns the type of the RecordData in the record

pub fn dns_class(&self) -> DNSClass

Returns the DNSClass of the Record, generally IN fro internet

pub fn ttl(&self) -> u32

Returns the time-to-live of the record, for caching purposes

pub fn data(&self) -> &R

Returns the Record Data, i.e. the record information

pub fn data_mut(&mut self) -> &mut R

Returns a mutable reference to the Record Data

pub fn into_data(self) -> R

Returns the RData consuming the Record

pub fn into_parts(self) -> RecordParts

Consumes Record and returns its components

pub fn mdns_cache_flush(&self) -> bool

Available on crate feature mdns only.

Returns if the mDNS cache-flush bit is set or not See RFC 6762

pub fn proof(&self) -> Proof

Available on crate feature dnssec only.

The Proof of DNSSEC validation for this record, this is only valid if some form of validation has occurred

Trait Implementations

impl<'r> BinDecodable<'r> for Record<RData>

fn read(decoder: &mut BinDecoder<'r>) -> ProtoResult<Self>

parse a resource record line example: WARNING: the record_bytes is 100% consumed and destroyed in this parsing process

fn from_bytes(bytes: &'r [u8]) -> ProtoResult<Self>

Returns the object in binary form

impl<R: RecordData> BinEncodable for Record<R>

fn emit(&self, encoder: &mut BinEncoder<'_>) -> ProtoResult<()>

Write the type to the stream

fn to_bytes(&self) -> ProtoResult<Vec<u8>>

Returns the object in binary form

impl<R: Clone + RecordData> Clone for Record<R>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<R: Debug + RecordData> Debug for Record<R>

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

Formats the value using the given formatter.

impl<'de, R> Deserialize<'de> for Record<R>

where R: Deserialize<'de> + RecordData,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<R: RecordData> Display for Record<R>

RFC 1033, DOMAIN OPERATIONS GUIDE, November 1987

  RESOURCE RECORDS

  Records in the zone data files are called resource records (RRs).
  They are specified in RFC-883 and RFC-973.  An RR has a standard
  format as shown:

          <name>   [<ttl>]   [<class>]   <type>   <data>

  The record is divided into fields which are separated by white space.

     <name>

        The name field defines what domain name applies to the given
        RR.  In some cases the name field can be left blank and it will
        default to the name field of the previous RR.

     <ttl>

        TTL stands for Time To Live.  It specifies how long a domain
        resolver should cache the RR before it throws it out and asks a
        domain server again.  See the section on TTL's.  If you leave
        the TTL field blank it will default to the minimum time
        specified in the SOA record (described later).

     <class>

        The class field specifies the protocol group.  If left blank it
        will default to the last class specified.

     <type>

        The type field specifies what type of data is in the RR.  See
        the section on types.

     <data>

        The data field is defined differently for each type and class
        of data.  Popular RR data formats are described later.

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

Formats the value using the given formatter.

impl<'a> From<&'a Edns> for Record

fn from(value: &'a Edns) -> Self

This returns a Resource Record that is formatted for Edns(0). Note: the rcode_high value is only part of the rcode, the rest is part of the base

impl<'a> From<&'a Record> for Edns

fn from(value: &'a Record) -> Self

Converts to this type from the input type.

impl<'a> From<&'a Record> for Proven<&'a Record>

fn from(record: &'a Record) -> Self

Converts to this type from the input type.

impl<R: RecordData> From<Record<R>> for RecordParts<R>

fn from(record: Record<R>) -> Self

Converts to this type from the input type.

impl From<Record> for Proven<Record>

fn from(record: Record) -> Self

Converts to this type from the input type.

impl From<Record> for RecordSet

fn from(record: Record) -> Self

Converts to this type from the input type.

impl IntoRecordSet for Record

fn into_record_set(self) -> RecordSet

👎Deprecated: use From/Into

Performs the conversion to a RecordSet

impl Ord for Record

fn cmp(&self, other: &Self) -> Ordering

Canonical ordering as defined by RFC 4034, DNSSEC Resource Records, March 2005

6.2.  Canonical RR Form

   For the purposes of DNS security, the canonical form of an RR is the
   wire format of the RR where:

   1.  every domain name in the RR is fully expanded (no DNS name
       compression) and fully qualified;

   2.  all uppercase US-ASCII letters in the owner name of the RR are
       replaced by the corresponding lowercase US-ASCII letters;

   3.  if the type of the RR is NS, MD, MF, CNAME, SOA, MB, MG, MR, PTR,
       HINFO, MINFO, MX, HINFO, RP, AFSDB, RT, SIG, PX, NXT, NAPTR, KX,
       SRV, DNAME, A6, RRSIG, or NSEC, all uppercase US-ASCII letters in
       the DNS names contained within the RDATA are replaced by the
       corresponding lowercase US-ASCII letters;

   4.  if the owner name of the RR is a wildcard name, the owner name is
       in its original unexpanded form, including the "*" label (no
       wildcard substitution); and

   5.  the RR's TTL is set to its original value as it appears in the
       originating authoritative zone or the Original TTL field of the
       covering RRSIG RR.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl<R: RecordData> PartialEq for Record<R>

fn eq(&self, other: &Self) -> bool

Equality or records, as defined by RFC 2136, DNS Update, April 1997

  1.1.1. Two RRs are considered equal if their NAME, CLASS, TYPE,
  RDLENGTH and RDATA fields are equal.  Note that the time-to-live
  (TTL) field is explicitly excluded from the comparison.

  1.1.2. The rules for comparison of character strings in names are
  specified in [RFC1035 2.3.3]. i.e. case insensitive

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Record

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

Canonical ordering as defined by RFC 4034, DNSSEC Resource Records, March 2005

6.2.  Canonical RR Form

   For the purposes of DNS security, the canonical form of an RR is the
   wire format of the RR where:

   1.  every domain name in the RR is fully expanded (no DNS name
       compression) and fully qualified;

   2.  all uppercase US-ASCII letters in the owner name of the RR are
       replaced by the corresponding lowercase US-ASCII letters;

   3.  if the type of the RR is NS, MD, MF, CNAME, SOA, MB, MG, MR, PTR,
       HINFO, MINFO, MX, HINFO, RP, AFSDB, RT, SIG, PX, NXT, NAPTR, KX,
       SRV, DNAME, A6, RRSIG, or NSEC, all uppercase US-ASCII letters in
       the DNS names contained within the RDATA are replaced by the
       corresponding lowercase US-ASCII letters;

   4.  if the owner name of the RR is a wildcard name, the owner name is
       in its original unexpanded form, including the "*" label (no
       wildcard substitution); and

   5.  the RR's TTL is set to its original value as it appears in the
       originating authoritative zone or the Original TTL field of the
       covering RRSIG RR.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<R> Serialize for Record<R>

where R: Serialize + RecordData,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a, R: RecordData> TryFrom<&'a Record> for RecordRef<'a, R>

type Error = &'a Record

The type returned in the event of a conversion error.

fn try_from(record: &'a Record) -> Result<Self, Self::Error>

Performs the conversion.

impl<R: Eq + RecordData> Eq for Record<R>