addr 0.15.6

A library for parsing domain names
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

//! DNS types

use crate::error::Result;
use crate::matcher;
use core::{fmt, str};
use psl_types::{List, Suffix, Type};

/// Holds information about a particular DNS name
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
pub struct Name<'a> {
    full: &'a str,
    suffix: Option<Suffix<'a>>,
}

impl<'a> Name<'a> {
    pub(crate) fn parse<T: List + ?Sized>(list: &T, name: &'a str) -> Result<Name<'a>> {
        matcher::is_dns_name(name)?;
        Ok(Self {
            full: name,
            suffix: list.suffix(name.as_bytes()),
        })
    }

    /// Full dns name as a `str`
    pub const fn as_str(&self) -> &'a str {
        self.full
    }

    fn without_suffix(&self) -> Option<&'a str> {
        let domain_len = self.full.len();
        let suffix_len = self.suffix()?.len();
        if domain_len == suffix_len {
            return None;
        }
        self.full.get(..domain_len - suffix_len - 1)
    }

    /// The root domain (the registrable part)
    pub fn root(&self) -> Option<&'a str> {
        let offset = self
            .without_suffix()?
            .rfind('.')
            .map(|x| x + 1)
            .unwrap_or_default();
        self.full.get(offset..)
    }

    /// The part before the root domain (aka. subdomain)
    pub fn prefix(&self) -> Option<&'a str> {
        let domain_len = self.full.len();
        let root_len = self.root()?.len();
        if domain_len == root_len {
            return None;
        }
        self.full.get(..domain_len - root_len - 1)
    }

    /// The domain name suffix (extension)
    pub fn suffix(&self) -> Option<&'a str> {
        let bytes = self.suffix.as_ref()?.as_bytes();
        str::from_utf8(bytes).ok()
    }

    /// Whether the suffix of the domain name is in the Public Suffix List
    pub fn has_known_suffix(&self) -> bool {
        if let Some(suffix) = self.suffix {
            suffix.is_known()
        } else {
            false
        }
    }

    /// Whether this an ICANN delegated suffix
    ///
    /// ICANN domains are those delegated by ICANN or part of the IANA root
    /// zone database
    pub fn is_icann(&self) -> bool {
        if let Some(suffix) = self.suffix {
            suffix.typ() == Some(Type::Icann)
        } else {
            false
        }
    }

    /// Whether this is a private party delegated suffix
    ///
    /// PRIVATE domains are amendments submitted by the domain holder, as an
    /// expression of how they operate their domain security policy
    pub fn is_private(&self) -> bool {
        if let Some(suffix) = self.suffix {
            suffix.typ() == Some(Type::Private)
        } else {
            false
        }
    }
}

impl fmt::Display for Name<'_> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.full)
    }
}

impl PartialEq<&str> for Name<'_> {
    fn eq(&self, other: &&str) -> bool {
        self.full == *other
    }
}