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

use crate::encode::Encoder;
use crate::{Dns, EncodeError, EncodeResult, Flags};
use num_traits::ToPrimitive;

impl Encoder {
    pub(super) fn flags(&mut self, flags: &Flags) -> EncodeResult<()> {
        let mut buffer = 0u8;
        if flags.qr {
            buffer |= 0b1000_0000;
        }
        if let Some(opcode) = flags.opcode.to_u8() {
            buffer |= opcode << 3;
        } else {
            return Err(EncodeError::OpcodeError);
        }
        if flags.aa {
            buffer |= 0b0000_0100;
        }
        if flags.tc {
            buffer |= 0b0000_0010;
        }
        if flags.rd {
            buffer |= 0b0000_0001;
        }
        self.u8(buffer);

        buffer = 0;
        if flags.ra {
            buffer |= 0b1000_0000;
        }
        if flags.ad {
            buffer |= 0b0010_0000;
        }
        if flags.cd {
            buffer |= 0b0001_0000;
        }
        if let Some(rcode) = flags.rcode.to_u8() {
            buffer |= rcode;
        } else {
            return Err(EncodeError::RCodeError);
        }
        self.u8(buffer);

        Ok(())
    }

    pub(super) fn dns(&mut self, dns: &Dns) -> EncodeResult<()> {
        self.u16(dns.id);
        self.flags(&dns.flags)?;
        self.u16(dns.questions.len() as u16);
        self.u16(dns.answers.len() as u16);
        self.u16(dns.authorities.len() as u16);
        self.u16(dns.additionals.len() as u16);

        for question in &dns.questions {
            self.question(question)?;
        }

        for answer in &dns.answers {
            self.rr(answer)?;
        }

        for authority in &dns.authorities {
            self.rr(authority)?;
        }

        for additional in &dns.additionals {
            self.rr(additional)?;
        }

        Ok(())
    }
}

impl_encode!(Flags, flags);

impl_encode!(Dns, dns);