dns-update 0.2.0

Dynamic DNS update (RFC 2136 and cloud) library for Rust
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

/*
 * Copyright Stalwart Labs LLC See the COPYING
 * file at the top-level directory of this distribution.
 *
 * Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
 * https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
 * <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
 * option. This file may not be copied, modified, or distributed
 * except according to those terms.
 */

use crate::{DnsRecord, IntoFqdn, NamedDnsRecord};
use std::fmt::Write;

pub struct BindSerializer;

impl BindSerializer {
    pub fn serialize(records: &[NamedDnsRecord]) -> String {
        let mut output = String::new();
        for named in records {
            let name = &named.name;
            match &named.record {
                DnsRecord::A(addr) => {
                    writeln!(output, "{name} IN A {addr}").unwrap();
                }
                DnsRecord::AAAA(addr) => {
                    writeln!(output, "{name} IN AAAA {addr}").unwrap();
                }
                DnsRecord::CNAME(cname) => {
                    writeln!(output, "{name} IN CNAME {}", cname.into_fqdn()).unwrap();
                }
                DnsRecord::NS(ns) => {
                    writeln!(output, "{name} IN NS {}", ns.into_fqdn()).unwrap();
                }
                DnsRecord::MX(mx) => {
                    writeln!(
                        output,
                        "{name} IN MX {} {}",
                        mx.priority,
                        (&mx.exchange).into_fqdn()
                    )
                    .unwrap();
                }
                DnsRecord::TXT(text) => {
                    write!(output, "{name} IN TXT ").unwrap();
                    if text.len() <= 255 {
                        writeln!(output, "\"{}\"", escape_txt(text)).unwrap();
                    } else {
                        writeln!(output, "(").unwrap();
                        for chunk in text.as_bytes().chunks(255) {
                            let chunk_str = String::from_utf8_lossy(chunk);
                            writeln!(output, "    \"{}\"", escape_txt(&chunk_str)).unwrap();
                        }
                        writeln!(output, ")").unwrap();
                    }
                }
                DnsRecord::SRV(srv) => {
                    writeln!(
                        output,
                        "{name} IN SRV {} {} {} {}",
                        srv.priority,
                        srv.weight,
                        srv.port,
                        (&srv.target).into_fqdn()
                    )
                    .unwrap();
                }
                DnsRecord::TLSA(tlsa) => {
                    writeln!(output, "{name} IN TLSA {tlsa}").unwrap();
                }
                DnsRecord::CAA(caa) => {
                    writeln!(output, "{name} IN CAA {caa}").unwrap();
                }
            }
        }
        output
    }
}

#[inline(always)]
fn escape_txt(s: &str) -> String {
    s.replace('\\', "\\\\").replace('"', "\\\"")
}