Add tries to scan_socket.

By default the number of try is 1, it can be set on the command line by using
--tries option.

This should close #38.

Author: eiffel-fl

README.md

@@ -242,6 +242,7 @@ OPTIONS:
                                      ascending order while the "random" option will scan ports randomly [default:
                                      serial]  [possible values: Serial, Random]
     -t, --timeout <timeout>          The timeout in milliseconds before a port is assumed to be closed [default: 1500]
+        --tries <tries>              The number of tries before a port is assumed to be closed [default: 1]
     -u, --ulimit <ulimit>            Automatically ups the ULIMIT with the value you provided
 
 ARGS:
@@ -260,7 +261,7 @@ Your operating system may not support this, but it is worth it to play around an
 
 ## Configuration file
 
-This binary accepts a configuration file that is read from the home directory of the user. It follows the TOML format
+This binary accepts a configuration file, named `.rustscan.toml`, that is read from the home directory of the user. It follows the TOML format
 and accepts the following fields:
 
 - `addresses`
@@ -272,6 +273,7 @@ and accepts the following fields:
 - `greppable`
 - `batch-size`
 - `timeout`
+- `tries`
 - `ulimit`
 
 ### Format example
@@ -286,6 +288,7 @@ accessible = true
 scan_order = "Serial"
 batch_size = 1000
 timeout = 1000
+tries = 3
 ulimit = 1000
 ```
 

src/input.rs

@@ -95,6 +95,10 @@ pub struct Opts {
     #[structopt(short, long, default_value = "1500")]
     pub timeout: u32,
 
+    /// The number of tries before a port is assumed to be closed.
+    #[structopt(long, default_value = "1")]
+    pub tries: u8,
+
     /// Automatically ups the ULIMIT with the value you provided.
     #[structopt(short, long)]
     pub ulimit: Option<rlimit::rlim>,
@@ -153,7 +157,9 @@ impl Opts {
             }
         }
 
-        merge_required!(addresses, greppable, accessible, batch_size, timeout, scan_order, command);
+        merge_required!(
+            addresses, greppable, accessible, batch_size, timeout, tries, scan_order, command
+        );
     }
 
     fn merge_optional(&mut self, config: &Config) {
@@ -195,6 +201,7 @@ pub struct Config {
     accessible: Option<bool>,
     batch_size: Option<u16>,
     timeout: Option<u32>,
+    tries: Option<u8>,
     no_nmap: Option<bool>,
     ulimit: Option<rlimit::rlim>,
     scan_order: Option<ScanOrder>,
@@ -252,6 +259,7 @@ mod tests {
                 greppable: Some(true),
                 batch_size: Some(25_000),
                 timeout: Some(1_000),
+                tries: Some(1),
                 ulimit: None,
                 no_nmap: Some(false),
                 command: Some(vec!["-A".to_owned()]),
@@ -270,6 +278,7 @@ mod tests {
                 greppable: true,
                 batch_size: 0,
                 timeout: 0,
+                tries: 0,
                 ulimit: None,
                 command: vec![],
                 accessible: false,

src/main.rs

@@ -77,6 +77,7 @@ fn main() {
         &ips,
         batch_size,
         Duration::from_millis(opts.timeout.into()),
+        opts.tries,
         opts.greppable,
         PortStrategy::pick(opts.range, opts.ports, opts.scan_order),
         opts.accessible,

src/scanner/mod.rs

@@ -14,6 +14,8 @@ use std::{
     time::Duration,
 };
 
+use super::warning;
+
 /// The class for the scanner
 /// IP is data type IpAddr and is the IP address
 /// start & end is where the port scan starts and ends
@@ -26,6 +28,7 @@ pub struct Scanner {
     ips: Vec<IpAddr>,
     batch_size: u16,
     timeout: Duration,
+    tries: u8,
     greppable: bool,
     port_strategy: PortStrategy,
     accessible: bool,
@@ -36,13 +39,20 @@ impl Scanner {
         ips: &[IpAddr],
         batch_size: u16,
         timeout: Duration,
+        tries: u8,
         greppable: bool,
         port_strategy: PortStrategy,
         accessible: bool,
     ) -> Self {
         Self {
             batch_size,
             timeout,
+            tries: if tries == 0 {
+                warning!("tries is 0, corrected to 1!");
+                1
+            } else {
+                tries
+            },
             greppable,
             port_strategy,
             ips: ips.iter().map(|ip| ip.to_owned()).collect(),
@@ -87,54 +97,72 @@ impl Scanner {
         open_sockets
     }
 
-    /// Given a port, scan it.
+    /// Given a port, scan it self.tries times.
     /// Turns the address into a SocketAddr
     /// Deals with the <result> type
     /// If it experiences error ErrorKind::Other then too many files are open and it Panics!
-    /// ese any other error, it returns the error in Result as a string
-    /// If no  errors occur, it returns the port number in Result to signify the port is open.
+    /// Else any other error, it returns the error in Result as a string
+    /// If no errors occur, it returns the port number in Result to signify the port is open.
     /// This function mainly deals with the logic of Results handling.
     /// # Example
     ///
     ///     self.scan_port(10:u16)
     ///
     /// Note: `self` must contain `self.ip`.
     async fn scan_socket(&self, socket: SocketAddr) -> io::Result<SocketAddr> {
-        match self.connect(socket).await {
-            Ok(x) => {
-                debug!(
-                    "Connection was successful, shutting down stream {}",
-                    &socket
-                );
-                match x.shutdown(Shutdown::Both) {
-                    Err(e) => debug!("Shutdown stream error {}", &e),
-                    _ => {}
-                }
-                if !self.greppable {
-                    if self.accessible {
-                        println!("Open {}", socket.to_string());
-                    } else {
-                        println!("Open {}", socket.to_string().purple());
+        debug!("self.tries: {}", self.tries);
+        for nr_try in 1..=self.tries {
+            debug!("Try number: {}", nr_try);
+
+            match self.connect(socket).await {
+                Ok(x) => {
+                    debug!(
+                        "Connection was successful, shutting down stream {}",
+                        &socket
+                    );
+                    match x.shutdown(Shutdown::Both) {
+                        Err(e) => debug!("Shutdown stream error {}", &e),
+                        _ => {}
                     }
+                    if !self.greppable {
+                        if self.accessible {
+                            println!("Open {}", socket.to_string());
+                        } else {
+                            println!("Open {}", socket.to_string().purple());
+                        }
+                    }
+
+                    debug!("Return Ok after {} tries", nr_try);
+                    return Ok(socket);
                 }
+                Err(e) => {
+                    let error = match e.kind() {
+                        ErrorKind::Other => {
+                            let error_string = e.to_string();
+                            if error_string.contains("No route to host")
+                                || error_string.contains("Network is unreachable")
+                            {
+                                debug!("Socket connect error: {} {}", &e.to_string(), &socket);
+                                Err(io::Error::new(io::ErrorKind::Other, e.to_string()))
+                            } else {
+                                debug!("Socket connect error: {} {}", &e.to_string(), &socket);
+                                panic!("Too many open files. Please reduce batch size. The default is 5000. Try -b 2500.");
+                            }
+                        }
+                        _ => Err(io::Error::new(io::ErrorKind::Other, e.to_string())),
+                    };
 
-                Ok(socket)
-            }
-            Err(e) => match e.kind() {
-                ErrorKind::Other => {
-                    if e.to_string().contains("No route to host")
-                        || e.to_string().contains("Network is unreachable")
-                    {
-                        debug!("Socket connect error: {} {}", &e.to_string(), &socket);
-                        Err(io::Error::new(io::ErrorKind::Other, e.to_string()))
-                    } else {
-                        debug!("Socket connect error: {} {}", &e.to_string(), &socket);
-                        panic!("Too many open files. Please reduce batch size. The default is 5000. Try -b 2500.");
+                    if nr_try == self.tries {
+                        debug!("Return Err after {} tries", self.tries);
+                        return error;
                     }
                 }
-                _ => Err(io::Error::new(io::ErrorKind::Other, e.to_string())),
-            },
+            };
         }
+        return Err(io::Error::new(
+            io::ErrorKind::Other,
+            format!("self.tries is {} so port scanning is not done!", self.tries),
+        ));
     }
 
     /// Performs the connection to the socket with timeout
@@ -174,7 +202,15 @@ mod tests {
             end: 1_000,
         };
         let strategy = PortStrategy::pick(Some(range), None, ScanOrder::Random);
-        let scanner = Scanner::new(&addrs, 10, Duration::from_millis(100), true, strategy, true);
+        let scanner = Scanner::new(
+            &addrs,
+            10,
+            Duration::from_millis(100),
+            1,
+            true,
+            strategy,
+            true,
+        );
         block_on(scanner.run());
         // if the scan fails, it wouldn't be able to assert_eq! as it panicked!
         assert_eq!(1, 1);
@@ -188,7 +224,15 @@ mod tests {
             end: 1_000,
         };
         let strategy = PortStrategy::pick(Some(range), None, ScanOrder::Random);
-        let scanner = Scanner::new(&addrs, 10, Duration::from_millis(100), true, strategy, true);
+        let scanner = Scanner::new(
+            &addrs,
+            10,
+            Duration::from_millis(100),
+            1,
+            true,
+            strategy,
+            true,
+        );
         block_on(scanner.run());
         // if the scan fails, it wouldn't be able to assert_eq! as it panicked!
         assert_eq!(1, 1);
@@ -201,7 +245,15 @@ mod tests {
             end: 1_000,
         };
         let strategy = PortStrategy::pick(Some(range), None, ScanOrder::Random);
-        let scanner = Scanner::new(&addrs, 10, Duration::from_millis(100), true, strategy, true);
+        let scanner = Scanner::new(
+            &addrs,
+            10,
+            Duration::from_millis(100),
+            1,
+            true,
+            strategy,
+            true,
+        );
         block_on(scanner.run());
         assert_eq!(1, 1);
     }
@@ -213,7 +265,15 @@ mod tests {
             end: 445,
         };
         let strategy = PortStrategy::pick(Some(range), None, ScanOrder::Random);
-        let scanner = Scanner::new(&addrs, 10, Duration::from_millis(100), true, strategy, true);
+        let scanner = Scanner::new(
+            &addrs,
+            10,
+            Duration::from_millis(100),
+            1,
+            true,
+            strategy,
+            true,
+        );
         block_on(scanner.run());
         assert_eq!(1, 1);
     }
@@ -228,7 +288,15 @@ mod tests {
             end: 600,
         };
         let strategy = PortStrategy::pick(Some(range), None, ScanOrder::Random);
-        let scanner = Scanner::new(&addrs, 10, Duration::from_millis(100), true, strategy, true);
+        let scanner = Scanner::new(
+            &addrs,
+            10,
+            Duration::from_millis(100),
+            1,
+            true,
+            strategy,
+            true,
+        );
         block_on(scanner.run());
         assert_eq!(1, 1);
     }