finialize initial dns + caching

7 files changed, 1069 insertions, 0 deletions

diff --git a/src/packet/buffer.rs b/src/packet/buffer.rs
new file mode 100644
index 0000000..4ecc605
--- /dev/null
+++ b/src/packet/buffer.rs
@@ -0,0 +1,236 @@
+use super::Result;
+
+pub struct PacketBuffer {
+    pub buf: Vec<u8>,
+    pub pos: usize,
+    pub size: usize,
+}
+
+impl PacketBuffer {
+    pub fn new(buf: Vec<u8>) -> Self {
+        Self {
+            buf,
+            pos: 0,
+            size: 0,
+        }
+    }
+
+    fn check(&mut self, pos: usize) {
+        if self.size < pos {
+            self.size = pos;
+        }
+
+        if self.buf.len() <= self.size {
+            self.buf.resize(self.size + 1, 0x00);
+        }
+    }
+
+    pub fn pos(&self) -> usize {
+        self.pos
+    }
+
+    pub fn step(&mut self, steps: usize) -> Result<()> {
+        self.pos += steps;
+
+        Ok(())
+    }
+
+    pub fn seek(&mut self, pos: usize) -> Result<()> {
+        self.pos = pos;
+
+        Ok(())
+    }
+
+    pub fn read(&mut self) -> Result<u8> {
+        // if self.pos >= 512 {
+        //     error!("Tried to read past end of buffer");
+        //     return Err("End of buffer".into());
+        // }
+        self.check(self.pos);
+        let res = self.buf[self.pos];
+        self.pos += 1;
+
+        Ok(res)
+    }
+
+    pub fn get(&mut self, pos: usize) -> Result<u8> {
+        // if pos >= 512 {
+        //     error!("Tried to read past end of buffer");
+        //     return Err("End of buffer".into());
+        // }
+        self.check(pos);
+        Ok(self.buf[pos])
+    }
+
+    pub fn get_range(&mut self, start: usize, len: usize) -> Result<&[u8]> {
+        // if start + len >= 512 {
+        //     error!("Tried to read past end of buffer");
+        //     return Err("End of buffer".into());
+        // }
+        self.check(start + len);
+        Ok(&self.buf[start..start + len])
+    }
+
+    pub fn read_u16(&mut self) -> Result<u16> {
+        let res = ((self.read()? as u16) << 8) | (self.read()? as u16);
+
+        Ok(res)
+    }
+
+    pub fn read_u32(&mut self) -> Result<u32> {
+        let res = ((self.read()? as u32) << 24)
+            | ((self.read()? as u32) << 16)
+            | ((self.read()? as u32) << 8)
+            | (self.read()? as u32);
+
+        Ok(res)
+    }
+
+    pub fn read_qname(&mut self, outstr: &mut String) -> Result<()> {
+        let mut pos = self.pos();
+        let mut jumped = false;
+
+        let mut delim = "";
+        let max_jumps = 5;
+        let mut jumps_performed = 0;
+        loop {
+            // Dns Packets are untrusted data, so we need to be paranoid. Someone
+            // can craft a packet with a cycle in the jump instructions. This guards
+            // against such packets.
+            if jumps_performed > max_jumps {
+                return Err(format!("Limit of {max_jumps} jumps exceeded").into());
+            }
+
+            let len = self.get(pos)?;
+
+            if (len & 0xC0) == 0xC0 {
+                if !jumped {
+                    self.seek(pos + 2)?;
+                }
+
+                let b2 = self.get(pos + 1)? as u16;
+                let offset = (((len as u16) ^ 0xC0) << 8) | b2;
+                pos = offset as usize;
+                jumped = true;
+                jumps_performed += 1;
+                continue;
+            }
+
+            pos += 1;
+
+            if len == 0 {
+                break;
+            }
+
+            outstr.push_str(delim);
+
+            let str_buffer = self.get_range(pos, len as usize)?;
+            outstr.push_str(&String::from_utf8_lossy(str_buffer).to_lowercase());
+
+            delim = ".";
+
+            pos += len as usize;
+        }
+
+        if !jumped {
+            self.seek(pos)?;
+        }
+
+        Ok(())
+    }
+
+    pub fn read_string(&mut self, outstr: &mut String) -> Result<()> {
+        let len = self.read()?;
+
+        self.read_string_n(outstr, len)?;
+
+        Ok(())
+    }
+
+    pub fn read_string_n(&mut self, outstr: &mut String, len: u8) -> Result<()> {
+        let mut pos = self.pos;
+
+        let str_buffer = self.get_range(pos, len as usize)?;
+
+        let mut i = 0;
+        for b in str_buffer {
+            let c = *b as char;
+            if c == '\0' {
+                break;
+            }
+            outstr.push(c);
+            i += 1;
+        }
+
+        pos += i;
+        self.seek(pos)?;
+
+        Ok(())
+    }
+
+    pub fn write(&mut self, val: u8) -> Result<()> {
+        self.check(self.pos);
+
+        self.buf[self.pos] = val;
+        self.pos += 1;
+        Ok(())
+    }
+
+    pub fn write_u8(&mut self, val: u8) -> Result<()> {
+        self.write(val)?;
+
+        Ok(())
+    }
+
+    pub fn write_u16(&mut self, val: u16) -> Result<()> {
+        self.write((val >> 8) as u8)?;
+        self.write((val & 0xFF) as u8)?;
+
+        Ok(())
+    }
+
+    pub fn write_u32(&mut self, val: u32) -> Result<()> {
+        self.write(((val >> 24) & 0xFF) as u8)?;
+        self.write(((val >> 16) & 0xFF) as u8)?;
+        self.write(((val >> 8) & 0xFF) as u8)?;
+        self.write((val & 0xFF) as u8)?;
+
+        Ok(())
+    }
+
+    pub fn write_qname(&mut self, qname: &str) -> Result<()> {
+        for label in qname.split('.') {
+            let len = label.len();
+
+            self.write_u8(len as u8)?;
+            for b in label.as_bytes() {
+                self.write_u8(*b)?;
+            }
+        }
+
+        self.write_u8(0)?;
+
+        Ok(())
+    }
+
+    pub fn write_string(&mut self, text: &str) -> Result<()> {
+        for b in text.as_bytes() {
+            self.write_u8(*b)?;
+        }
+
+        Ok(())
+    }
+
+    pub fn set(&mut self, pos: usize, val: u8) -> Result<()> {
+        self.buf[pos] = val;
+
+        Ok(())
+    }
+
+    pub fn set_u16(&mut self, pos: usize, val: u16) -> Result<()> {
+        self.set(pos, (val >> 8) as u8)?;
+        self.set(pos + 1, (val & 0xFF) as u8)?;
+
+        Ok(())
+    }
+}
diff --git a/src/packet/header.rs b/src/packet/header.rs
new file mode 100644
index 0000000..a75f6ba
--- /dev/null
+++ b/src/packet/header.rs
@@ -0,0 +1,101 @@
+use super::{buffer::PacketBuffer, result::ResultCode, Result};
+
+#[derive(Clone, Debug)]
+pub struct DnsHeader {
+    pub id: u16, // 16 bits
+
+    pub recursion_desired: bool,    // 1 bit
+    pub truncated_message: bool,    // 1 bit
+    pub authoritative_answer: bool, // 1 bit
+    pub opcode: u8,                 // 4 bits
+    pub response: bool,             // 1 bit
+
+    pub rescode: ResultCode,       // 4 bits
+    pub checking_disabled: bool,   // 1 bit
+    pub authed_data: bool,         // 1 bit
+    pub z: bool,                   // 1 bit
+    pub recursion_available: bool, // 1 bit
+
+    pub questions: u16,             // 16 bits
+    pub answers: u16,               // 16 bits
+    pub authoritative_entries: u16, // 16 bits
+    pub resource_entries: u16,      // 16 bits
+}
+
+impl DnsHeader {
+    pub fn new() -> Self {
+        Self {
+            id: 0,
+
+            recursion_desired: false,
+            truncated_message: false,
+            authoritative_answer: false,
+            opcode: 0,
+            response: false,
+
+            rescode: ResultCode::NOERROR,
+            checking_disabled: false,
+            authed_data: false,
+            z: false,
+            recursion_available: false,
+
+            questions: 0,
+            answers: 0,
+            authoritative_entries: 0,
+            resource_entries: 0,
+        }
+    }
+
+    pub fn read(&mut self, buffer: &mut PacketBuffer) -> Result<()> {
+        self.id = buffer.read_u16()?;
+        let flags = buffer.read_u16()?;
+        let a = (flags >> 8) as u8;
+        let b = (flags & 0xFF) as u8;
+        self.recursion_desired = (a & (1 << 0)) > 0;
+        self.truncated_message = (a & (1 << 1)) > 0;
+        self.authoritative_answer = (a & (1 << 2)) > 0;
+        self.opcode = (a >> 3) & 0x0F;
+        self.response = (a & (1 << 7)) > 0;
+
+        self.rescode = ResultCode::from_num(b & 0x0F);
+        self.checking_disabled = (b & (1 << 4)) > 0;
+        self.authed_data = (b & (1 << 5)) > 0;
+        self.z = (b & (1 << 6)) > 0;
+        self.recursion_available = (b & (1 << 7)) > 0;
+
+        self.questions = buffer.read_u16()?;
+        self.answers = buffer.read_u16()?;
+        self.authoritative_entries = buffer.read_u16()?;
+        self.resource_entries = buffer.read_u16()?;
+
+        // Return the constant header size
+        Ok(())
+    }
+
+    pub fn write(&self, buffer: &mut PacketBuffer) -> Result<()> {
+        buffer.write_u16(self.id)?;
+
+        buffer.write_u8(
+            (self.recursion_desired as u8)
+                | ((self.truncated_message as u8) << 1)
+                | ((self.authoritative_answer as u8) << 2)
+                | (self.opcode << 3)
+                | ((self.response as u8) << 7),
+        )?;
+
+        buffer.write_u8(
+            (self.rescode as u8)
+                | ((self.checking_disabled as u8) << 4)
+                | ((self.authed_data as u8) << 5)
+                | ((self.z as u8) << 6)
+                | ((self.recursion_available as u8) << 7),
+        )?;
+
+        buffer.write_u16(self.questions)?;
+        buffer.write_u16(self.answers)?;
+        buffer.write_u16(self.authoritative_entries)?;
+        buffer.write_u16(self.resource_entries)?;
+
+        Ok(())
+    }
+}
diff --git a/src/packet/mod.rs b/src/packet/mod.rs
new file mode 100644
index 0000000..0b7cb7b
--- /dev/null
+++ b/src/packet/mod.rs
@@ -0,0 +1,130 @@
+use std::net::IpAddr;
+
+use self::{
+    buffer::PacketBuffer, header::DnsHeader, query::QueryType, question::DnsQuestion,
+    record::DnsRecord,
+};
+
+type Error = Box<dyn std::error::Error>;
+pub type Result<T> = std::result::Result<T, Error>;
+
+pub mod buffer;
+pub mod header;
+pub mod query;
+pub mod question;
+pub mod record;
+pub mod result;
+
+#[derive(Clone, Debug)]
+pub struct Packet {
+    pub header: DnsHeader,
+    pub questions: Vec<DnsQuestion>,
+    pub answers: Vec<DnsRecord>,
+    pub authorities: Vec<DnsRecord>,
+    pub resources: Vec<DnsRecord>,
+}
+
+impl Packet {
+    pub fn new() -> Self {
+        Self {
+            header: DnsHeader::new(),
+            questions: Vec::new(),
+            answers: Vec::new(),
+            authorities: Vec::new(),
+            resources: Vec::new(),
+        }
+    }
+
+    pub fn from_buffer(buffer: &mut PacketBuffer) -> Result<Self> {
+        let mut result = Self::new();
+        result.header.read(buffer)?;
+
+        for _ in 0..result.header.questions {
+            let mut question = DnsQuestion::new("".to_string(), QueryType::UNKNOWN(0));
+            question.read(buffer)?;
+            result.questions.push(question);
+        }
+
+        for _ in 0..result.header.answers {
+            let rec = DnsRecord::read(buffer)?;
+            result.answers.push(rec);
+        }
+        for _ in 0..result.header.authoritative_entries {
+            let rec = DnsRecord::read(buffer)?;
+            result.authorities.push(rec);
+        }
+        for _ in 0..result.header.resource_entries {
+            let rec = DnsRecord::read(buffer)?;
+            result.resources.push(rec);
+        }
+
+        Ok(result)
+    }
+
+    pub fn write(&mut self, buffer: &mut PacketBuffer) -> Result<()> {
+        self.header.questions = self.questions.len() as u16;
+        self.header.answers = self.answers.len() as u16;
+        self.header.authoritative_entries = self.authorities.len() as u16;
+        self.header.resource_entries = self.resources.len() as u16;
+
+        self.header.write(buffer)?;
+
+        for question in &self.questions {
+            question.write(buffer)?;
+        }
+        for rec in &self.answers {
+            rec.write(buffer)?;
+        }
+        for rec in &self.authorities {
+            rec.write(buffer)?;
+        }
+        for rec in &self.resources {
+            rec.write(buffer)?;
+        }
+
+        Ok(())
+    }
+
+    pub fn get_random_a(&self) -> Option<IpAddr> {
+        self.answers
+            .iter()
+            .filter_map(|record| match record {
+                DnsRecord::A { addr, .. } => Some(IpAddr::V4(*addr)),
+                DnsRecord::AAAA { addr, .. } => Some(IpAddr::V6(*addr)),
+                _ => None,
+            })
+            .next()
+    }
+
+    fn get_ns<'a>(&'a self, qname: &'a str) -> impl Iterator<Item = (&'a str, &'a str)> {
+        self.authorities
+            .iter()
+            .filter_map(|record| match record {
+                DnsRecord::NS { domain, host, .. } => Some((domain.as_str(), host.as_str())),
+                _ => None,
+            })
+            .filter(move |(domain, _)| qname.ends_with(*domain))
+    }
+
+    pub fn get_resolved_ns(&self, qname: &str) -> Option<IpAddr> {
+        self.get_ns(qname)
+            .flat_map(|(_, host)| {
+                self.resources
+                    .iter()
+                    .filter_map(move |record| match record {
+                        DnsRecord::A { domain, addr, .. } if domain == host => {
+                            Some(IpAddr::V4(*addr))
+                        }
+                        DnsRecord::AAAA { domain, addr, .. } if domain == host => {
+                            Some(IpAddr::V6(*addr))
+                        }
+                        _ => None,
+                    })
+            })
+            .next()
+    }
+
+    pub fn get_unresolved_ns<'a>(&'a self, qname: &'a str) -> Option<&'a str> {
+        self.get_ns(qname).map(|(_, host)| host).next()
+    }
+}
diff --git a/src/packet/query.rs b/src/packet/query.rs
new file mode 100644
index 0000000..cae6f09
--- /dev/null
+++ b/src/packet/query.rs
@@ -0,0 +1,51 @@
+#[derive(PartialEq, Eq, Debug, Clone, Hash, Copy)]
+pub enum QueryType {
+    UNKNOWN(u16),
+    A,     // 1
+    NS,    // 2
+    CNAME, // 5
+    SOA,   // 6
+    PTR,   // 12
+    MX,    // 15
+    TXT,   // 16
+    AAAA,  // 28
+    SRV,   // 33
+    OPT,   // 41
+    CAA,   // 257
+}
+
+impl QueryType {
+    pub fn to_num(&self) -> u16 {
+        match *self {
+            Self::UNKNOWN(x) => x,
+            Self::A => 1,
+            Self::NS => 2,
+            Self::CNAME => 5,
+            Self::SOA => 6,
+            Self::PTR => 12,
+            Self::MX => 15,
+            Self::TXT => 16,
+            Self::AAAA => 28,
+            Self::SRV => 33,
+            Self::OPT => 41,
+            Self::CAA => 257,
+        }
+    }
+
+    pub fn from_num(num: u16) -> Self {
+        match num {
+            1 => Self::A,
+            2 => Self::NS,
+            5 => Self::CNAME,
+            6 => Self::SOA,
+            12 => Self::PTR,
+            15 => Self::MX,
+            16 => Self::TXT,
+            28 => Self::AAAA,
+            33 => Self::SRV,
+            41 => Self::OPT,
+            257 => Self::CAA,
+            _ => Self::UNKNOWN(num),
+        }
+    }
+}
diff --git a/src/packet/question.rs b/src/packet/question.rs
new file mode 100644
index 0000000..9042e1c
--- /dev/null
+++ b/src/packet/question.rs
@@ -0,0 +1,31 @@
+use super::{buffer::PacketBuffer, query::QueryType, Result};
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct DnsQuestion {
+    pub name: String,
+    pub qtype: QueryType,
+}
+
+impl DnsQuestion {
+    pub fn new(name: String, qtype: QueryType) -> Self {
+        Self { name, qtype }
+    }
+
+    pub fn read(&mut self, buffer: &mut PacketBuffer) -> Result<()> {
+        buffer.read_qname(&mut self.name)?;
+        self.qtype = QueryType::from_num(buffer.read_u16()?); // qtype
+        let _ = buffer.read_u16()?; // class
+
+        Ok(())
+    }
+
+    pub fn write(&self, buffer: &mut PacketBuffer) -> Result<()> {
+        buffer.write_qname(&self.name)?;
+
+        let typenum = self.qtype.to_num();
+        buffer.write_u16(typenum)?;
+        buffer.write_u16(1)?;
+
+        Ok(())
+    }
+}
diff --git a/src/packet/record.rs b/src/packet/record.rs
new file mode 100644
index 0000000..c29dd8f
--- /dev/null
+++ b/src/packet/record.rs
@@ -0,0 +1,498 @@
+use std::net::{Ipv4Addr, Ipv6Addr};
+
+use tracing::{trace, warn};
+
+use super::{buffer::PacketBuffer, query::QueryType, Result};
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[allow(dead_code)]
+pub enum DnsRecord {
+    UNKNOWN {
+        domain: String,
+        qtype: u16,
+        data_len: u16,
+        ttl: u32,
+    }, // 0
+    A {
+        domain: String,
+        addr: Ipv4Addr,
+        ttl: u32,
+    }, // 1
+    NS {
+        domain: String,
+        host: String,
+        ttl: u32,
+    }, // 2
+    CNAME {
+        domain: String,
+        host: String,
+        ttl: u32,
+    }, // 5
+    SOA {
+        domain: String,
+        mname: String,
+        nname: String,
+        serial: u32,
+        refresh: u32,
+        retry: u32,
+        expire: u32,
+        minimum: u32,
+        ttl: u32,
+    }, // 6
+    PTR {
+        domain: String,
+        pointer: String,
+        ttl: u32,
+    }, // 12
+    MX {
+        domain: String,
+        priority: u16,
+        host: String,
+        ttl: u32,
+    }, // 15
+    TXT {
+        domain: String,
+        text: Vec<String>,
+        ttl: u32,
+    }, //16
+    AAAA {
+        domain: String,
+        addr: Ipv6Addr,
+        ttl: u32,
+    }, // 28
+    SRV {
+        domain: String,
+        priority: u16,
+        weight: u16,
+        port: u16,
+        target: String,
+        ttl: u32,
+    }, // 33
+    CAA {
+        domain: String,
+        flags: u8,
+        length: u8,
+        tag: String,
+        value: String,
+        ttl: u32,
+    }, // 257
+}
+
+impl DnsRecord {
+
+    pub fn read(buffer: &mut PacketBuffer) -> Result<Self> {
+        let mut domain = String::new();
+        buffer.read_qname(&mut domain)?;
+
+        let qtype_num = buffer.read_u16()?;
+        let qtype = QueryType::from_num(qtype_num);
+        let _ = buffer.read_u16()?;
+        let ttl = buffer.read_u32()?;
+        let data_len = buffer.read_u16()?;
+
+        let header_pos = buffer.pos();
+
+        trace!("Reading DNS Record TYPE: {:?}", qtype);
+
+        match qtype {
+            QueryType::A => {
+                let raw_addr = buffer.read_u32()?;
+                let addr = Ipv4Addr::new(
+                    ((raw_addr >> 24) & 0xFF) as u8,
+                    ((raw_addr >> 16) & 0xFF) as u8,
+                    ((raw_addr >> 8) & 0xFF) as u8,
+                    (raw_addr & 0xFF) as u8,
+                );
+
+                Ok(Self::A { domain, addr, ttl })
+            }
+            QueryType::AAAA => {
+                let raw_addr1 = buffer.read_u32()?;
+                let raw_addr2 = buffer.read_u32()?;
+                let raw_addr3 = buffer.read_u32()?;
+                let raw_addr4 = buffer.read_u32()?;
+                let addr = Ipv6Addr::new(
+                    ((raw_addr1 >> 16) & 0xFFFF) as u16,
+                    (raw_addr1 & 0xFFFF) as u16,
+                    ((raw_addr2 >> 16) & 0xFFFF) as u16,
+                    (raw_addr2 & 0xFFFF) as u16,
+                    ((raw_addr3 >> 16) & 0xFFFF) as u16,
+                    (raw_addr3 & 0xFFFF) as u16,
+                    ((raw_addr4 >> 16) & 0xFFFF) as u16,
+                    (raw_addr4 & 0xFFFF) as u16,
+                );
+
+                Ok(Self::AAAA { domain, addr, ttl })
+            }
+            QueryType::NS => {
+                let mut ns = String::new();
+                buffer.read_qname(&mut ns)?;
+
+                Ok(Self::NS {
+                    domain,
+                    host: ns,
+                    ttl,
+                })
+            }
+            QueryType::CNAME => {
+                let mut cname = String::new();
+                buffer.read_qname(&mut cname)?;
+
+                Ok(Self::CNAME {
+                    domain,
+                    host: cname,
+                    ttl,
+                })
+            }
+            QueryType::SOA => {
+                let mut mname = String::new();
+                buffer.read_qname(&mut mname)?;
+
+                let mut nname = String::new();
+                buffer.read_qname(&mut nname)?;
+
+                let serial = buffer.read_u32()?;
+                let refresh = buffer.read_u32()?;
+                let retry = buffer.read_u32()?;
+                let expire = buffer.read_u32()?;
+                let minimum = buffer.read_u32()?;
+
+                Ok(Self::SOA {
+                    domain,
+                    mname,
+                    nname,
+                    serial,
+                    refresh,
+                    retry,
+                    expire,
+                    minimum,
+                    ttl,
+                })
+            }
+            QueryType::PTR => {
+                let mut pointer = String::new();
+                buffer.read_qname(&mut pointer)?;
+
+                Ok(Self::PTR {
+                    domain,
+                    pointer,
+                    ttl,
+                })
+            }
+            QueryType::MX => {
+                let priority = buffer.read_u16()?;
+                let mut mx = String::new();
+                buffer.read_qname(&mut mx)?;
+
+                Ok(Self::MX {
+                    domain,
+                    priority,
+                    host: mx,
+                    ttl,
+                })
+            }
+            QueryType::TXT => {
+                let mut text = Vec::new();
+
+                loop {
+                    let mut s = String::new();
+                    buffer.read_string(&mut s)?;
+
+                    if s.len() == 0 {
+                        break;
+                    } else {
+                        text.push(s);
+                    }
+                }
+
+                Ok(Self::TXT { domain, text, ttl })
+            }
+            QueryType::SRV => {
+                let priority = buffer.read_u16()?;
+                let weight = buffer.read_u16()?;
+                let port = buffer.read_u16()?;
+
+                let mut target = String::new();
+                buffer.read_qname(&mut target)?;
+
+                Ok(Self::SRV {
+                    domain,
+                    priority,
+                    weight,
+                    port,
+                    target,
+                    ttl,
+                })
+            }
+            QueryType::CAA => {
+                let flags = buffer.read()?;
+                let length = buffer.read()?;
+
+                let mut tag = String::new();
+                buffer.read_string_n(&mut tag, length)?;
+
+                let value_len = (data_len as usize) + header_pos - buffer.pos;
+                let mut value = String::new();
+                buffer.read_string_n(&mut value, value_len as u8)?;
+
+                Ok(Self::CAA {
+                    domain,
+                    flags,
+                    length,
+                    tag,
+                    value,
+                    ttl,
+                })
+            }
+            QueryType::UNKNOWN(_) | _ => {
+                buffer.step(data_len as usize)?;
+
+                Ok(Self::UNKNOWN {
+                    domain,
+                    qtype: qtype_num,
+                    data_len,
+                    ttl,
+                })
+            }
+        }
+    }
+
+    pub fn write(&self, buffer: &mut PacketBuffer) -> Result<usize> {
+        let start_pos = buffer.pos();
+
+        trace!("Writing DNS Record {:?}", self);
+
+        match *self {
+            Self::A {
+                ref domain,
+                ref addr,
+                ttl,
+            } => {
+                buffer.write_qname(domain)?;
+                buffer.write_u16(QueryType::A.to_num())?;
+                buffer.write_u16(1)?;
+                buffer.write_u32(ttl)?;
+                buffer.write_u16(4)?;
+
+                let octets = addr.octets();
+                buffer.write_u8(octets[0])?;
+                buffer.write_u8(octets[1])?;
+                buffer.write_u8(octets[2])?;
+                buffer.write_u8(octets[3])?;
+            }
+            Self::NS {
+                ref domain,
+                ref host,
+                ttl,
+            } => {
+                buffer.write_qname(domain)?;
+                buffer.write_u16(QueryType::NS.to_num())?;
+                buffer.write_u16(1)?;
+                buffer.write_u32(ttl)?;
+
+                let pos = buffer.pos();
+                buffer.write_u16(0)?;
+
+                buffer.write_qname(host)?;
+
+                let size = buffer.pos() - (pos + 2);
+                buffer.set_u16(pos, size as u16)?;
+            }
+            Self::CNAME {
+                ref domain,
+                ref host,
+                ttl,
+            } => {
+                buffer.write_qname(domain)?;
+                buffer.write_u16(QueryType::CNAME.to_num())?;
+                buffer.write_u16(1)?;
+                buffer.write_u32(ttl)?;
+
+                let pos = buffer.pos();
+                buffer.write_u16(0)?;
+
+                buffer.write_qname(host)?;
+
+                let size = buffer.pos() - (pos + 2);
+                buffer.set_u16(pos, size as u16)?;
+            }
+            Self::SOA {
+                ref domain,
+                ref mname,
+                ref nname,
+                serial,
+                refresh,
+                retry,
+                expire,
+                minimum,
+                ttl,
+            } => {
+                buffer.write_qname(domain)?;
+                buffer.write_u16(QueryType::SOA.to_num())?;
+                buffer.write_u16(1)?;
+                buffer.write_u32(ttl)?;
+
+                let pos = buffer.pos();
+                buffer.write_u16(0)?;
+
+                buffer.write_qname(mname)?;
+                buffer.write_qname(nname)?;
+                buffer.write_u32(serial)?;
+                buffer.write_u32(refresh)?;
+                buffer.write_u32(retry)?;
+                buffer.write_u32(expire)?;
+                buffer.write_u32(minimum)?;
+
+                let size = buffer.pos() - (pos + 2);
+                buffer.set_u16(pos, size as u16)?;
+            }
+            Self::PTR {
+                ref domain,
+                ref pointer,
+                ttl,
+            } => {
+                buffer.write_qname(domain)?;
+                buffer.write_u16(QueryType::NS.to_num())?;
+                buffer.write_u16(1)?;
+                buffer.write_u32(ttl)?;
+
+                let pos = buffer.pos();
+                buffer.write_u16(0)?;
+
+                buffer.write_qname(&pointer)?;
+
+                let size = buffer.pos() - (pos + 2);
+                buffer.set_u16(pos, size as u16)?;
+            }
+            Self::MX {
+                ref domain,
+                priority,
+                ref host,
+                ttl,
+            } => {
+                buffer.write_qname(domain)?;
+                buffer.write_u16(QueryType::MX.to_num())?;
+                buffer.write_u16(1)?;
+                buffer.write_u32(ttl)?;
+
+                let pos = buffer.pos();
+                buffer.write_u16(0)?;
+
+                buffer.write_u16(priority)?;
+                buffer.write_qname(host)?;
+
+                let size = buffer.pos() - (pos + 2);
+                buffer.set_u16(pos, size as u16)?;
+            }
+            Self::TXT {
+                ref domain,
+                ref text,
+                ttl,
+            } => {
+                buffer.write_qname(&domain)?;
+                buffer.write_u16(QueryType::TXT.to_num())?;
+                buffer.write_u16(1)?;
+                buffer.write_u32(ttl)?;
+
+                let pos = buffer.pos();
+                buffer.write_u16(0)?;
+
+                if text.is_empty() {
+                    return Ok(buffer.pos() - start_pos);
+                }
+
+                for s in text {
+                    buffer.write_u8(s.len() as u8)?;
+                    buffer.write_string(&s)?;
+                }
+                let size = buffer.pos() - (pos + 2);
+                buffer.set_u16(pos, size as u16)?;
+            }
+            Self::AAAA {
+                ref domain,
+                ref addr,
+                ttl,
+            } => {
+                buffer.write_qname(domain)?;
+                buffer.write_u16(QueryType::AAAA.to_num())?;
+                buffer.write_u16(1)?;
+                buffer.write_u32(ttl)?;
+                buffer.write_u16(16)?;
+
+                for octet in &addr.segments() {
+                    buffer.write_u16(*octet)?;
+                }
+            }
+            Self::SRV {
+                ref domain,
+                priority,
+                weight,
+                port,
+                ref target,
+                ttl,
+            } => {
+                buffer.write_qname(domain)?;
+                buffer.write_u16(QueryType::SRV.to_num())?;
+                buffer.write_u16(1)?;
+                buffer.write_u32(ttl)?;
+
+                let pos = buffer.pos();
+                buffer.write_u16(0)?;
+
+                buffer.write_u16(priority)?;
+                buffer.write_u16(weight)?;
+                buffer.write_u16(port)?;
+                buffer.write_qname(target)?;
+
+                let size = buffer.pos() - (pos + 2);
+                buffer.set_u16(pos, size as u16)?;
+            }
+            Self::CAA {
+                ref domain,
+                flags,
+                length,
+                ref tag,
+                ref value,
+                ttl,
+            } => {
+                buffer.write_qname(domain)?;
+                buffer.write_u16(QueryType::CAA.to_num())?;
+                buffer.write_u16(1)?;
+                buffer.write_u32(ttl)?;
+
+                let pos = buffer.pos();
+                buffer.write_u16(0)?;
+
+                buffer.write_u8(flags)?;
+                buffer.write_u8(length)?;
+                buffer.write_string(tag)?;
+                buffer.write_string(value)?;
+
+                let size = buffer.pos() - (pos + 2);
+                buffer.set_u16(pos, size as u16)?;
+            }
+            Self::UNKNOWN { .. } => {
+                warn!("Skipping record: {self:?}");
+            }
+        }
+
+        Ok(buffer.pos() - start_pos)
+    }
+
+    pub fn get_ttl(&self) -> u32 {
+        match *self {
+            DnsRecord::UNKNOWN { .. } => 0,
+            DnsRecord::AAAA { ttl, .. } => ttl,
+            DnsRecord::A { ttl, .. } => ttl,
+            DnsRecord::NS { ttl, .. } => ttl,
+            DnsRecord::CNAME { ttl, .. } => ttl,
+            DnsRecord::SOA { ttl, .. } => ttl,
+            DnsRecord::PTR { ttl, .. } => ttl,
+            DnsRecord::MX { ttl, .. } => ttl,
+            DnsRecord::TXT { ttl, .. } => ttl,
+            DnsRecord::SRV { ttl, .. } => ttl,
+            DnsRecord::CAA { ttl, .. } => ttl,
+        }
+    }
+    
+}
diff --git a/src/packet/result.rs b/src/packet/result.rs
new file mode 100644
index 0000000..41c8ba9
--- /dev/null
+++ b/src/packet/result.rs
@@ -0,0 +1,22 @@
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum ResultCode {
+    NOERROR = 0,
+    FORMERR = 1,
+    SERVFAIL = 2,
+    NXDOMAIN = 3,
+    NOTIMP = 4,
+    REFUSED = 5,
+}
+
+impl ResultCode {
+    pub fn from_num(num: u8) -> Self {
+        match num {
+            1 => Self::FORMERR,
+            2 => Self::SERVFAIL,
+            3 => Self::NXDOMAIN,
+            4 => Self::NOTIMP,
+            5 => Self::REFUSED,
+            0 | _ => Self::NOERROR,
+        }
+    }
+}