diff --git a/src/main.rs b/src/main.rs index fa38db6..439f387 100644 --- a/src/main.rs +++ b/src/main.rs @@ -32,7 +32,7 @@ use std::io::{self, stderr}; fn main() -> Result<(), Box> { enable_raw_mode()?; let mut stderr = stderr(); - execute!(stderr, EnterAlternateScreen, EnableMouseCapture)?; + execute!(stderr, EnterAlternateScreen)?; let backend = CrosstermBackend::new(stderr); let mut terminal = Terminal::new(backend)?; @@ -45,11 +45,7 @@ fn main() -> Result<(), Box> { let _res = run_app(&mut terminal, &mut app); disable_raw_mode()?; - execute!( - terminal.backend_mut(), - LeaveAlternateScreen, - DisableMouseCapture - )?; + execute!(terminal.backend_mut(), LeaveAlternateScreen)?; terminal.show_cursor()?; Ok(()) } diff --git a/src/whois/au.rs b/src/whois/au.rs index bc2606e..f99ddeb 100644 --- a/src/whois/au.rs +++ b/src/whois/au.rs @@ -2,22 +2,167 @@ use crate::whois::whois_base::{ NameServer, RegexQuery, Registrant, RegistrantType, Whois, WhoisData, }; use whois_rust::{WhoIs, WhoIsLookupOptions}; + +struct Eligibility { + e_type: Option, + e_name: Option, + e_id: Option, + r_id: Option, +} + +impl Eligibility { + fn new() -> Eligibility { + Eligibility { + e_id: Some(String::new()), + e_name: Some(String::new()), + e_type: Some(String::new()), + r_id: Some(String::new()), + } + } +} + pub struct _Whois { base: WhoisData, - elegibility: String, + eligibility: Eligibility, } impl Whois for _Whois { fn new() -> Self { _Whois { base: WhoisData::new(), - elegibility: String::new(), + eligibility: Eligibility::new(), } } fn to_vec(&self) -> Vec { - vec![String::new()] + let mut ret_vec: Vec = vec![]; + let mut registrar = String::from("Registrar: "); + registrar.push_str(&self.base.registrar.clone().unwrap()); + ret_vec.push(registrar); + + let mut domain_status = String::from("Status: "); + domain_status.push_str(&self.base.domain_status.clone().unwrap()); + ret_vec.push(domain_status); + + let mut dnssec = String::from("DNSSEC: "); + dnssec.push_str(&self.base.dnssec.clone().unwrap()); + ret_vec.push(dnssec); + + let mut registrant_type = String::new(); + for registrant in &self.base.registrant.clone().unwrap() { + match registrant.rtype { + RegistrantType::Admin => { + registrant_type.push_str("Admin "); + } + RegistrantType::Billing => { + registrant_type.push_str("Billing "); + } + RegistrantType::Tech => { + registrant_type.push_str("Tech "); + } + RegistrantType::Registrant => { + registrant_type.push_str("Registrant "); + } + } + let mut name = registrant_type.clone(); + name.push_str("Name: "); + name.push_str(®istrant.name); + ret_vec.push(name); + + let mut org = registrant_type.clone(); + org.push_str("Organisation: "); + org.push_str(®istrant.org); + ret_vec.push(org); + + let mut email = registrant_type.clone(); + email.push_str("Email: "); + email.push_str(®istrant.email); + ret_vec.push(email); + } + + for nameserver in &self.base.nameservers.clone().unwrap() { + let mut tmp = String::from("Nameserver: "); + tmp.push_str(&nameserver.host); + ret_vec.push(tmp); + } + + let mut eligibility_name = String::from("Eligibility Name: "); + eligibility_name.push_str(&self.eligibility.e_name.clone().unwrap()); + ret_vec.push(eligibility_name); + + let mut eligibility_type = String::from("Eligibility Type: "); + eligibility_type.push_str(&self.eligibility.e_type.clone().unwrap()); + ret_vec.push(eligibility_type); + + let mut eligibility_id = String::from("Eligibility ID: "); + eligibility_id.push_str(&self.eligibility.e_id.clone().unwrap()); + ret_vec.push(eligibility_id); + + let mut registrant_id = String::from("Registrant ID: "); + registrant_id.push_str(&self.eligibility.r_id.clone().unwrap()); + ret_vec.push(registrant_id); + + return ret_vec; } fn lookup(&mut self, domain: String) -> Vec { + let whois = WhoIs::from_path("servers.json").unwrap(); + let result: String = whois + .lookup(WhoIsLookupOptions::from_string(domain).unwrap()) + .unwrap(); + let registrar_regex = + RegexQuery::new(String::from(r"(?i)(.*registrar:|registrar *name:)(.*)")); + let domain_status_regex = + RegexQuery::new(String::from(r"(?i)(.*domain status:|.*status:)(.* )")); + // TODO: Capture the registrant info for each type + let registrant_name_regex = RegexQuery::new(String::from(r"(?i)(registrant.*name:)(.*)")); + let registrant_org_regex = + RegexQuery::new(String::from(r"(?i)(registrant org.*:|registrant:)(.*)")); + let registrant_email_regex = RegexQuery::new(String::from(r"(?i)(registrant email:)(.*)")); + let nameserver_regex = + RegexQuery::new(String::from(r"(?i)(nameservers*:|name servers*:)(.*)")); + let dnssec_regex = RegexQuery::new(String::from(r"(?i)(.*dnssec:)(.*)")); + let eligebility_name_regex = + RegexQuery::new(String::from(r"(?i)(.*eligibility name:)(.*)")); + let eligebility_type_regex = + RegexQuery::new(String::from(r"(?i)(.*eligibility type:)(.*)")); + let eligebility_id_regex = RegexQuery::new(String::from(r"(?i)(.*eligibility id:)(.*)")); + let registrant_id_regex = RegexQuery::new(String::from(r"(?i)(.*registrant id:)(.*)")); + + let registrar = WhoisData::return_regex(registrar_regex.get_matches(&result), 0); + let domain_status = WhoisData::return_regex(domain_status_regex.get_matches(&result), 0); + let reg_name = WhoisData::return_regex(registrant_name_regex.get_matches(&result), 0); + let reg_org = WhoisData::return_regex(registrant_org_regex.get_matches(&result), 0); + let reg_email = WhoisData::return_regex(registrant_email_regex.get_matches(&result), 0); + + let mut nameservers = vec![]; + for nameserver in nameserver_regex.get_matches(&result) { + nameservers.push(NameServer::new(nameserver)); + } + let mut dnssec = dnssec_regex.get_matches(&result); + if dnssec.len() == 0 { + dnssec = vec![String::from("Failed to get DNSSEC")]; + } + let eligebility_name = + WhoisData::return_regex(eligebility_name_regex.get_matches(&result), 0); + let eligebility_type = + WhoisData::return_regex(eligebility_type_regex.get_matches(&result), 0); + let eligebility_id = WhoisData::return_regex(eligebility_id_regex.get_matches(&result), 0); + let registrant_id = WhoisData::return_regex(registrant_id_regex.get_matches(&result), 0); + + // println!("{:?}", registrar[0]); + self.base.domain_status = Some(domain_status.clone()); + self.base.registrant = Some(vec![Registrant::new( + reg_name.clone(), + reg_org.clone(), + reg_email, + RegistrantType::Registrant, + )]); + self.base.nameservers = Some(nameservers); + self.base.dnssec = Some(dnssec[0].clone()); + self.base.registrar = Some(registrar.clone()); + self.eligibility.e_name = Some(eligebility_name.clone()); + self.eligibility.e_type = Some(eligebility_type.clone()); + self.eligibility.e_id = Some(eligebility_id.clone()); + self.eligibility.r_id = Some(registrant_id.clone()); self.to_vec() } } diff --git a/src/whois/mod.rs b/src/whois/mod.rs index 0a50a90..ae9ab09 100644 --- a/src/whois/mod.rs +++ b/src/whois/mod.rs @@ -1,4 +1,5 @@ pub mod au; pub mod default; pub mod selector; +pub mod uk; pub mod whois_base; diff --git a/src/whois/selector.rs b/src/whois/selector.rs index 50678a3..725c059 100644 --- a/src/whois/selector.rs +++ b/src/whois/selector.rs @@ -1,13 +1,16 @@ -use crate::whois::default; use addr::parse_domain_name; -use super::{au, whois_base::Whois}; +use super::{au, default, uk, whois_base::Whois}; pub fn select_whois_server(domain: String) -> Result, String> { let domain = parse_domain_name(&domain.as_str()); match domain { Ok(val) => match val.suffix() { - ".com.au" => Ok(Box::new(au::_Whois::new())), + "com.au" => Ok(Box::new(au::_Whois::new())), + "org.au" => Ok(Box::new(au::_Whois::new())), + "net.au" => Ok(Box::new(au::_Whois::new())), + "co.uk" => Ok(Box::new(uk::_Whois::new())), + "au" => Ok(Box::new(au::_Whois::new())), _ => Ok(Box::new(default::_Whois::new())), }, Err(_) => Err(String::from("Failed to select whois server")), diff --git a/src/whois/uk.rs b/src/whois/uk.rs new file mode 100644 index 0000000..b3bf726 --- /dev/null +++ b/src/whois/uk.rs @@ -0,0 +1,62 @@ +use crate::whois::whois_base::{ + NameServer, RegexQuery, Registrant, RegistrantType, Whois, WhoisData, +}; +use regex::Regex; +use whois_rust::{WhoIs, WhoIsLookupOptions}; + +// (.*registrar:\n)(.*) + +// (.*name servers:\n)((.*\n)+?^\n) + +pub struct _Whois { + base: WhoisData, +} + +impl Whois for _Whois { + fn new() -> Self + where + Self: Sized, + { + _Whois { + base: WhoisData::new(), + } + } + fn to_vec(&self) -> Vec { + let mut ret_vec: Vec = vec![]; + let mut registrar = String::from("Registrar: "); + registrar.push_str(&self.base.registrar.clone().unwrap()); + ret_vec.push(registrar); + + return ret_vec; + } + fn lookup(&mut self, domain: String) -> Vec { + let whois = WhoIs::from_path("servers.json").unwrap(); + let result: String = whois + .lookup(WhoIsLookupOptions::from_string(domain).unwrap()) + .unwrap(); + + 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))")); + + let registrar = WhoisData::return_regex(registrar_regex.get_matches(&result), 0); + // let nameserver_regex = WhoisData::return_regex(self.get_matches(&result), 0); + + self.base.registrar = Some(registrar.clone()); + + self.to_vec() + } +} + +impl _Whois { + pub fn get_matches(&self, haystack: &str, expression: String) -> Vec { + let re = Regex::new(&expression).unwrap(); + let mut results = vec![]; + for (_, [_, rex2]) in re.captures_iter(haystack).map(|c| c.extract()) { + results.push(String::from(rex2.trim())); + println!("{:?}", rex2.trim()) + } + println!("{:?}", results); + results + } +}