Clippy fixes.

src/args.rs

@@ -11,6 +11,7 @@ use {
 };
 
 #[allow(clippy::cognitive_complexity)]
+#[must_use]
 pub fn get_args() -> Args {
     let yaml = load_yaml!("cli.yml");
     let matches = App::from_yaml(yaml)

src/files.rs

@@ -1,5 +1,8 @@
 use {
-    crate::{errors::*, structs::Args},
+    crate::{
+        errors::{Result, ResultExt},
+        structs::Args,
+    },
     log::error,
     prettytable::Table,
     std::{
@@ -10,6 +13,7 @@ use {
     },
 };
 
+#[must_use]
 pub fn return_file_targets(args: &Args, mut files: Vec<String>) -> Vec<String> {
     let mut targets: Vec<String> = Vec::new();
     files.sort();
@@ -23,13 +27,10 @@ pub fn return_file_targets(args: &Args, mut files: Vec<String>) -> Vec<String> {
             }
             Err(e) => {
                 if args.files.len() == 1 {
-                    error!("Can not open file {}. Error: {}\n", f, e);
+                    error!("Can not open file {f}. Error: {e}\n");
                     std::process::exit(1)
                 } else if !args.quiet_flag {
-                    error!(
-                        "Can not open file {}, working with next file. Error: {}\n",
-                        f, e
-                    );
+                    error!("Can not open file {f}, working with next file. Error: {e}\n");
                 }
             }
         }
@@ -44,6 +45,7 @@ pub fn table_to_file(table: &Table, file_name: Option<std::fs::File>) -> Result<
     Ok(())
 }
 
+#[must_use]
 pub fn return_output_file(args: &Args) -> Option<File> {
     if args.file_name.is_empty() || !args.with_output {
         None
@@ -59,6 +61,7 @@ pub fn return_output_file(args: &Args) -> Option<File> {
     }
 }
 
+#[must_use]
 pub fn check_full_path(full_path: &str) -> bool {
     (Path::new(full_path).exists() && Path::new(full_path).is_dir())
         || fs::create_dir_all(full_path).is_ok()
@@ -68,7 +71,7 @@ pub fn delete_files(paths: &HashSet<String>) {
     for file in paths {
         if Path::new(&file).exists() {
             match std::fs::remove_file(file) {
-                Ok(_) => (),
+                Ok(()) => (),
                 Err(e) => error!("Error deleting the file {}. Description: {}", &file, e),
             }
         }

src/logger.rs

@@ -21,10 +21,10 @@ impl Log for SimpleLogger {
     }
 
     fn log(&self, record: &Record) {
-        let target = if !record.target().is_empty() {
-            record.target()
-        } else {
+        let target = if record.target().is_empty() {
             record.module_path().unwrap_or_default()
+        } else {
+            record.target()
         };
         if target.contains("unimap") && self.enabled(record.metadata()) {
             let level_string = {

src/main.rs

@@ -1,27 +1,27 @@
 use {
     log::{error, Level},
     std::{collections::HashSet, iter::FromIterator},
-    unimap::{args, errors::*, files::return_file_targets, logger, misc, resolver_engine},
+    unimap::{args, errors::Result, files::return_file_targets, logger, misc, resolver_engine},
 };
 
 fn run() -> Result<()> {
     if std::env::var("UNIMAP_LOG_LEVEL").is_ok() {
-        logger::init_by_env()
+        logger::init_by_env();
     } else {
-        logger::init_with_level(Level::Info).unwrap()
+        logger::init_with_level(Level::Info).unwrap();
     }
     let mut arguments = args::get_args();
     if !arguments.files.is_empty() {
         arguments.targets =
-            HashSet::from_iter(return_file_targets(&arguments, arguments.files.clone()))
+            HashSet::from_iter(return_file_targets(&arguments, arguments.files.clone()));
     } else if !arguments.target.is_empty() {
         arguments.targets.insert(arguments.target.clone());
     } else {
-        arguments.targets = misc::read_stdin()
+        arguments.targets = misc::read_stdin();
     }
 
     if arguments.targets.len() < 50 {
-        arguments.threads = arguments.targets.len()
+        arguments.threads = arguments.targets.len();
     }
 
     rayon::ThreadPoolBuilder::new()
@@ -29,19 +29,19 @@ fn run() -> Result<()> {
         .build_global()
         .unwrap();
 
-    if !arguments.targets.is_empty() {
-        resolver_engine::parallel_resolver_all(&mut arguments)
-    } else {
+    if arguments.targets.is_empty() {
         error!("Error: Target is empty or invalid!\n");
         std::process::exit(1)
+    } else {
+        resolver_engine::parallel_resolver_all(&mut arguments)
     }
 }
 
 fn main() {
     if let Err(err) = run() {
-        error!("Error: {}", err);
+        error!("Error: {err}");
         for cause in err.iter_chain().skip(1) {
-            error!("Error description: {}\n", cause);
+            error!("Error description: {cause}\n");
         }
         std::process::exit(1);
     }

src/misc.rs

@@ -3,6 +3,7 @@ use std::{
     io::{self, Read},
 };
 
+#[must_use]
 pub fn sanitize_target_string(target: String) -> String {
     target
         .replace("www.", "")

src/networking.rs

@@ -10,7 +10,7 @@ use {
 pub fn get_records(resolver: &Resolver, domain: &str) -> String {
     if let Ok(ips) = resolver.ipv4_lookup(domain) {
         ips.iter()
-            .map(|x| x.to_string())
+            .map(std::string::ToString::to_string)
             .next()
             .expect("Failed to get IPV4.")
     } else {

src/nmap.rs

@@ -132,17 +132,17 @@ pub fn get_nmap_data(
     ];
 
     if !min_rate.is_empty() {
-        nmap_args.append(&mut vec!["--min-rate", &min_rate])
+        nmap_args.append(&mut vec!["--min-rate", &min_rate]);
     }
 
     if fast_scan {
-        nmap_args.append(&mut vec!["--host-timeout", "20m"])
+        nmap_args.append(&mut vec!["--host-timeout", "20m"]);
     } else {
-        nmap_args.append(&mut vec!["-sV"])
+        nmap_args.append(&mut vec!["-sV"]);
     }
 
     if !ports.is_empty() {
-        nmap_args.append(&mut vec!["-p", ports])
+        nmap_args.append(&mut vec!["-p", ports]);
     }
 
     nmap_args.push(host);
@@ -159,8 +159,7 @@ pub fn get_nmap_data(
         }
         Err(e) => {
             error!(
-                    "Error waiting command to finish for {}, continuing with remaining hosts. Description: {}",
-                    host, e
+                    "Error waiting command to finish for {host}, continuing with remaining hosts. Description: {e}"
                 );
             Ok(Nmaprun::default())
         }

src/resolver_engine.rs

@@ -1,7 +1,7 @@
 use {
     crate::{
         args,
-        errors::*,
+        errors::Result,
         files, logic, networking,
         nmap::{self, Nmaprun},
         structs::{Args, ResolvData},
@@ -30,7 +30,7 @@ lazy_static! {
                 match r.parse::<Ipv4Addr>() {
                     Ok(ip) => resolver_ips.push(ip),
                     Err(e) => {
-                        error!("Error parsing the {} IP from resolvers file to IP address. Please check and try again. Error: {}\n", r, e);
+                        error!("Error parsing the {r} IP from resolvers file to IP address. Please check and try again. Error: {e}\n");
                         std::process::exit(1)
                     }
                 }
@@ -40,7 +40,7 @@ lazy_static! {
                 match r.parse::<Ipv4Addr>() {
                     Ok(ip) => resolver_ips.push(ip),
                     Err(e) => {
-                        error!("Error parsing the {} IP from resolvers file to IP address. Please check and try again. Error: {}\n", r, e);
+                        error!("Error parsing the {r} IP from resolvers file to IP address. Please check and try again. Error: {e}\n");
                         std::process::exit(1)
                     }
                 }
@@ -51,13 +51,16 @@ lazy_static! {
 }
 
 pub fn parallel_resolver_all(args: &mut Args) -> Result<()> {
-    files::check_full_path(&args.logs_dir);
+    if !files::check_full_path(&args.logs_dir) {
+        error!("The logs directory {} does not exist.\n", args.logs_dir);
+        std::process::exit(1)
+    }
 
     if !args.quiet_flag {
         info!(
             "Performing parallel resolution for {} targets with {} threads, it will take a while...\n",
             args.targets.len(), args.threads
-        )
+        );
     }
 
     let opts = ResolverOpts {
@@ -79,9 +82,9 @@ pub fn parallel_resolver_all(args: &mut Args) -> Result<()> {
        "SERVICES"
     ]);
     if args.raw_output && !args.quiet_flag {
-        println!("HOST,IP,PORT,SERVICE,VERSION,PRODUCT,OS,EXTRAINFO")
+        println!("HOST,IP,PORT,SERVICE,VERSION,PRODUCT,OS,EXTRAINFO");
     } else if args.url_output && !args.quiet_flag {
-        println!("HOST:IP")
+        println!("HOST:IP");
     }
     for (target, resolv_data) in &data {
         if !resolv_data.ip.is_empty() {
@@ -120,11 +123,11 @@ pub fn parallel_resolver_all(args: &mut Args) -> Result<()> {
                             .extrainfo
                             .clone()
                             .unwrap_or_else(|| "NULL".to_string())
-                    )
+                    );
                 }
             } else if args.url_output {
                 for port_data in &resolv_data.ports_data {
-                    println!("{}:{}", target, port_data.portid)
+                    println!("{}:{}", target, port_data.portid);
                 }
             } else {
                 let mut services_table = Table::new();
@@ -179,7 +182,7 @@ pub fn parallel_resolver_all(args: &mut Args) -> Result<()> {
         error!(
             "An error occurred while writing the output file {}.\n",
             args.file_name
-        )
+        );
     }
     if !args.quiet_flag && !args.raw_output && !args.url_output {
         table.printstd();
@@ -206,7 +209,7 @@ fn parallel_resolver_engine(
     let resolv_data: HashMap<String, ResolvData> = targets
         .par_iter()
         .map(|target| {
-            let fqdn_target = format!("{}.", target);
+            let fqdn_target = format!("{target}.");
             let mut resolv_data = ResolvData::default();
             resolv_data.ip = networking::get_records(&resolver, &fqdn_target);
             (target.to_owned(), resolv_data)
@@ -227,10 +230,7 @@ fn parallel_resolver_engine(
     });
 
     if nmap_ips.is_empty() {
-        error!(
-            "No valid IPs found for scanning. IPs found: {:?}\n",
-            nmap_ips_orig
-        );
+        error!("No valid IPs found for scanning. IPs found: {nmap_ips_orig:?}\n");
         std::process::exit(1)
     } else {
         let nmap_data: HashMap<String, Nmaprun> = nmap_ips
@@ -254,7 +254,7 @@ fn parallel_resolver_engine(
                             .port
                             .retain(|f| f.state.state == "open");
                         if args.no_keep_nmap_logs && std::fs::remove_file(&filename).is_err() {
-                            error!("Error removing filename {}.", &filename)
+                            error!("Error removing filename {}.", &filename);
                         }
                         (ip.clone(), nmap_data)
                     }
@@ -268,7 +268,7 @@ fn parallel_resolver_engine(
 
         // Delete the args.logs_dir directory if it's empty
         if args.no_keep_nmap_logs && std::fs::remove_dir(&args.logs_dir).is_err() {
-            error!("Error removing directory {}.", &args.logs_dir)
+            error!("Error removing directory {}.", &args.logs_dir);
         }
 
         resolv_data

src/structs.rs

@@ -35,8 +35,8 @@ pub struct ResolvData {
     pub ports_data: Vec<Port>,
 }
 impl ResolvData {
-    pub fn default() -> ResolvData {
-        ResolvData {
+    pub const fn default() -> Self {
+        Self {
             ip: String::new(),
             ports_data: Vec::new(),
         }