rename packet terminology to message

Signed-off-by: Sanskar Jaiswal <[email protected]>

Author: aryan9600

src/bin/client.rs

@@ -15,8 +15,8 @@ async fn main() -> Result<()> {
     let rr_type = rr_types::str_to_record_type(&record_type)?;
 
     let resolver = Resolver::new("0.0.0.0:3400").await?;
-    let packet = resolver.resolve(domain, &rr_type).await?;
-    let ips = packet.answers_data(&rr_type);
+    let message = resolver.resolve(domain, &rr_type).await?;
+    let ips = message.answers_data(&rr_type);
 
     println!("answer(s): {:?}", ips);
     Ok(())

src/bin/server.rs

@@ -1,13 +1,13 @@
 use anyhow::Result;
 use dns_resolver::cache::DNSCache;
-use dns_resolver::packet::DNSPacket;
+use dns_resolver::message::DNSMessage;
 use dns_resolver::query::{DNSHeader, DNSQuestion, QR};
 use dns_resolver::resolver::Resolver;
 use tokio::net::UdpSocket;
 
 #[tokio::main]
 async fn main() -> Result<()> {
-    let socket = UdpSocket::bind("0.0.0.0:3500").await?;
+    let socket = UdpSocket::bind("127.0.0.1:3500").await?;
     let mut cache = DNSCache::new(100);
     loop {
         let mut buf = [0; 1024];
@@ -17,7 +17,7 @@ async fn main() -> Result<()> {
 
         let header = DNSHeader::decode(&mut query_iter)?;
         let question = DNSQuestion::decode(&mut query_iter)?;
-        let mut packet: DNSPacket;
+        let mut message: DNSMessage;
         if let Some(answer) = cache.get(question.name(), question.q_type()) {
             let mut new_header = DNSHeader::new(
                 header.id(),
@@ -32,16 +32,20 @@ async fn main() -> Result<()> {
             new_header.set_recursion_available(true);
             let questions = vec![question];
             let answers = answer.data();
-            packet = DNSPacket::new(new_header, questions, answers, vec![], vec![]);
+            message = DNSMessage::new(new_header, questions, answers, vec![], vec![]);
         } else {
             let resolver = Resolver::new("0.0.0.0:3400").await?;
             let domain = question.name().0.clone();
-            packet = resolver.resolve(domain, question.q_type()).await?;
-            packet.set_id(header.id());
-            cache.insert(question.name(), question.q_type(), packet.answers().clone());
+            message = resolver.resolve(domain, question.q_type()).await?;
+            message.set_id(header.id());
+            cache.insert(
+                question.name(),
+                question.q_type(),
+                message.answers().clone(),
+            );
         }
 
-        let encoded = packet.encode()?;
+        let encoded = message.encode()?;
         socket.send_to(&encoded, addr).await?;
     }
 }

src/domain_name.rs

@@ -18,7 +18,7 @@ impl LabelSequenceParser {
     }
 
     // Constructs the domain name from its wire format.
-    // response is supposed to be the entire DNS packet required
+    // response is supposed to be the entire DNS message required
     // to go back to where a pointer is pointing.
     pub fn construct_domain_name<'a, T>(
         &mut self,
@@ -166,7 +166,7 @@ impl DomainName {
         let mut parts_iter = parts.iter();
         loop {
             if let Some(part) = parts_iter.next() {
-                // check if the label is already present somewhere in the encoded packet.
+                // check if the label is already present somewhere in the encoded message.
                 if let Some(idx) = find_subset_index(&encoded, &part.1) {
                     // subtract 1 here since we need to include the length octect that appears
                     // before the start of label.

src/lib.rs

@@ -1,7 +1,7 @@
 pub mod cache;
 pub mod domain_name;
 pub mod error;
-pub mod packet;
+pub mod message;
 pub mod query;
 pub mod resolver;
 pub mod resource_record;

src/packet.rs src/message.rs

@@ -5,59 +5,60 @@ use crate::{
     rr_types::RRType,
 };
 
-// DNSPacket represents a DNS packet.
+// DNSMessage represents a DNS message.
 #[derive(Debug)]
-pub struct DNSPacket {
+pub struct DNSMessage {
     header: DNSHeader,
     questions: Vec<DNSQuestion>,
     answers: Vec<DNSRecord>,
     authorities: Vec<DNSRecord>,
     additionals: Vec<DNSRecord>,
 }
 
-impl DNSPacket {
+impl DNSMessage {
     pub fn new(
         header: DNSHeader,
         questions: Vec<DNSQuestion>,
         answers: Vec<DNSRecord>,
         authorities: Vec<DNSRecord>,
         additionals: Vec<DNSRecord>,
-    ) -> DNSPacket {
-        DNSPacket {
+    ) -> DNSMessage {
+        DNSMessage {
             header,
             questions,
             answers,
             authorities,
             additionals,
         }
     }
-    // Decode the packet from its wire format into our representation.
-    pub fn decode(packet: &Vec<u8>) -> Result<DNSPacket> {
-        let mut packet_iter = packet.iter();
+
+    // Decode the message from its wire format into our representation.
+    pub fn decode(message: &Vec<u8>) -> Result<DNSMessage> {
+        let mut message_iter = message.iter();
         let mut questions = vec![];
         let mut answers = vec![];
         let mut authorities = vec![];
         let mut additionals = vec![];
 
-        let header = DNSHeader::decode(&mut packet_iter)?;
+        let header = DNSHeader::decode(&mut message_iter)?;
         for _ in 0..header.num_questions() {
-            let question = DNSQuestion::decode(&mut packet_iter)?;
+            let question = DNSQuestion::decode(&mut message_iter)?;
             questions.push(question);
         }
         for _ in 0..header.num_answers() {
-            let answer = DNSRecord::decode(&mut packet_iter, &mut packet.iter())?;
+            let answer = DNSRecord::decode(&mut message_iter, &mut message.iter())?;
             answers.push(answer);
         }
         for _ in 0..header.num_authorities() {
-            let rr = DNSRecord::decode(&mut packet_iter, &mut packet.iter())?;
+            let rr = DNSRecord::decode(&mut message_iter, &mut message.iter())?;
             authorities.push(rr);
         }
         for _ in 0..header.num_additionals() {
-            let rr = DNSRecord::decode(&mut packet_iter, &mut packet.iter())?;
+            let rr = DNSRecord::decode(&mut message_iter, &mut message.iter())?;
             additionals.push(rr);
         }
 
-        Ok(DNSPacket {
+        Ok(DNSMessage {
             header,
             questions,
             answers,
@@ -66,7 +67,7 @@ impl DNSPacket {
         })
     }
 
-    // Encode the packet into the wire format.
+    // Encode the message into the wire format.
     pub fn encode(&self) -> Result<Vec<u8>> {
         let mut encoded = vec![];
         self.header.encode(&mut encoded);
@@ -85,7 +86,6 @@ impl DNSPacket {
         Ok(encoded)
     }
 
-    // Sets the provided id as its header's id.
     pub fn set_id(&mut self, id: u16) {
         self.header.set_id(id);
     }

src/query.rs

@@ -99,24 +99,29 @@ impl DNSHeader {
         }
     }
 
+    // Set the QR (0th) bit of the header's flags.
+    // 1 signfies a response; 0 signfies a query.
     pub fn set_qr(&mut self, qr: QR) {
         self.flags = set_bit(self.flags, qr as u8, 0);
     }
 
-    pub fn set_opcode_std_query(&mut self) {
-        for i in 1..5 {
-            self.flags = set_bit(self.flags, 0, i);
-        }
-    }
-
+    // Set the RD (7th) bit of the header's flags.
+    // Signifies whether recursion is desired.
     pub fn set_recursion_desired(&mut self, rd: bool) {
         self.flags = set_bit(self.flags, rd as u8, 7);
     }
 
+    // Set the RA (8th) bit of the header's flags.
+    // Signifies whether recursion is available.
     pub fn set_recursion_available(&mut self, ra: bool) {
         self.flags = set_bit(self.flags, ra as u8, 8);
     }
 
+    // Set the header ID.
+    pub fn set_id(&mut self, id: u16) {
+        self.id = id
+    }
+
     pub fn id(&self) -> u16 {
         self.id
     }
@@ -145,10 +150,6 @@ impl DNSHeader {
         return self.ar_count;
     }
 
-    pub fn set_id(&mut self, id: u16) {
-        self.id = id
-    }
-
     // Encode the header into the provided vector in its wire format.
     pub fn encode(&self, encoded: &mut Vec<u8>) {
         encoded.extend(self.id.to_be_bytes());

src/resolver.rs

@@ -1,5 +1,5 @@
 use crate::error::{DNSResolverError, Result};
-use crate::packet::DNSPacket;
+use crate::message::DNSMessage;
 use crate::query::{self};
 use crate::rr_types::RRType;
 use std::future::Future;
@@ -20,8 +20,8 @@ impl Resolver {
     }
 
     // Constructs a DNS query out of the provided domain and record type, resolves
-    // the same and returns the resolved DNS packet.
-    pub async fn resolve(&self, domain: String, record_type: &RRType) -> Result<DNSPacket> {
+    // the same and returns the resolved DNS message.
+    pub async fn resolve(&self, domain: String, record_type: &RRType) -> Result<DNSMessage> {
         match record_type {
             &RRType::A => self.resolve_a_record(domain).await,
             &RRType::CNAME => self.resolve_cname_record(domain).await,
@@ -35,7 +35,9 @@ impl Resolver {
         }
     }
 
-    async fn resolve_ns_record(&self, domain: String) -> Result<DNSPacket> {
+    // Constructs a DNS query of type NS using the provided domain, resolves
+    // the same and returns the resolved DNS message.
+    async fn resolve_ns_record(&self, domain: String) -> Result<DNSMessage> {
         let mut nameserver = String::from("198.41.0.4");
         let record_type = RRType::NS;
 
@@ -47,17 +49,17 @@ impl Resolver {
             let response = self
                 .send_query(nameserver, domain.clone(), record_type.clone())
                 .await?;
-            let packet = DNSPacket::decode(&response)?;
+            let message = DNSMessage::decode(&response)?;
 
-            if packet.answers_data(&record_type).len() > 0 {
-                return Ok(packet);
-            } else if packet.answers_data(&RRType::CNAME).len() > 0 {
-                let cname = packet.answers_data(&RRType::CNAME)[0].clone();
+            if message.answers_data(&record_type).len() > 0 {
+                return Ok(message);
+            } else if message.answers_data(&RRType::CNAME).len() > 0 {
+                let cname = message.answers_data(&RRType::CNAME)[0].clone();
                 let resolved_cname = self.resolve_a_record(cname).await?;
                 return Ok(resolved_cname);
-            } else if let Some(ns_ip) = packet.ns_ip() {
+            } else if let Some(ns_ip) = message.ns_ip() {
                 nameserver = ns_ip.to_owned();
-            } else if let Some(ns) = packet.nameserver() {
+            } else if let Some(ns) = message.nameserver() {
                 let resolved_ns = self.resolve_a_record(ns.to_owned()).await?;
                 nameserver = resolved_ns.answers_data(&RRType::A)[0].clone();
             } else {
@@ -66,7 +68,9 @@ impl Resolver {
         }
     }
 
-    async fn resolve_cname_record(&self, domain: String) -> Result<DNSPacket> {
+    // Constructs a DNS query of type CNAME using the provided domain, resolves
+    // the same and returns the resolved DNS message.
+    async fn resolve_cname_record(&self, domain: String) -> Result<DNSMessage> {
         let mut nameserver = String::from("198.41.0.4");
         let record_type = RRType::CNAME;
 
@@ -78,13 +82,13 @@ impl Resolver {
             let response = self
                 .send_query(nameserver, domain.clone(), record_type.clone())
                 .await?;
-            let packet = DNSPacket::decode(&response)?;
+            let message = DNSMessage::decode(&response)?;
 
-            if packet.answers_data(&record_type).len() > 0 {
-                return Ok(packet);
-            } else if let Some(ns_ip) = packet.ns_ip() {
+            if message.answers_data(&record_type).len() > 0 {
+                return Ok(message);
+            } else if let Some(ns_ip) = message.ns_ip() {
                 nameserver = ns_ip.to_owned();
-            } else if let Some(ns) = packet.nameserver() {
+            } else if let Some(ns) = message.nameserver() {
                 let resolved_ns = self.resolve_a_record(ns.to_owned()).await?;
                 nameserver = resolved_ns.answers_data(&RRType::A)[0].clone();
             } else {
@@ -96,7 +100,9 @@ impl Resolver {
         }
     }
 
-    async fn resolve_txt_record(&self, domain: String) -> Result<DNSPacket> {
+    // Constructs a DNS query of type TXT using the provided domain, resolves
+    // the same and returns the resolved DNS message.
+    async fn resolve_txt_record(&self, domain: String) -> Result<DNSMessage> {
         let mut nameserver = String::from("198.41.0.4");
         let record_type = RRType::TXT;
 
@@ -108,13 +114,13 @@ impl Resolver {
             let response = self
                 .send_query(nameserver, domain.clone(), record_type.clone())
                 .await?;
-            let packet = DNSPacket::decode(&response)?;
+            let message = DNSMessage::decode(&response)?;
 
-            if packet.answers_data(&record_type).len() > 0 {
-                return Ok(packet);
-            } else if let Some(ns_ip) = packet.ns_ip() {
+            if message.answers_data(&record_type).len() > 0 {
+                return Ok(message);
+            } else if let Some(ns_ip) = message.ns_ip() {
                 nameserver = ns_ip.to_owned();
-            } else if let Some(ns) = packet.nameserver() {
+            } else if let Some(ns) = message.nameserver() {
                 let resolved_ns = self.resolve_a_record(ns.to_owned()).await?;
                 nameserver = resolved_ns.answers_data(&RRType::A)[0].clone();
             } else {
@@ -123,10 +129,12 @@ impl Resolver {
         }
     }
 
+    // Constructs a DNS query of type A using the provided domain, resolves
+    // the same and returns the resolved DNS message.
     fn resolve_a_record(
         &self,
         domain: String,
-    ) -> Pin<Box<dyn Future<Output = Result<DNSPacket>> + '_>> {
+    ) -> Pin<Box<dyn Future<Output = Result<DNSMessage>> + '_>> {
         Box::pin(async move {
             let mut nameserver = String::from("198.41.0.4");
             let record_type = RRType::A;
@@ -139,17 +147,17 @@ impl Resolver {
                 let response = self
                     .send_query(nameserver, domain.clone(), record_type.clone())
                     .await?;
-                let packet = DNSPacket::decode(&response)?;
+                let message = DNSMessage::decode(&response)?;
 
-                if packet.answers_data(&record_type).len() > 0 {
-                    return Ok(packet);
-                } else if packet.answers_data(&RRType::CNAME).len() > 0 {
-                    let cname = packet.answers_data(&RRType::CNAME)[0].clone();
+                if message.answers_data(&record_type).len() > 0 {
+                    return Ok(message);
+                } else if message.answers_data(&RRType::CNAME).len() > 0 {
+                    let cname = message.answers_data(&RRType::CNAME)[0].clone();
                     let resolved_cname = self.resolve_a_record(cname).await?;
                     return Ok(resolved_cname);
-                } else if let Some(ns_ip) = packet.ns_ip() {
+                } else if let Some(ns_ip) = message.ns_ip() {
                     nameserver = ns_ip.to_owned();
-                } else if let Some(ns) = packet.nameserver() {
+                } else if let Some(ns) = message.nameserver() {
                     let resolved_ns = self.resolve_a_record(ns.to_owned()).await?;
                     nameserver = resolved_ns.answers_data(&RRType::A)[0].clone();
                 } else {