Struct trust_dns::rr::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() -> Name

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

fn root() -> Name

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_proto::rr::domain::Name;

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

fn is_fqdn(&self) -> bool

Returns true if the name is a fully qualified domain name.

If this is true, it has effects like only querying for this single name, as opposed to building up a search list in resolvers.

warning: this interface is unstable and may change in the future

Examples

use std::str::FromStr;
use trust_dns_proto::rr::domain::Name;

let name = Name::from_str("www").unwrap();
assert!(!name.is_fqdn());

let name = Name::from_str("www.example.com").unwrap();
assert!(!name.is_fqdn());

let name = Name::from_str("www.example.com.").unwrap();
assert!(name.is_fqdn());

fn set_fqdn(&mut self, val: bool)

Specifies this name is a fully qualified domain name

warning: this interface is unstable and may change in the future

fn append_label<S>(self, label: S) -> Name where
    S: Into<String>, 

Appends the label to the end of this name

Example

use std::str::FromStr;
use trust_dns_proto::rr::domain::Name;

let name = Name::from_str("www.example").unwrap();
let name = name.append_label("com");
assert_eq!(name, Name::from_str("www.example.com").unwrap());

fn from_labels<S>(labels: Vec<S>) -> Name where
    S: Into<String>, 

Creates a new Name from the specified labels

Arguments

• labels - vector of items which will be stored as Strings.

Examples

use std::str::FromStr;
use trust_dns_proto::rr::domain::Name;

let from_labels = Name::from_labels(vec!["www", "example", "com"]);
assert_eq!(from_labels, Name::from_str("www.example.com").unwrap());

let root = Name::from_labels::<String>(vec![]);
assert!(root.is_root());

fn append_name(self, other: &Name) -> Name

Appends other to self, returning a new Name

Carries forward is_fqdn from other.

Examples

use std::str::FromStr;
use trust_dns_proto::rr::domain::Name;

let local = Name::from_str("www").unwrap();
let domain = Name::from_str("example.com").unwrap();
assert!(!domain.is_fqdn());

let name = local.clone().append_name(&domain);
assert_eq!(name, Name::from_str("www.example.com").unwrap());
assert!(!name.is_fqdn());

// see also `Name::append_domain`
let domain = Name::from_str("example.com.").unwrap();
assert!(domain.is_fqdn());
let name = local.append_name(&domain);
assert_eq!(name, Name::from_str("www.example.com.").unwrap());
assert!(name.is_fqdn());

fn append_domain(self, domain: &Name) -> Name

Appends the domain to self, making the new Name an FQDN

This is an alias for append_name with the added effect of marking the new Name as a fully-qualified-domain-name.

Examples

use std::str::FromStr;
use trust_dns_proto::rr::domain::Name;

let local = Name::from_str("www").unwrap();
let domain = Name::from_str("example.com").unwrap();
let name = local.append_domain(&domain);
assert_eq!(name, Name::from_str("www.example.com").unwrap());
assert!(name.is_fqdn())

fn to_lowercase(&self) -> Name

Creates a new Name with all labels lowercased

Examples

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

let example_com = Name::from_labels(vec!["Example", "Com"]);
assert_eq!(example_com.cmp_with_case(&Name::from_labels(vec!["example", "com"]), false), Ordering::Less);
assert_eq!(example_com.to_lowercase().cmp_with_case(&Name::from_labels(vec!["example", "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_proto::rr::domain::Name;

let example_com = Name::from_labels(vec!["example", "com"]);
assert_eq!(example_com.base_name(), Name::from_labels(vec!["com"]));
assert_eq!(Name::from_labels(vec!["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_proto::rr::domain::Name;

let example_com = Name::from_labels(vec!["example", "com"]);
assert_eq!(example_com.trim_to(2), Name::from_labels(vec!["example", "com"]));
assert_eq!(example_com.trim_to(1), Name::from_labels(vec!["com"]));
assert_eq!(example_com.trim_to(0), Name::root());

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

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

Example

use trust_dns_proto::rr::domain::Name;

let name = Name::from_labels(vec!["www", "example", "com"]);
let name = Name::from_labels(vec!["www", "example", "com"]);
let zone = Name::from_labels(vec!["example", "com"]);
let another = Name::from_labels(vec!["example", "net"]);
assert!(zone.zone_of(&name));
assert!(!another.zone_of(&name));

fn num_labels(&self) -> u8

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

Examples

use trust_dns_proto::rr::domain::Name;

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

let example_com = Name::from_labels(vec!["example", "com"]);
assert_eq!(example_com.num_labels(), 2);

let star_example_com = Name::from_labels(vec!["*", "example", "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 is_empty(&self) -> bool

Returns whether the length of the labels, in bytes is 0. In practive, since '.' counts as 1, this is never the case so the method returns false.

fn parse(local: &str, origin: Option<&Name>) -> Result<Name, ProtoError>

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

Examples

use trust_dns_proto::rr::domain::Name;

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

fn emit_as_canonical(
    &self,
    encoder: &mut BinEncoder,
    canonical: bool
) -> Result<(), ProtoError>

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
) -> Result<(), ProtoError>

Writes the labels, as lower case, to the encoder

fn cmp_with_case(&self, other: &Name, 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 Ord for Name

fn cmp(&self, other: &Name) -> 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

impl Index<usize> for Name

type Output = String

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

impl Hash for Name

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

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

impl From<Ipv6Addr> for Name

fn from(addr: Ipv6Addr) -> Name

Performs the conversion.

impl From<Ipv4Addr> for Name

fn from(addr: Ipv4Addr) -> Name

Performs the conversion.

impl From<IpAddr> for Name

fn from(addr: IpAddr) -> Name

Performs the conversion.

impl PartialEq<Name> for Name

fn eq(&self, other: &Name) -> 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 FromStr for Name

type Err = ProtoError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Name, <Name as FromStr>::Err>

Parses a string s to return a value of this type.

impl Debug for Name

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

Formats the value using the given formatter.

impl BinSerializable<Name> for Name

fn read(decoder: &mut BinDecoder) -> Result<Name, ProtoError>

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) -> Result<(), ProtoError>

Write the type to the stream

impl Display for Name

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

Formats the value using the given formatter.

impl Default for Name

fn default() -> Name

Returns the "default value" for a type.

impl PartialOrd<Name> for Name

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