initial

src/main.rs

@@ -0,0 +1,127 @@
+use hickory_resolver::proto::rr::rdata::*;
+use hickory_resolver::Resolver;
+use hickory_resolver::config::*;
+
+// #[derive(Debug)]
+struct Domain {
+    domain_name: String,
+    subdomains: Vec<Domain>,
+    a_records: Vec<A>,
+    aaaa_records: Vec<AAAA>,
+    txt_records: Vec<TXT>,
+    mx_records: Vec<MX>,
+    resolver: Resolver
+}
+
+impl Domain {
+    fn new(domain: String) -> Domain {
+        Domain {
+            domain_name: domain,
+            subdomains: vec![],
+            a_records: vec![],
+            aaaa_records: vec![],
+            txt_records: vec![],
+            mx_records: vec![],
+            resolver: Resolver::new(ResolverConfig::default(), ResolverOpts::default()).unwrap(),
+        }
+    }
+
+    fn append_subdomain(&mut self, subdomain: String) {
+        let mut new_domain = String::from(subdomain);
+        new_domain.push_str(".");
+        new_domain.push_str(&self.domain_name);
+        let subdomain = Domain::new(new_domain);
+        self.subdomains.push(subdomain);
+        // println!("Added: {}", new_domain);
+    }
+
+    fn lookup_all_records(&mut self) {
+       // Lookup A records
+       self.lookup_a();
+
+       // Lookup AAAA records
+        self.lookup_aaaa();
+
+       // Lookup MX records
+       self.lookup_mx();
+
+       // Lookup TXT records
+       self.lookup_txt();
+
+       // Do subdomains?
+       for subdomain in &mut self.subdomains {
+        // println!("Looking up subdomain: {}", subdomain.domain_name);
+        subdomain.lookup_all_records();
+       }
+    }
+
+    fn lookup_a(&mut self) {
+        let response = self.resolver.ipv4_lookup(&self.domain_name);
+        match response {
+            Ok(rec) => {
+                for entry in rec {
+                    self.a_records.push(entry);
+                }
+            },
+            Err(_err) => {},
+        }
+    }
+
+    fn lookup_aaaa(&mut self) {
+        let response = self.resolver.ipv6_lookup(&self.domain_name);
+        match response {
+            Ok(rec) => {
+                for entry in rec {
+                    self.aaaa_records.push(entry);
+                }
+            },
+            Err(_err) => {} // Log error
+        }
+    }
+
+    fn lookup_mx(&mut self) {
+        let response = self.resolver.mx_lookup(&self.domain_name);
+        match response {
+            Ok(rec) => {
+                for entry in rec {
+                    self.mx_records.push(entry);
+                }
+            },
+            Err(_err) => {},
+        }
+    }
+
+    fn lookup_txt(&mut self) {
+        let response = self.resolver.txt_lookup(&self.domain_name);
+        match response {
+            Ok(rec) => {
+                for entry in rec {
+                    self.txt_records.push(entry);
+                }
+            },
+            Err(_err) => {},
+        }
+    }
+}
+
+fn main() {
+
+    let mut test = Domain::new("swin.edu.au.".to_string());
+    test.append_subdomain("www".to_string());
+    test.append_subdomain("mail".to_string());
+    test.append_subdomain("ftp".to_string());
+    test.lookup_all_records();
+    println!("A Records: {:?}", test.a_records);
+    println!("AAAA Records: {:?}", test.aaaa_records);
+    println!("MX Records: {:?}", test.mx_records);
+    for rec in test.txt_records.iter() {
+        println!("TXT Records: {}", rec);
+    }
+
+    println!("\n\nSubdomains");
+    for subdom in test.subdomains {
+        println!("{}", subdom.domain_name);
+        println!("{:?}", subdom.a_records);
+    }
+    // println!("TXT Records: {:#?}", test.txt_records);
+}