ch4 0.12.0

DNS Client Tool
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
112

use anyhow::Result;
use rsdns::records::data;
use std::fmt::Write;

macro_rules! obsolete {
    ($RR:ident) => {
        // https://en.wikipedia.org/wiki/List_of_DNS_record_types#Obsolete_record_types
        impl<W: Write> RDataFormatter<W, data::$RR> for RDataFmt {
            fn fmt(w: &mut W, _d: &data::$RR) -> Result<()> {
                write!(w, "OBSOLETE RTYPE")?;
                Ok(())
            }
        }
    };
}

fn str_from_text(text: &[u8]) -> &str {
    match std::str::from_utf8(text) {
        Ok(s) => s,
        Err(_) => "__CH4_NON_UTF8_STRING__",
    }
}

pub trait RDataFormatter<W: Write, D: data::RData> {
    fn fmt(w: &mut W, d: &D) -> Result<()>;
}

pub struct RDataFmt;

impl<W: Write> RDataFormatter<W, data::A> for RDataFmt {
    fn fmt(w: &mut W, d: &data::A) -> Result<()> {
        write!(w, "{}", d.address)?;
        Ok(())
    }
}

impl<W: Write> RDataFormatter<W, data::Ns> for RDataFmt {
    fn fmt(w: &mut W, d: &data::Ns) -> Result<()> {
        write!(w, "{}", d.nsdname)?;
        Ok(())
    }
}

obsolete!(Md);
obsolete!(Mf);

impl<W: Write> RDataFormatter<W, data::Cname> for RDataFmt {
    fn fmt(w: &mut W, d: &data::Cname) -> Result<()> {
        write!(w, "{}", d.cname)?;
        Ok(())
    }
}

impl<W: Write> RDataFormatter<W, data::Soa> for RDataFmt {
    fn fmt(w: &mut W, d: &data::Soa) -> Result<()> {
        write!(
            w,
            "{} {} {} {} {} {} {}",
            d.mname, d.rname, d.serial, d.refresh, d.retry, d.expire, d.minimum,
        )?;
        Ok(())
    }
}

obsolete!(Mb);
obsolete!(Mg);
obsolete!(Mr);
obsolete!(Null);
obsolete!(Wks);

impl<W: Write> RDataFormatter<W, data::Ptr> for RDataFmt {
    fn fmt(w: &mut W, d: &data::Ptr) -> Result<()> {
        write!(w, "{}", d.ptrdname)?;
        Ok(())
    }
}

impl<W: Write> RDataFormatter<W, data::Hinfo> for RDataFmt {
    fn fmt(w: &mut W, d: &data::Hinfo) -> Result<()> {
        write!(
            w,
            "\"{}\" \"{}\"",
            str_from_text(&d.cpu),
            str_from_text(&d.os)
        )?;
        Ok(())
    }
}

obsolete!(Minfo);

impl<W: Write> RDataFormatter<W, data::Mx> for RDataFmt {
    fn fmt(w: &mut W, d: &data::Mx) -> Result<()> {
        write!(w, "{} {}", d.preference, d.exchange)?;
        Ok(())
    }
}

impl<W: Write> RDataFormatter<W, data::Txt> for RDataFmt {
    fn fmt(w: &mut W, d: &data::Txt) -> Result<()> {
        let utf8 = str_from_text(&d.text);
        write!(w, "\"{utf8}\"")?;
        Ok(())
    }
}

impl<W: Write> RDataFormatter<W, data::Aaaa> for RDataFmt {
    fn fmt(w: &mut W, d: &data::Aaaa) -> Result<()> {
        write!(w, "{}", d.address)?;
        Ok(())
    }
}