Struct trust_dns_proto::rr::rdata::naptr::NAPTR

pub struct NAPTR { /* private fields */ }

RFC 3403 DDDS DNS Database, October 2002

4.1 Packet Format

  The packet format of the NAPTR RR is given below.  The DNS type code
  for NAPTR is 35.

     The packet format for the NAPTR record is as follows
                                      1  1  1  1  1  1
        0  1  2  3  4  5  6  7  8  9  0  1  2  3  4  5
      +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
      |                     ORDER                     |
      +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
      |                   PREFERENCE                  |
      +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
      /                     FLAGS                     /
      +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
      /                   SERVICES                    /
      +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
      /                    REGEXP                     /
      +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
      /                  REPLACEMENT                  /
      /                                               /
      +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+

  <character-string> and <domain-name> as used here are defined in RFC
  1035 [7].

Implementations

impl NAPTR

pub fn new(
    order: u16,
    preference: u16,
    flags: Box<[u8]>,
    services: Box<[u8]>,
    regexp: Box<[u8]>,
    replacement: Name
) -> Self

Constructs a new NAPTR record

Arguments

• order - the order in which the NAPTR records MUST be processed in order to accurately represent the ordered list of Rules.
• preference - this field is equivalent to the Priority value in the DDDS Algorithm.
• flags - flags to control aspects of the rewriting and interpretation of the fields in the record. Flags are single characters from the set A-Z and 0-9.
• services - the Service Parameters applicable to this this delegation path.
• regexp - substitution expression that is applied to the original string held by the client in order to construct the next domain name to lookup.
• replacement - the next domain-name to query for depending on the potential values found in the flags field.

pub fn order(&self) -> u16

  ORDER
     A 16-bit unsigned integer specifying the order in which the NAPTR
     records MUST be processed in order to accurately represent the
     ordered list of Rules.  The ordering is from lowest to highest.
     If two records have the same order value then they are considered
     to be the same rule and should be selected based on the
     combination of the Preference values and Services offered.

pub fn preference(&self) -> u16

  PREFERENCE
     Although it is called "preference" in deference to DNS
     terminology, this field is equivalent to the Priority value in the
     DDDS Algorithm.  It is a 16-bit unsigned integer that specifies
     the order in which NAPTR records with equal Order values SHOULD be
     processed, low numbers being processed before high numbers.  This
     is similar to the preference field in an MX record, and is used so
     domain administrators can direct clients towards more capable
     hosts or lighter weight protocols.  A client MAY look at records
     with higher preference values if it has a good reason to do so
     such as not supporting some protocol or service very well.

     The important difference between Order and Preference is that once
     a match is found the client MUST NOT consider records with a
     different Order but they MAY process records with the same Order
     but different Preferences.  The only exception to this is noted in
     the second important Note in the DDDS algorithm specification
     concerning allowing clients to use more complex Service
     determination between steps 3 and 4 in the algorithm.  Preference
     is used to give communicate a higher quality of service to rules
     that are considered the same from an authority standpoint but not
     from a simple load balancing standpoint.

     It is important to note that DNS contains several load balancing
     mechanisms and if load balancing among otherwise equal services
     should be needed then methods such as SRV records or multiple A
     records should be utilized to accomplish load balancing.

pub fn flags(&self) -> &[u8]

  FLAGS
     A <character-string> containing flags to control aspects of the
     rewriting and interpretation of the fields in the record.  Flags
     are single characters from the set A-Z and 0-9.  The case of the
     alphabetic characters is not significant.  The field can be empty.

     It is up to the Application specifying how it is using this
     Database to define the Flags in this field.  It must define which
     ones are terminal and which ones are not.

pub fn services(&self) -> &[u8]

  SERVICES
     A <character-string> that specifies the Service Parameters
     applicable to this this delegation path.  It is up to the
     Application Specification to specify the values found in this
     field.

pub fn regexp(&self) -> &[u8]

  REGEXP
     A <character-string> containing a substitution expression that is
     applied to the original string held by the client in order to
     construct the next domain name to lookup.  See the DDDS Algorithm
     specification for the syntax of this field.

     As stated in the DDDS algorithm, The regular expressions MUST NOT
     be used in a cumulative fashion, that is, they should only be
     applied to the original string held by the client, never to the
     domain name p  roduced by a previous NAPTR rewrite.  The latter is
     tempting in some applications but experience has shown such use to
     be extremely fault sensitive, very error prone, and extremely
     difficult to debug.

pub fn replacement(&self) -> &Name

  REPLACEMENT
     A <domain-name> which is the next domain-name to query for
     depending on the potential values found in the flags field.  This
     field is used when the regular expression is a simple replacement
     operation.  Any value in this field MUST be a fully qualified
     domain-name.  Name compression is not to be used for this field.

     This field and the REGEXP field together make up the Substitution
     Expression in the DDDS Algorithm.  It is simply a historical
     optimization specifically for DNS compression that this field
     exists.  The fields are also mutually exclusive.  If a record is
     returned that has values for both fields then it is considered to
     be in error and SHOULD be either ignored or an error returned.

Trait Implementations

impl Clone for NAPTR

fn clone(&self) -> NAPTR

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for NAPTR

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for NAPTR

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Display for NAPTR

RFC 2915, NAPTR DNS RR, September 2000

Master File Format

  The master file format follows the standard rules in RFC-1035 [1].
  Order and preference, being 16-bit unsigned integers, shall be an
  integer between 0 and 65535.  The Flags and Services and Regexp
  fields are all quoted <character-string>s.  Since the Regexp field
  can contain numerous backslashes and thus should be treated with
  care.  See Section 10 for how to correctly enter and escape the
  regular expression.

;;      order pref flags service           regexp replacement
IN NAPTR 100  50  "a"    "z3950+N2L+N2C"     ""   cidserver.example.com.
IN NAPTR 100  50  "a"    "rcds+N2C"          ""   cidserver.example.com.
IN NAPTR 100  50  "s"    "http+N2L+N2C+N2R"  ""   www.example.com.

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

Formats the value using the given formatter.

impl Hash for NAPTR

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl PartialEq<NAPTR> for NAPTR

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl Serialize for NAPTR

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

Serialize this value into the given Serde serializer.

impl Eq for NAPTR

impl StructuralEq for NAPTR

impl StructuralPartialEq for NAPTR