Struct trust_dns::rr::domain::Name

pub struct Name { /* fields omitted */ }

TODO: all Names should be stored in a global "intern" space, and then everything that uses them should be through references. As a workaround the Strings are all Rc as well as the array TODO: Currently this probably doesn't support binary names, it would be nice to do that.

Methods

impl Name

fn new() -> Self

Create a new domain::Name, i.e. label

fn root() -> Self

Returns the root label, i.e. no labels, can probably make this better in the future.

fn is_root(&self) -> bool

Returns true if there are no labels, i.e. it's empty.

In DNS the root is represented by .

Examples

use trust_dns::rr::domain::Name;

let root = Name::root();
assert_eq!(&root.to_string(), ".");

fn label(self, label: &'static str) -> Self

inline builder

fn with_labels(labels: Vec<String>) -> Self

for mutating over time

fn prepend_label(&self, label: Rc<String>) -> Self

prepend the String to the label

fn add_label(&mut self, label: Rc<String>) -> &mut Self

appends the String to this label at the end

fn append(&mut self, other: &Self) -> &mut Self

appends the other to this name

fn to_lowercase(&self) -> Name

Creates a new Name with all labels lowercased

Examples

use trust_dns::rr::domain::Name;
use std::cmp::Ordering;

let example_com = Name::new().label("Example").label("Com");
assert_eq!(example_com.to_lowercase().cmp_with_case(&Name::new().label("example").label("com"), false), Ordering::Equal);

fn base_name(&self) -> Name

Trims off the first part of the name, to help with searching for the domain piece

Examples

use trust_dns::rr::domain::Name;

let example_com = Name::new().label("example").label("com");
assert_eq!(example_com.base_name(), Name::new().label("com"));
assert_eq!(Name::new().label("com").base_name(), Name::root());
assert_eq!(Name::root().base_name(), Name::root());

fn trim_to(&self, num_labels: usize) -> Name

Trims to the number of labels specified

Examples

use trust_dns::rr::domain::Name;

let example_com = Name::new().label("example").label("com");
assert_eq!(example_com.trim_to(2), Name::new().label("example").label("com"));
assert_eq!(example_com.trim_to(1), Name::new().label("com"));
assert_eq!(example_com.trim_to(0), Name::root());

fn zone_of(&self, name: &Self) -> bool

returns true if the name components of self are all present at the end of name

fn num_labels(&self) -> u8

Returns the number of labels in the name, discounting *.

Examples

use trust_dns::rr::domain::Name;

let root = Name::root();
assert_eq!(root.num_labels(), 0);

let example_com = Name::new().label("example").label("com");
assert_eq!(example_com.num_labels(), 2);

let star_example_com = Name::new().label("*").label("example").label("com");
assert_eq!(star_example_com.num_labels(), 2);

fn len(&self) -> usize

returns the length in bytes of the labels. '.' counts as 1

This can be used as an estimate, when serializing labels, they will often be compressed and/or escaped causing the exact length to be different.

fn parse(local: &str, origin: Option<&Self>) -> ParseResult<Self>

attempts to parse a name such as "example.com." or "subdomain.example.com."

Examples

use trust_dns::rr::domain::Name;

let name = Name::parse("example.com.", None).unwrap();
assert_eq!(name.base_name(), Name::new().label("com"));
assert_eq!(*name[0], String::from("example"));

fn emit_as_canonical(
    &self,
    encoder: &mut BinEncoder,
    canonical: bool
) -> EncodeResult

Emits the canonical version of the name to the encoder.

In canonical form, there will be no pointers written to the encoder (i.e. no compression).

fn emit_with_lowercase(
    &self,
    encoder: &mut BinEncoder,
    lowercase: bool
) -> EncodeResult

Writes the labels, as lower case, to the encoder

fn cmp_with_case(&self, other: &Self, ignore_case: bool) -> Ordering

compares with the other label, ignoring case

fn to_string(&self) -> String

Converts the Name labels to the String form.

This converts the name to an unescaped format, that could be used with parse. The name is is followed by the final ., e.g. as in www.example.com., which represents a fully qualified Name.

Trait Implementations

impl Debug for Name

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Eq for Name

impl Clone for Name

fn clone(&self) -> Name

Returns a copy of the value.

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

Performs copy-assignment from source.

impl From<IpAddr> for Name

fn from(addr: IpAddr) -> Name

Performs the conversion.

impl From<Ipv4Addr> for Name

fn from(addr: Ipv4Addr) -> Name

Performs the conversion.

impl From<Ipv6Addr> for Name

fn from(addr: Ipv6Addr) -> Name

Performs the conversion.

impl Hash for Name

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

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<Name> for Name

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

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

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

This method tests for !=.

impl BinSerializable<Name> for Name

fn read(decoder: &mut BinDecoder) -> DecodeResult<Name>

parses the chain of labels this has a max of 255 octets, with each label being less than 63. all names will be stored lowercase internally. This will consume the portions of the Vec which it is reading...

fn emit(&self, encoder: &mut BinEncoder) -> EncodeResult

Write the type to the stream

impl Display for Name

FIXME: this needs to escape characters in the labels.

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

Formats the value using the given formatter.

impl Index<usize> for Name

type Output = String

The returned type after indexing

fn index<'a>(&'a self, _index: usize) -> &'a String

The method for the indexing (container[index]) operation

impl PartialOrd<Name> for Name

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

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

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl Ord for Name

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

RFC 4034 DNSSEC Resource Records March 2005

6.1.  Canonical DNS Name Order

 For the purposes of DNS security, owner names are ordered by treating
 individual labels as unsigned left-justified octet strings.  The
 absence of a octet sorts before a zero value octet, and uppercase
 US-ASCII letters are treated as if they were lowercase US-ASCII
 letters.

 To compute the canonical ordering of a set of DNS names, start by
 sorting the names according to their most significant (rightmost)
 labels.  For names in which the most significant label is identical,
 continue sorting according to their next most significant label, and
 so forth.

 For example, the following names are sorted in canonical DNS name
 order.  The most significant label is "example".  At this level,
 "example" sorts first, followed by names ending in "a.example", then
 by names ending "z.example".  The names within each level are sorted
 in the same way.

           example
           a.example
           yljkjljk.a.example
           Z.a.example
           zABC.a.EXAMPLE
           z.example
           \001.z.example
           *.z.example
           \200.z.example