Updated whois module, added .co.uk nameservers

src/logger.rs

@@ -0,0 +1,33 @@
+use std::fs::OpenOptions;
+use std::io::prelude::*;
+use std::path::Path;
+
+enum LoggerType {
+    Local(&'static str),
+}
+
+pub struct Logger {
+    l_type: LoggerType,
+}
+
+impl Logger {
+    pub fn new(path: &'static str) -> Logger {
+        Logger {
+            l_type: LoggerType::Local(path),
+        }
+    }
+
+    pub fn write_log_line(&self, data: String) {
+        match self.l_type {
+            LoggerType::Local(path) => {
+                let mut file = OpenOptions::new()
+                    .write(true)
+                    .append(true)
+                    .create(true)
+                    .open(path)
+                    .unwrap();
+                writeln!(file, "{}", data).unwrap();
+            }
+        }
+    }
+}

src/main.rs

@@ -17,6 +17,8 @@ mod whois;
 use whois::default;
 use whois::selector::*;
 
+mod logger;
+
 use crossterm::event::{
     self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode, KeyEventKind,
 };
@@ -27,14 +29,14 @@ use crossterm::terminal::{
 use ratatui::backend::{Backend, CrosstermBackend};
 use ratatui::Terminal;
 use std::error::Error;
-use std::io::{self, stderr};
+use std::io::{self, stdout};
 
 fn main() -> Result<(), Box<dyn Error>> {
     enable_raw_mode()?;
-    let mut stderr = stderr();
+    let mut stdout = stdout();
-    execute!(stderr, EnterAlternateScreen)?;
+    execute!(stdout, EnterAlternateScreen)?;
 
-    let backend = CrosstermBackend::new(stderr);
+    let backend = CrosstermBackend::new(stdout);
     let mut terminal = Terminal::new(backend)?;
 
     // Initialise the App and config

src/whois/uk.rs

@@ -27,6 +27,12 @@ impl Whois for _Whois {
         registrar.push_str(&self.base.registrar.clone().unwrap());
         ret_vec.push(registrar);
 
+        for nameserver in &self.base.nameservers.clone().unwrap() {
+            let mut tmp = String::from("Nameserver: ");
+            tmp.push_str(&nameserver.host);
+            ret_vec.push(tmp);
+        }
+
         return ret_vec;
     }
     fn lookup(&mut self, domain: String) -> Vec<String> {
@@ -35,14 +41,16 @@ impl Whois for _Whois {
             .lookup(WhoIsLookupOptions::from_string(domain).unwrap())
             .unwrap();
 
-        let registrar_regex = RegexQuery::new(String::from(r"(?mi)(.*registrar:.*\n)(.*?\[)"));
+        let registrar_regex = RegexQuery::new(String::from(r"(?mi)(.*registrar:.*\n)(.*)"));
         let nameserver_regex =
-            RegexQuery::new(String::from(r"(?mi)(.*name servers:\r\n)((.*\r\n))"));
+            RegexQuery::new(String::from(r"(?miR)(.*name servers:\r\n)((.+\.+.+)+)"));
 
         let registrar = WhoisData::return_regex(registrar_regex.get_matches(&result), 0);
-        // let nameserver_regex = WhoisData::return_regex(self.get_matches(&result), 0);
+        let nameservers = nameserver_regex.captures(&result);
+        // println!("{:?}", nameservers);
 
         self.base.registrar = Some(registrar.clone());
+        self.base.nameservers = Some(nameservers.clone());
 
         self.to_vec()
     }

src/whois/whois_base.rs

@@ -1,3 +1,4 @@
+use crate::logger::Logger;
 use core::fmt;
 use regex::Regex;
 
@@ -34,6 +35,24 @@ impl RegexQuery {
         }
         results
     }
+    pub fn captures(&self, haystack: &str) -> Vec<NameServer> {
+        // let logger = Logger::new("log.txt");
+        let mut results: Vec<NameServer> = vec![];
+        match self.re.captures(haystack) {
+            Some(rex) => {
+                for x in 1..rex.len() {
+                    if x == 1 {
+                        continue;
+                    };
+                    results.push(NameServer::new(String::from(
+                        rex.get(x).unwrap().as_str().trim(),
+                    )));
+                }
+            }
+            None => {}
+        }
+        results
+    }
 }
 
 #[derive(Debug, Clone)]