Struct trust_dns_proto::rr::domain::Name
source · pub struct Name { /* private fields */ }
Expand description
A domain name
Implementations§
source§impl Name
impl Name
sourcepub fn root() -> Self
pub fn root() -> Self
Returns the root label, i.e. no labels, can probably make this better in the future.
sourcepub fn is_root(&self) -> bool
pub 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(), ".");
sourcepub fn is_fqdn(&self) -> bool
pub 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());
sourcepub fn set_fqdn(&mut self, val: bool)
pub 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
sourcepub fn append_label<L: IntoLabel>(self, label: L) -> ProtoResult<Self>
pub fn append_label<L: IntoLabel>(self, label: L) -> ProtoResult<Self>
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").unwrap();
assert_eq!(name, Name::from_str("www.example.com").unwrap());
sourcepub fn from_labels<I, L>(labels: I) -> ProtoResult<Self>where
I: IntoIterator<Item = L>,
L: IntoLabel,
pub fn from_labels<I, L>(labels: I) -> ProtoResult<Self>where I: IntoIterator<Item = L>, L: IntoLabel,
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;
// From strings, uses utf8 conversion
let from_labels = Name::from_labels(vec!["www", "example", "com"]).unwrap();
assert_eq!(from_labels, Name::from_str("www.example.com").unwrap());
// Force a set of bytes into labels (this is none-standard and potentially dangerous)
let from_labels = Name::from_labels(vec!["bad chars".as_bytes(), "example".as_bytes(), "com".as_bytes()]).unwrap();
assert_eq!(from_labels.iter().next(), Some(&b"bad chars"[..]));
let root = Name::from_labels(Vec::<&str>::new()).unwrap();
assert!(root.is_root());
sourcepub fn append_name(self, other: &Self) -> Result<Self, ProtoError>
pub fn append_name(self, other: &Self) -> Result<Self, ProtoError>
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).unwrap();
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).unwrap();
assert_eq!(name, Name::from_str("www.example.com.").unwrap());
assert!(name.is_fqdn());
sourcepub fn append_domain(self, domain: &Self) -> Result<Self, ProtoError>
pub fn append_domain(self, domain: &Self) -> Result<Self, ProtoError>
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).unwrap();
assert_eq!(name, Name::from_str("www.example.com").unwrap());
assert!(name.is_fqdn())
sourcepub fn to_lowercase(&self) -> Self
pub fn to_lowercase(&self) -> Self
Creates a new Name with all labels lowercased
Examples
use std::cmp::Ordering;
use std::str::FromStr;
use trust_dns_proto::rr::domain::{Label, Name};
let example_com = Name::from_ascii("Example.Com").unwrap();
assert_eq!(example_com.cmp_case(&Name::from_str("example.com").unwrap()), Ordering::Less);
assert!(example_com.to_lowercase().eq_case(&Name::from_str("example.com").unwrap()));
sourcepub fn base_name(&self) -> Self
pub fn base_name(&self) -> Self
Trims off the first part of the name, to help with searching for the domain piece
Examples
use std::str::FromStr;
use trust_dns_proto::rr::domain::Name;
let example_com = Name::from_str("example.com.").unwrap();
assert_eq!(example_com.base_name(), Name::from_str("com.").unwrap());
assert_eq!(Name::from_str("com.").unwrap().base_name(), Name::root());
assert_eq!(Name::root().base_name(), Name::root());
sourcepub fn trim_to(&self, num_labels: usize) -> Self
pub fn trim_to(&self, num_labels: usize) -> Self
Trims to the number of labels specified
Examples
use std::str::FromStr;
use trust_dns_proto::rr::domain::Name;
let example_com = Name::from_str("example.com.").unwrap();
assert_eq!(example_com.trim_to(2), Name::from_str("example.com.").unwrap());
assert_eq!(example_com.trim_to(1), Name::from_str("com.").unwrap());
assert_eq!(example_com.trim_to(0), Name::root());
assert_eq!(example_com.trim_to(3), Name::from_str("example.com.").unwrap());
sourcepub fn zone_of_case(&self, name: &Self) -> bool
pub fn zone_of_case(&self, name: &Self) -> bool
same as zone_of
allows for case sensitive call
sourcepub fn zone_of(&self, name: &Self) -> bool
pub fn zone_of(&self, name: &Self) -> bool
returns true if the name components of self are all present at the end of name
Example
use std::str::FromStr;
use trust_dns_proto::rr::domain::Name;
let name = Name::from_str("www.example.com").unwrap();
let name = Name::from_str("www.example.com").unwrap();
let zone = Name::from_str("example.com").unwrap();
let another = Name::from_str("example.net").unwrap();
assert!(zone.zone_of(&name));
assert!(!name.zone_of(&zone));
assert!(!another.zone_of(&name));
sourcepub fn num_labels(&self) -> u8
pub fn num_labels(&self) -> u8
Returns the number of labels in the name, discounting *
.
Examples
use std::str::FromStr;
use trust_dns_proto::rr::domain::Name;
let root = Name::root();
assert_eq!(root.num_labels(), 0);
let example_com = Name::from_str("example.com").unwrap();
assert_eq!(example_com.num_labels(), 2);
let star_example_com = Name::from_str("*.example.com.").unwrap();
assert_eq!(star_example_com.num_labels(), 2);
sourcepub fn len(&self) -> usize
pub 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.
Examples
use std::str::FromStr;
use trust_dns_proto::rr::domain::Name;
assert_eq!(Name::from_str("www.example.com.").unwrap().len(), 16);
assert_eq!(Name::from_str(".").unwrap().len(), 1);
assert_eq!(Name::root().len(), 1);
sourcepub fn is_empty(&self) -> bool
pub fn is_empty(&self) -> bool
Returns whether the length of the labels, in bytes is 0. In practice, since ‘.’ counts as 1, this is never the case so the method returns false.
sourcepub fn parse(local: &str, origin: Option<&Self>) -> ProtoResult<Self>
pub fn parse(local: &str, origin: Option<&Self>) -> ProtoResult<Self>
attempts to parse a name such as "example.com."
or "subdomain.example.com."
Examples
use std::str::FromStr;
use trust_dns_proto::rr::domain::Name;
let name = Name::from_str("example.com.").unwrap();
assert_eq!(name.base_name(), Name::from_str("com.").unwrap());
assert_eq!(name.iter().next(), Some(&b"example"[..]));
sourcepub fn from_ascii<S: AsRef<str>>(name: S) -> ProtoResult<Self>
pub fn from_ascii<S: AsRef<str>>(name: S) -> ProtoResult<Self>
Will convert the string to a name only allowing ascii as valid input
This method will also preserve the case of the name where that’s desirable
Examples
use trust_dns_proto::rr::Name;
let bytes_name = Name::from_labels(vec!["WWW".as_bytes(), "example".as_bytes(), "COM".as_bytes()]).unwrap();
let ascii_name = Name::from_ascii("WWW.example.COM.").unwrap();
let lower_name = Name::from_ascii("www.example.com.").unwrap();
assert!(bytes_name.eq_case(&ascii_name));
assert!(!lower_name.eq_case(&ascii_name));
// escaped values
let bytes_name = Name::from_labels(vec!["email.name".as_bytes(), "example".as_bytes(), "com".as_bytes()]).unwrap();
let name = Name::from_ascii("email\\.name.example.com.").unwrap();
assert_eq!(bytes_name, name);
let bytes_name = Name::from_labels(vec!["bad.char".as_bytes(), "example".as_bytes(), "com".as_bytes()]).unwrap();
let name = Name::from_ascii("bad\\056char.example.com.").unwrap();
assert_eq!(bytes_name, name);
sourcepub fn from_utf8<S: AsRef<str>>(name: S) -> ProtoResult<Self>
pub fn from_utf8<S: AsRef<str>>(name: S) -> ProtoResult<Self>
Will convert the string to a name using IDNA, punycode, to encode the UTF8 as necessary
When making names IDNA compatible, there is a side-effect of lowercasing the name.
Examples
use std::str::FromStr;
use trust_dns_proto::rr::Name;
let bytes_name = Name::from_labels(vec!["WWW".as_bytes(), "example".as_bytes(), "COM".as_bytes()]).unwrap();
// from_str calls through to from_utf8
let utf8_name = Name::from_str("WWW.example.COM.").unwrap();
let lower_name = Name::from_str("www.example.com.").unwrap();
assert!(!bytes_name.eq_case(&utf8_name));
assert!(lower_name.eq_case(&utf8_name));
sourcepub fn from_str_relaxed<S: AsRef<str>>(name: S) -> ProtoResult<Self>
pub fn from_str_relaxed<S: AsRef<str>>(name: S) -> ProtoResult<Self>
First attempts to decode via from_utf8
, if that fails IDNA checks, then falls back to
ascii decoding.
Examples
use std::str::FromStr;
use trust_dns_proto::rr::Name;
// Ok, underscore in the beginning of a name
assert!(Name::from_utf8("_allows.example.com.").is_ok());
// Error, underscore in the end
assert!(Name::from_utf8("dis_allowed.example.com.").is_err());
// Ok, relaxed mode
assert!(Name::from_str_relaxed("allow_in_.example.com.").is_ok());
sourcepub fn emit_as_canonical(
&self,
encoder: &mut BinEncoder<'_>,
canonical: bool
) -> ProtoResult<()>
pub fn emit_as_canonical( &self, encoder: &mut BinEncoder<'_>, canonical: bool ) -> ProtoResult<()>
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).
sourcepub fn emit_with_lowercase(
&self,
encoder: &mut BinEncoder<'_>,
lowercase: bool
) -> ProtoResult<()>
pub fn emit_with_lowercase( &self, encoder: &mut BinEncoder<'_>, lowercase: bool ) -> ProtoResult<()>
Writes the labels, as lower case, to the encoder
Arguments
encoder
- encoder for writing this namelowercase
- if true the name will be lowercased, otherwise it will not be changed when writing
sourcepub fn to_ascii(&self) -> String
pub fn to_ascii(&self) -> String
Converts this name into an ascii safe string.
If the name is an IDNA name, then the name labels will be returned with the xn--
prefix.
see to_utf8
or the Display
impl for methods which convert labels to utf8.
sourcepub fn to_utf8(&self) -> String
pub fn to_utf8(&self) -> String
Converts the Name labels to the utf8 String form.
This converts the name to an unescaped format, that could be used with parse. If, the name is
is followed by the final .
, e.g. as in www.example.com.
, which represents a fully
qualified Name.
sourcepub fn parse_arpa_name(&self) -> Result<IpNet, ProtoError>
pub fn parse_arpa_name(&self) -> Result<IpNet, ProtoError>
Converts a *.arpa Name in a PTR record back into an IpNet if possible.
sourcepub fn is_localhost(&self) -> bool
pub fn is_localhost(&self) -> bool
Returns true if the Name
is either localhost or in the localhost zone.
Example
use std::str::FromStr;
use trust_dns_proto::rr::Name;
let name = Name::from_str("localhost").unwrap();
assert!(name.is_localhost());
let name = Name::from_str("localhost.").unwrap();
assert!(name.is_localhost());
let name = Name::from_str("my.localhost.").unwrap();
assert!(name.is_localhost());
sourcepub fn is_wildcard(&self) -> bool
pub fn is_wildcard(&self) -> bool
True if the first label of this name is the wildcard, i.e. ‘*’
Example
use std::str::FromStr;
use trust_dns_proto::rr::Name;
let name = Name::from_str("www.example.com").unwrap();
assert!(!name.is_wildcard());
let name = Name::from_str("*.example.com").unwrap();
assert!(name.is_wildcard());
let name = Name::root();
assert!(!name.is_wildcard());
sourcepub fn into_wildcard(self) -> Self
pub fn into_wildcard(self) -> Self
Converts a name to a wildcard, by replacing the first label with *
Example
use std::str::FromStr;
use trust_dns_proto::rr::Name;
let name = Name::from_str("www.example.com").unwrap().into_wildcard();
assert_eq!(name, Name::from_str("*.example.com.").unwrap());
// does nothing if the root
let name = Name::root().into_wildcard();
assert_eq!(name, Name::root());
Trait Implementations§
source§impl<'r> BinDecodable<'r> for Name
impl<'r> BinDecodable<'r> for Name
source§fn read(decoder: &mut BinDecoder<'r>) -> ProtoResult<Self>
fn read(decoder: &mut BinDecoder<'r>) -> ProtoResult<Self>
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…
source§fn from_bytes(bytes: &'r [u8]) -> ProtoResult<Self>
fn from_bytes(bytes: &'r [u8]) -> ProtoResult<Self>
source§impl BinEncodable for Name
impl BinEncodable for Name
source§fn emit(&self, encoder: &mut BinEncoder<'_>) -> ProtoResult<()>
fn emit(&self, encoder: &mut BinEncoder<'_>) -> ProtoResult<()>
source§impl FromStr for Name
impl FromStr for Name
source§fn from_str(s: &str) -> Result<Self, Self::Err>
fn from_str(s: &str) -> Result<Self, Self::Err>
Uses the Name::from_utf8 conversion on this string, see Name::from_ascii for ascii only, or for preserving case
§type Err = ProtoError
type Err = ProtoError
source§impl<'a> IntoIterator for &'a Name
impl<'a> IntoIterator for &'a Name
source§impl Ord for Name
impl Ord for Name
source§fn cmp(&self, other: &Self) -> Ordering
fn cmp(&self, other: &Self) -> Ordering
Case insensitive comparison, see Name::cmp_case
for case sensitive comparisons
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
1.21.0 · source§fn max(self, other: Self) -> Selfwhere
Self: Sized,
fn max(self, other: Self) -> Selfwhere Self: Sized,
source§impl PartialEq<Name> for Name
impl PartialEq<Name> for Name
source§impl PartialOrd<Name> for Name
impl PartialOrd<Name> for Name
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl TryParseIp for Name
impl TryParseIp for Name
source§fn try_parse_ip(&self) -> Option<RData>
fn try_parse_ip(&self) -> Option<RData>
Always returns none for Name, it assumes something that is already a name, wants to be a name