rsdns 0.23.0

DNS Client Library
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
109
110
111

use crate::{
    Error, Result,
    bytes::Cursor,
    message::reader::{Labels, read_domain_name},
    names::{InlineName, Name},
};

/// An encoded domain name.
///
/// `NameRef` represents an encoded domain name. It doesn't hold the name bytes itself, but rather
/// points into a message buffer.
///
/// Its main purpose is efficient comparison between domain names encoded in the **same** DNS
/// message. This is optimized for compressed domain names, where two labels encoded at the same
/// offset ensure that suffixes of a domain name starting at these labels are equal.
///
/// `NameRef` doesn't implement the `PartialEq` trait, because that trait is infallible.
#[derive(Debug, Clone)]
pub struct NameRef<'a> {
    cursor: Cursor<'a>,
}

impl<'a> NameRef<'a> {
    #[allow(dead_code)]
    #[inline]
    pub(crate) fn new(cursor: Cursor<'a>) -> NameRef<'a> {
        NameRef { cursor }
    }

    /// Returns an iterator over the labels of this domain name.
    #[inline]
    pub fn labels(&self) -> Labels<'a> {
        Labels::new(self.cursor.clone())
    }

    /// Checks if this `NameRef` points to the same name as another one.
    ///
    /// This method is well defined only when applied to names encoded in the **same** DNS message.
    pub fn eq(&self, other: &Self) -> Result<bool> {
        let mut my_labels = self.labels();
        let mut other_labels = other.labels();

        loop {
            let mo = my_labels.next();
            let oo = other_labels.next();
            match (mo, oo) {
                (Some(mr), Some(or)) => {
                    // unwrap the labels
                    let ml = mr?;
                    let ol = or?;

                    // efficiently compare labels: if two labels are at the same offset,
                    // the rest of the domain name is necessary equal.
                    if ml.pos == ol.pos {
                        break Ok(true);
                    } else if !ml.bytes.eq_ignore_ascii_case(ol.bytes) {
                        break Ok(false);
                    } // else continue
                }
                (None, None) => break Ok(true),
                _ => break Ok(false),
            }
        }
    }

    /// Checks if this `NameRef` and another one point to different names.
    ///
    /// This method is the inverse of [`NameRef::eq`].
    ///
    /// This method is well defined only when applied to names encoded in the **same** DNS message.
    #[inline]
    pub fn ne(&self, other: &Self) -> Result<bool> {
        Ok(!self.eq(other)?)
    }
}

impl TryFrom<NameRef<'_>> for Name {
    type Error = Error;

    #[inline]
    fn try_from(mut value: NameRef<'_>) -> Result<Self> {
        read_domain_name(&mut value.cursor)
    }
}

impl TryFrom<&NameRef<'_>> for Name {
    type Error = Error;

    #[inline]
    fn try_from(value: &NameRef<'_>) -> Result<Self> {
        read_domain_name(&mut value.cursor.clone())
    }
}

impl TryFrom<NameRef<'_>> for InlineName {
    type Error = Error;

    #[inline]
    fn try_from(mut value: NameRef<'_>) -> Result<Self> {
        read_domain_name(&mut value.cursor)
    }
}

impl TryFrom<&NameRef<'_>> for InlineName {
    type Error = Error;

    #[inline]
    fn try_from(value: &NameRef<'_>) -> Result<Self> {
        read_domain_name(&mut value.cursor.clone())
    }
}