Struct ZoneUsage

pub struct ZoneUsage { /* private fields */ }

ZoneUsage represents information about how a name falling in a given zone should be treated

Implementations

impl ZoneUsage

pub fn new( name: Name, user: UserUsage, app: AppUsage, resolver: ResolverUsage, cache: CacheUsage, auth: AuthUsage, op: OpUsage, registry: RegistryUsage, ) -> ZoneUsage

Constructs a new ZoneUsage with the associated values

pub fn reverse(name: Name) -> ZoneUsage

Restrictions for reverse zones

pub fn test(name: Name) -> ZoneUsage

Restrictions for the .test. zone

pub fn localhost(name: Name) -> ZoneUsage

Restrictions for the .localhost. zone

pub fn local(name: Name) -> ZoneUsage

Restrictions for the .local. zone

pub fn invalid(name: Name) -> ZoneUsage

Restrictions for the .invalid. zone

pub fn example(name: Name) -> ZoneUsage

Restrictions for the .example. zone

pub fn name(&self) -> &Name

A reference to this zone name

pub fn user(&self) -> UserUsage

Returns the UserUsage of this zone

pub fn app(&self) -> AppUsage

Returns the AppUsage of this zone

pub fn resolver(&self) -> ResolverUsage

Returns the ResolverUsage of this zone

pub fn cache(&self) -> CacheUsage

Returns the CacheUsage of this zone

pub fn auth(&self) -> AuthUsage

Returns the AuthUsage of this zone

pub fn op(&self) -> OpUsage

Returns the OpUsage of this zone

pub fn registry(&self) -> RegistryUsage

Returns the RegistryUsage of this zone

Methods from Deref<Target = Name>

pub const MAX_LENGTH: usize = 255usize

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

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

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 hickory_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());

pub fn iter(&self) -> LabelIter<'_>

Returns an iterator over the labels

pub fn prepend_label<L>(&self, label: L) -> Result<Name, ProtoError>

where L: IntoLabel,

Prepends the label to the beginning of this name

Example

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

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

pub fn to_lowercase(&self) -> Name

Creates a new Name with all labels lowercased

Examples

use std::cmp::Ordering;
use std::str::FromStr;

use hickory_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()));

pub fn base_name(&self) -> Name

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

Examples

use std::str::FromStr;
use hickory_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());

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

Trims to the number of labels specified

Examples

use std::str::FromStr;
use hickory_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());

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

same as zone_of allows for case sensitive call

pub 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 std::str::FromStr;
use hickory_proto::rr::domain::Name;

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));

pub fn num_labels(&self) -> u8

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

Examples

use std::str::FromStr;
use hickory_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);

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, though escaping may cause the exact length to be different.

Examples

use std::str::FromStr;
use hickory_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);

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.

pub 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).

pub fn emit_with_lowercase( &self, encoder: &mut BinEncoder<'_>, lowercase: bool, ) -> Result<(), ProtoError>

Writes the labels, as lower case, to the encoder

Arguments

• encoder - encoder for writing this name
• lowercase - if true the name will be lowercased, otherwise it will not be changed when writing

pub fn cmp_case(&self, other: &Name) -> Ordering

Case sensitive comparison

pub fn eq_case(&self, other: &Name) -> bool

Compares the Names, in a case sensitive manner

pub fn eq_ignore_root(&self, other: &Name) -> bool

Non-FQDN-aware case-insensitive comparison

This will return true if names are equal, or if an otherwise equal relative and non-relative name are compared.

Examples

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

let name1 = Name::from_str("a.com.").unwrap();
let name2 = name1.clone();
assert_eq!(&name1, &name2);
assert!(name1.eq_ignore_root(&name2));

// Make name2 uppercase.
let name2 = Name::from_str("A.CoM.").unwrap();
assert_eq!(&name1, &name2);
assert!(name1.eq_ignore_root(&name2));

// Make name2 a relative name.
// Note that standard equality testing now returns false.
let name2 = Name::from_str("a.com").unwrap();
assert!(&name1 != &name2);
assert!(name1.eq_ignore_root(&name2));

// Make name2 a completely unrelated name.
let name2 = Name::from_str("b.com.").unwrap();
assert!(&name1 != &name2);
assert!(!name1.eq_ignore_root(&name2));

pub fn eq_ignore_root_case(&self, other: &Name) -> bool

Non-FQDN-aware case-sensitive comparison

This will return true if names are equal, or if an otherwise equal relative and non-relative name are compared.

Examples

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

let name1 = Name::from_str("a.com.").unwrap();
let name2 = Name::from_ascii("A.CoM.").unwrap();
let name3 = Name::from_ascii("A.CoM").unwrap();

assert_eq!(&name1, &name2);
assert!(name1.eq_ignore_root(&name2));
assert!(!name1.eq_ignore_root_case(&name2));
assert!(name2.eq_ignore_root_case(&name3));

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.

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.

pub fn parse_arpa_name(&self) -> Result<IpNet, ProtoError>

Converts a *.arpa Name in a PTR record back into an IpNet if possible.

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 hickory_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());

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 hickory_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());

Trait Implementations

impl Default for ZoneUsage

Constructs a new Default, with all no restrictions

fn default() -> ZoneUsage

Returns the “default value” for a type.

impl Deref for ZoneUsage

type Target = Name

The resulting type after dereferencing.

fn deref(&self) -> &<ZoneUsage as Deref>::Target

Dereferences the value.