Struct Ptr 

#[repr(transparent)]
pub struct Ptr<N> {
    pub name: N,
}

Available on crate feature unstable-new only.

A pointer to another domain name.

A Ptr record is used with special domain names for pointing to other locations in the domain name space. It is conventionally used for reverse lookups: for example, the Ptr record for <addr>.in-addr.arpa points to the domain name using the IPv4 <addr> in an A record. The same technique works with <addr>.ip6.arpa for IPv6 addresses.

Ptr is specified by RFC 1035, section 3.3.12.

Wire format

The wire format of a Ptr record is simply the domain name of the name server. This domain name may be compressed in DNS messages.

Usage

Because Ptr is a record data type, it is usually handled within an enum like RecordData. This section describes how to use it independently (or when building new record data from scratch).

In order to build a Ptr, it’s first important to choose a domain name type. For short-term usage (where the Ptr is a local variable), it is common to pick RevNameBuf. If the Ptr will be placed on the heap, Box<RevName> will be more efficient.

The primary way to build a new Ptr is to construct each field manually. To parse a Ptr from a DNS message, use ParseMessageBytes. In case the input bytes don’t use name compression, ParseBytes can be used.

// Build a 'Ptr' manually:
let manual: Ptr<RevNameBuf> = Ptr {
    name: "example.org.".parse().unwrap(),
};

// Its wire format serialization looks like:
let bytes = b"\x07example\x03org\x00";

// Parse a 'Ptr' from the wire format, without name decompression:
let from_wire: Ptr<RevNameBuf> = Ptr::parse_bytes(bytes).unwrap();

// See 'ParseMessageBytes' for parsing with name decompression.

Since Ptr is a sized type, and it implements Copy and Clone, it’s straightforward to handle and move around. However, this depends on the domain name type. It can be changed using Ptr::map_name() and Ptr::map_name_by_ref().

For debugging, Ptr can be formatted using fmt::Debug.

To serialize a Ptr in the wire format, use BuildInMessage (which supports name compression). If name compression is not desired, use BuildBytes.

Fields

name: N

The referenced domain name.

Implementations

impl<N> Ptr<N>

pub fn map_name<R, F: FnOnce(N) -> R>(self, f: F) -> Ptr<R>

Map the domain name within to another type.

pub fn map_name_by_ref<'r, R, F: FnOnce(&'r N) -> R>(&'r self, f: F) -> Ptr<R>

Map a reference to the domain name within to another type.

Trait Implementations

impl<N> BuildBytes for Ptr<N>

where N: BuildBytes,

fn build_bytes<'bytes>( &self, bytes: &'bytes mut [u8], ) -> Result<&'bytes mut [u8], TruncationError>

Serialize into a byte sequence.

fn built_bytes_size(&self) -> usize

The size of self when serialized into a byte sequence.

impl<N: BuildInMessage> BuildInMessage for Ptr<N>

fn build_in_message( &self, contents: &mut [u8], start: usize, compressor: &mut NameCompressor, ) -> Result<usize, TruncationError>

Write this object in a DNS message.

impl<N: CanonicalName> CanonicalRecordData for Ptr<N>

fn build_canonical_bytes<'b>( &self, bytes: &'b mut [u8], ) -> Result<&'b mut [u8], TruncationError>

Serialize record data in the canonical form.

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

Compare record data in the canonical form.

impl<N: Clone> Clone for Ptr<N>

fn clone(&self) -> Ptr<N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<N: Copy> Copy for Ptr<N>

impl<N: Debug> Debug for Ptr<N>

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

Formats the value using the given formatter.

impl<N: Eq> Eq for Ptr<N>

impl<'a, N> From<Ptr<N>> for RecordData<'a, N>

fn from(value: Ptr<N>) -> Self

Converts to this type from the input type.

impl<N: Hash> Hash for Ptr<N>

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<N: Ord> Ord for Ptr<N>

fn cmp(&self, other: &Ptr<N>) -> Ordering

This method returns an Ordering between self and other.

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,

Restrict a value to a certain interval.

impl<'bytes, N> ParseBytes<'bytes> for Ptr<N>

where N: ParseBytes<'bytes>,

fn parse_bytes(bytes: &'bytes [u8]) -> Result<Self, ParseError>

Parse a value of Self from the given byte sequence.

impl<'a, N: ParseMessageBytes<'a>> ParseMessageBytes<'a> for Ptr<N>

fn parse_message_bytes( contents: &'a [u8], start: usize, ) -> Result<Self, ParseError>

Parse a value from bytes in a DNS message.

impl<'a, N: ParseMessageBytes<'a>> ParseRecordData<'a> for Ptr<N>

fn parse_record_data( contents: &'a [u8], start: usize, rtype: RType, ) -> Result<Self, ParseError>

Parse DNS record data of the given type from a DNS message.

impl<'a, N: ParseBytes<'a>> ParseRecordDataBytes<'a> for Ptr<N>

fn parse_record_data_bytes( bytes: &'a [u8], rtype: RType, ) -> Result<Self, ParseError>

Parse DNS record data of the given type from a byte sequence.

impl<N: PartialEq> PartialEq for Ptr<N>

fn eq(&self, other: &Ptr<N>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<N: PartialOrd> PartialOrd for Ptr<N>

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

This method returns an ordering between self and other values if one exists.

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<'bytes, N> SplitBytes<'bytes> for Ptr<N>

where N: SplitBytes<'bytes>,

fn split_bytes(bytes: &'bytes [u8]) -> Result<(Self, &'bytes [u8]), ParseError>

Parse a value of Self from the start of the byte sequence.

impl<N: PartialEq> StructuralPartialEq for Ptr<N>