Merging with master

CODE_OF_CONDUCT.md

@@ -55,7 +55,7 @@ further defined and clarified by project maintainers.
 ## Enforcement
 
 Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported by contacting the project team at brandon@skerritt.blog. All
+reported by contacting the project team at our discord via a private message to any of the owners. All
 complaints will be reviewed and investigated and will result in a response that
 is deemed necessary and appropriate to the circumstances. The project team is
 obligated to maintain confidentiality with regard to the reporter of an incident.
@@ -67,10 +67,10 @@ members of the project's leadership.
 
 ## Attribution
 
-This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+This Code of Conduct is adapted from the Contributor Covenant homepage, version 1.4,
 available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
 
-[homepage]: https://www.contributor-covenant.org
+homepage: https://www.contributor-covenant.org
 
 For answers to common questions about this code of conduct, see
 https://www.contributor-covenant.org/faq

Cargo.lock

@@ -41,9 +41,9 @@ checksum = "cff77d8686867eceff3105329d4698d96c2391c176d5d03adc90c7389162b5b8"
 
 [[package]]
 name = "async-channel"
-version = "1.4.0"
+version = "1.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43de69555a39d52918e2bc33a408d3c0a86c829b212d898f4ca25d21a6387478"
+checksum = "59386c3aa61f4e14c4ddda1a6744c119b4bf278ec9f866d3c20bc5728ee0eb97"
 dependencies = [
  "concurrent-queue",
  "event-listener",
@@ -85,9 +85,9 @@ dependencies = [
 
 [[package]]
 name = "async-mutex"
-version = "1.1.5"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "20e85981fc34e84cdff3fc2c9219189752633fdc538a06df8b5ac45b68a4f3a9"
+checksum = "065de1ccf10280d0d75c2f3a71a970ee1007c85c51aa3e7deee1df100f1dfadb"
 dependencies = [
  "event-listener",
 ]
@@ -144,15 +144,15 @@ dependencies = [
 
 [[package]]
 name = "autocfg"
-version = "1.0.0"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8aac770f1885fd7e387acedd76065302551364496e46b3dd00860b2f8359b9d"
+checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"
 
 [[package]]
 name = "base64"
-version = "0.11.0"
+version = "0.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b41b7ea54a0c9d92199de89e20e58d49f02f8e699814ef3fdf266f6f748d15c7"
+checksum = "3441f0f7b02788e948e47f457ca01f1d7e6d92c693bc132c22b087d3141c03ff"
 
 [[package]]
 name = "bitflags"
@@ -173,9 +173,9 @@ dependencies = [
 
 [[package]]
 name = "blocking"
-version = "0.5.0"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76e94bf99b692f54c9d05f97454d3faf11134523fe5b180564a3fb6ed63bcc0a"
+checksum = "ea5800d29218fea137b0880387e5948694a23c93fcdde157006966693a865c7c"
 dependencies = [
  "async-channel",
  "atomic-waker",
@@ -198,9 +198,9 @@ checksum = "631ae5198c9be5e753e5cc215e1bd73c2b466a3565173db433f52bb9d3e66dba"
 
 [[package]]
 name = "cc"
-version = "1.0.58"
+version = "1.0.59"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f9a06fb2e53271d7c279ec1efea6ab691c35a2ae67ec0d91d7acec0caf13b518"
+checksum = "66120af515773fb005778dc07c261bd201ec8ce50bd6e7144c927753fe013381"
 
 [[package]]
 name = "cfg-if"
@@ -210,9 +210,9 @@ checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
 
 [[package]]
 name = "clap"
-version = "2.33.2"
+version = "2.33.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10040cdf04294b565d9e0319955430099ec3813a64c952b86a41200ad714ae48"
+checksum = "37e58ac78573c40708d45522f0d80fa2f01cc4f9b4e2bf749807255454312002"
 dependencies = [
  "ansi_term 0.11.0",
  "atty",
@@ -301,15 +301,15 @@ dependencies = [
 
 [[package]]
 name = "event-listener"
-version = "2.3.2"
+version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68082183f458867ce7cddea16d4df4443c1537112c0c09c450dedc09daf5c719"
+checksum = "e1cd41440ae7e4734bbd42302f63eaba892afc93a3912dad84006247f0dedb0e"
 
 [[package]]
 name = "fastrand"
-version = "1.3.3"
+version = "1.3.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "36a9cb09840f81cd211e435d00a4e487edd263dc3c8ff815c32dd76ad668ebed"
+checksum = "5c85295147490b8fcf2ea3d104080a105a8b2c63f9c319e82c02d8e952388919"
 
 [[package]]
 name = "futures"
@@ -361,15 +361,15 @@ checksum = "de27142b013a8e869c14957e6d2edeef89e97c289e69d042ee3a49acd8b51789"
 
 [[package]]
 name = "futures-lite"
-version = "0.1.10"
+version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbe71459749b2e8e66fb95df721b22fa08661ad384a0c5b519e11d3893b4692a"
+checksum = "97999970129b808f0ccba93211201d431fcc12d7e1ffae03a61b5cedd1a7ced2"
 dependencies = [
  "fastrand",
  "futures-core",
  "futures-io",
  "memchr",
- "parking 1.0.6",
+ "parking 2.0.0",
  "pin-project-lite",
  "waker-fn",
 ]
@@ -491,9 +491,9 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
 
 [[package]]
 name = "libc"
-version = "0.2.74"
+version = "0.2.76"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2f02823cf78b754822df5f7f268fb59822e7296276d3e069d8e8cb26a14bd10"
+checksum = "755456fae044e6fa1ebbbd1b3e902ae19e73097ed4ed87bb79934a867c007bc3"
 
 [[package]]
 name = "log"
@@ -533,9 +533,9 @@ dependencies = [
 
 [[package]]
 name = "once_cell"
-version = "1.4.0"
+version = "1.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b631f7e854af39a1739f401cf34a8a013dfe09eac4fa4dba91e9768bd28168d"
+checksum = "260e51e7efe62b592207e9e13a68e43692a7a279171d6ba57abd208bf23645ad"
 
 [[package]]
 name = "parking"
@@ -583,21 +583,22 @@ checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
 
 [[package]]
 name = "polling"
-version = "0.1.3"
+version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6d83023eb990619815bb41b45625b02da62b00d0f24b0a08aae37697b3f6c94"
+checksum = "53c5afb3e8bc82c2780a807374bda0fb8886904d8e9d51e6f4f3743fb1dd27fb"
 dependencies = [
  "cfg-if",
  "libc",
+ "log",
  "wepoll-sys-stjepang",
  "winapi",
 ]
 
 [[package]]
 name = "ppv-lite86"
-version = "0.2.8"
+version = "0.2.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "237a5ed80e274dbc66f86bd59c1e25edc039660be53194b5fe0a482e0f2612ea"
+checksum = "c36fa947111f5c62a733b652544dd0016a43ce89619538a8ef92724a6f501a20"
 
 [[package]]
 name = "proc-macro-error"
@@ -708,9 +709,9 @@ checksum = "41cc0f7e4d5d4544e8861606a285bb08d3e70712ccc7d2b84d7c0ccfaf4b05ce"
 
 [[package]]
 name = "redox_users"
-version = "0.3.4"
+version = "0.3.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09b23093265f8d200fa7b4c2c76297f47e681c655f6f1285a8780d6a022f7431"
+checksum = "de0737333e7a9502c789a36d7c7fa6092a49895d4faa31ca5df163857ded2e9d"
 dependencies = [
  "getrandom",
  "redox_syscall",
@@ -747,9 +748,9 @@ dependencies = [
 
 [[package]]
 name = "rust-argon2"
-version = "0.7.0"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2bc8af4bda8e1ff4932523b94d3dd20ee30a87232323eda55903ffd71d2fb017"
+checksum = "9dab61250775933275e84053ac235621dfb739556d5c54a2f2e9313b7cf43a19"
 dependencies = [
  "base64",
  "blake2b_simd",
@@ -858,9 +859,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "1.0.38"
+version = "1.0.39"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e69abc24912995b3038597a7a593be5053eb0fb44f3cc5beec0deb421790c1f4"
+checksum = "891d8d6567fe7c7f8835a3a98af4208f3846fba258c1bc3c31d6e506239f11f9"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -923,9 +924,9 @@ checksum = "f7fe0bb3479651439c9112f72b6c505038574c9fbb575ed1bf3b797fa39dd564"
 
 [[package]]
 name = "vec-arena"
-version = "0.5.0"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "17dfb54bf57c9043f4616cb03dab30eff012cc26631b797d8354b916708db919"
+checksum = "8cb18268690309760d59ee1a9b21132c126ba384f374c59a94db4bc03adeb561"
 
 [[package]]
 name = "vec_map"
@@ -941,9 +942,9 @@ checksum = "b5a972e5669d67ba988ce3dc826706fb0a8b01471c088cb0b6110b805cc36aed"
 
 [[package]]
 name = "waker-fn"
-version = "1.0.0"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9571542c2ce85ce642e6b58b3364da2fb53526360dfb7c211add4f5c23105ff7"
+checksum = "9d5b2c62b4012a3e1eca5a7e077d13b3bf498c4073e33ccd58626607748ceeca"
 
 [[package]]
 name = "wasi"

Cargo.toml

@@ -40,4 +40,4 @@ section = "rust"
 
 [profile.release]
 lto = true
-panic = 'abort'
+panic = 'abort'

src/input.rs

@@ -68,7 +68,7 @@ pub struct Opts {
 
     /// Whether to ignore the configuration file or not.
     #[structopt(short, long)]
-    pub ignore_config: bool,
+    pub no_config: bool,
 
     /// Quiet mode. Only output the ports. No Nmap. Useful for grep or outputting to a file.
     #[structopt(short, long)]
@@ -78,6 +78,10 @@ pub struct Opts {
     #[structopt(long)]
     pub accessible: bool,
 
+    /// Turns off Nmap.
+    #[structopt(long)]
+    pub no_nmap: bool,
+
     /// The batch size for port scanning, it increases or slows the speed of
     /// scanning. Depends on the open file limit of your OS.  If you do 65535
     /// it will do every port at the same time. Although, your OS may not
@@ -125,7 +129,7 @@ impl Opts {
     /// Reads the command line arguments into an Opts struct and merge
     /// values found within the user configuration file.
     pub fn merge(&mut self, config: &Config) {
-        if !self.ignore_config {
+        if !self.no_config {
             self.merge_required(&config);
             self.merge_optional(&config);
         }
@@ -180,6 +184,7 @@ pub struct Config {
     accessible: Option<bool>,
     batch_size: Option<u16>,
     timeout: Option<u32>,
+    no_nmap: Option<bool>,
     ulimit: Option<rlimit::rlim>,
     scan_order: Option<ScanOrder>,
     command: Option<Vec<String>>,
@@ -241,8 +246,9 @@ mod tests {
             ulimit: None,
             command: vec![],
             accessible: false,
+            no_nmap: false,
             scan_order: ScanOrder::Serial,
-            ignore_config: true,
+            no_config: true,
         };
 
         let config = Config {
@@ -253,6 +259,7 @@ mod tests {
             batch_size: Some(25_000),
             timeout: Some(1_000),
             ulimit: None,
+            no_nmap: Some(false),
             command: Some(vec!["-A".to_owned()]),
             accessible: Some(true),
             scan_order: Some(ScanOrder::Random),
@@ -281,12 +288,14 @@ mod tests {
             command: vec![],
             accessible: false,
             scan_order: ScanOrder::Serial,
-            ignore_config: false,
+            no_nmap: false,
+            no_config: false,
         };
 
         let config = Config {
             ips_or_hosts: Some(vec!["127.0.0.1".to_owned()]),
             ports: None,
+            no_nmap: Some(false),
             range: None,
             quiet: Some(true),
             batch_size: Some(25_000),
@@ -320,7 +329,8 @@ mod tests {
             command: vec![],
             accessible: false,
             scan_order: ScanOrder::Serial,
-            ignore_config: false,
+            no_nmap: false,
+            no_config: false,
         };
 
         let config = Config {
@@ -333,6 +343,7 @@ mod tests {
             quiet: None,
             batch_size: None,
             timeout: None,
+            no_nmap: Some(false),
             ulimit: Some(1_000),
             command: None,
             accessible: None,

src/main.rs

@@ -277,7 +277,8 @@ mod tests {
             command: Vec::new(),
             accessible: false,
             scan_order: ScanOrder::Serial,
-            ignore_config: false,
+            no_config: false,
+            no_nmap: false,
         };
         let batch_size = infer_batch_size(&opts, 120);
 
@@ -297,7 +298,8 @@ mod tests {
             command: Vec::new(),
             accessible: false,
             scan_order: ScanOrder::Serial,
-            ignore_config: false,
+            no_config: false,
+            no_nmap: false,
         };
         let batch_size = infer_batch_size(&opts, 9_000);
 
@@ -318,7 +320,8 @@ mod tests {
             command: Vec::new(),
             accessible: false,
             scan_order: ScanOrder::Serial,
-            ignore_config: false,
+            no_config: false,
+            no_nmap: false,
         };
         let batch_size = infer_batch_size(&opts, 5_000);
 
@@ -338,7 +341,8 @@ mod tests {
             command: Vec::new(),
             accessible: false,
             scan_order: ScanOrder::Serial,
-            ignore_config: false,
+            no_config: false,
+            no_nmap: false,
         };
         let batch_size = adjust_ulimit_size(&opts);
 
@@ -363,7 +367,8 @@ mod tests {
             command: Vec::new(),
             accessible: true,
             scan_order: ScanOrder::Serial,
-            ignore_config: false,
+            no_config: false,
+            no_nmap: false,
         };
 
         infer_batch_size(&opts, 1_000_000);
@@ -384,7 +389,8 @@ mod tests {
             command: Vec::new(),
             accessible: false,
             scan_order: ScanOrder::Serial,
-            ignore_config: false,
+            no_config: false,
+            no_nmap: false,
         };
         let ips = parse_ips(&opts);
 
@@ -404,7 +410,8 @@ mod tests {
             command: Vec::new(),
             accessible: false,
             scan_order: ScanOrder::Serial,
-            ignore_config: false,
+            no_config: false,
+            no_nmap: false,
         };
         let ips = parse_ips(&opts);
 
@@ -424,7 +431,8 @@ mod tests {
             command: Vec::new(),
             accessible: false,
             scan_order: ScanOrder::Serial,
-            ignore_config: false,
+            no_config: false,
+            no_nmap: false,
         };
         let ips = parse_ips(&opts);
 

src/scanner/main.rs

@@ -0,0 +1,476 @@
+extern crate shell_words;
+
+mod tui;
+
+mod input;
+use input::{Config, Opts, PortRange, ScanOrder};
+
+mod scanner;
+use scanner::Scanner;
+
+mod port_strategy;
+use port_strategy::PortStrategy;
+
+use colorful::Color;
+use colorful::Colorful;
+use futures::executor::block_on;
+use rlimit::Resource;
+use rlimit::{getrlimit, setrlimit};
+
+use std::collections::HashMap;
+use std::net::ToSocketAddrs;
+use std::process::Command;
+use std::str::FromStr;
+use std::{net::IpAddr, time::Duration};
+
+extern crate colorful;
+extern crate dirs;
+
+// Average value for Ubuntu
+const DEFAULT_FILE_DESCRIPTORS_LIMIT: rlimit::rlim = 8000;
+// Safest batch size based on experimentation
+const AVERAGE_BATCH_SIZE: rlimit::rlim = 3000;
+
+#[macro_use]
+extern crate log;
+
+#[cfg(not(tarpaulin_include))]
+/// Faster Nmap scanning with Rust
+/// If you're looking for the actual scanning, check out the module Scanner
+fn main() {
+    env_logger::init();
+
+    let mut opts: Opts = Opts::read();
+    let config = Config::read();
+    opts.merge(&config);
+    dbg!(&opts);
+
+    info!("Main() `opts` arguments are {:?}", opts);
+
+    if !opts.quiet && !opts.accessible {
+        print_opening();
+    }
+
+    let ips: Vec<IpAddr> = parse_ips(&opts);
+
+    if ips.is_empty() {
+        warning!("No IPs could be resolved, aborting scan.", false);
+        std::process::exit(1);
+    }
+
+    let ulimit: rlimit::rlim = adjust_ulimit_size(&opts);
+    let batch_size: u16 = infer_batch_size(&opts, ulimit);
+
+    let scanner = Scanner::new(
+        &ips,
+        batch_size,
+        Duration::from_millis(opts.timeout.into()),
+        opts.quiet,
+        PortStrategy::pick(opts.range, opts.ports, opts.scan_order),
+    );
+
+    let scan_result = block_on(scanner.run());
+    let mut ports_per_ip = HashMap::new();
+
+    for socket in scan_result {
+        ports_per_ip
+            .entry(socket.ip())
+            .or_insert_with(Vec::new)
+            .push(socket.port());
+    }
+
+    for ip in ips {
+        if ports_per_ip.contains_key(&ip) {
+            continue;
+        }
+
+        // If we got here it means the IP was not found within the HashMap, this
+        // means the scan couldn't find any open ports for it.
+
+        let x = format!("{} Looks like I didn't find any open ports for {:?}. This is usually caused by a high batch size.
+        \n*I used {} batch size, consider lowering to {} with {} or a comfortable number for your system.
+        \n Alternatively, increase the timeout if your ping is high. Rustscan -t 2000 for 2000 milliseconds (2s) timeout.\n",
+        "ERROR",
+        ip,
+        opts.batch_size,
+        (opts.batch_size / 2).to_string(),
+        "'rustscan -b <batch_size> <ip address>'");
+        warning!(x, opts.quiet);
+    }
+
+    for (ip, ports) in ports_per_ip.iter_mut() {
+        let nmap_str_ports: Vec<String> = ports.into_iter().map(|port| port.to_string()).collect();
+
+        // nmap port style is 80,443. Comma separated with no spaces.
+        let ports_str = nmap_str_ports.join(",");
+
+        // if quiet mode is on nmap should not be spawned
+        if opts.quiet {
+            println!("{}", ports_str);
+            continue;
+        } else if opts.no_nmap {
+            continue;
+        } else {
+            detail!("Starting Nmap", opts.quiet);
+        }
+
+        let addr = ip.to_string();
+        let user_nmap_args =
+            shell_words::split(&opts.command.join(" ")).expect("failed to parse nmap arguments");
+        let nmap_args = build_nmap_arguments(&addr, &ports_str, &user_nmap_args, ip.is_ipv6());
+
+        output!(format!(
+            "The Nmap command to be run is nmap {}\n",
+            &nmap_args.join(" ")
+        ));
+
+        // Runs the nmap command and spawns it as a process.
+        let mut child = Command::new("nmap")
+            .args(&nmap_args)
+            .spawn()
+            .expect("failed to execute nmap process");
+
+        child.wait().expect("failed to wait on nmap process");
+    }
+}
+
+/// Prints the opening title of RustScan
+fn print_opening() {
+    info!("Printing opening");
+    let s = r#".----. .-. .-. .----..---.  .----. .---.   .--.  .-. .-.
+| {}  }| { } |{ {__ {_   _}{ {__  /  ___} / {} \ |  `| |
+| .-. \| {_} |.-._} } | |  .-._} }\     }/  /\  \| |\  |
+`-' `-'`-----'`----'  `-'  `----'  `---' `-'  `-'`-' `-'
+Faster Nmap scanning with Rust."#;
+    println!("{}", s.gradient(Color::Green).bold());
+    let info = r#"________________________________________
+: https://discord.gg/GFrQsGy           :
+: https://github.com/RustScan/RustScan :
+ --------------------------------------"#;
+    println!("{}", info.gradient(Color::Yellow).bold());
+    funny_opening!();
+
+    let config_path = match dirs::config_dir() {
+        Some(mut path) => {
+            path.push("rustscan");
+            path.push("config.toml");
+            path
+        }
+        None => panic!("Couldn't find config dir."),
+    };
+
+    detail!(format!(
+        "{} {:?}",
+        "The config file is expected to be at", config_path
+    ));
+}
+#[cfg(not(tarpaulin_include))]
+fn build_nmap_arguments<'a>(
+    addr: &'a str,
+    ports: &'a str,
+    user_args: &'a Vec<String>,
+    is_ipv6: bool,
+) -> Vec<&'a str> {
+    let mut arguments: Vec<&str> = user_args.iter().map(AsRef::as_ref).collect();
+    arguments.push("-vvv");
+
+    if is_ipv6 {
+        arguments.push("-6");
+    }
+
+    arguments.push("-p");
+    arguments.push(ports);
+    arguments.push(addr);
+
+    arguments
+}
+
+fn parse_ips(opts: &Opts) -> Vec<IpAddr> {
+    let mut ips: Vec<IpAddr> = Vec::new();
+
+    for ip_or_host in &opts.ips_or_hosts {
+        match IpAddr::from_str(ip_or_host) {
+            Ok(ip) => ips.push(ip),
+            _ => match format!("{}:{}", &ip_or_host, 80).to_socket_addrs() {
+                Ok(mut iter) => ips.push(iter.nth(0).unwrap().ip()),
+                _ => {
+                    let failed_to_resolve = format!("Host {:?} could not be resolved.", ip_or_host);
+                    warning!(failed_to_resolve, opts.quiet);
+                }
+            },
+        }
+    }
+
+    ips
+}
+
+fn adjust_ulimit_size(opts: &Opts) -> rlimit::rlim {
+    if opts.ulimit.is_some() {
+        let limit: rlimit::rlim = opts.ulimit.unwrap();
+
+        match setrlimit(Resource::NOFILE, limit, limit) {
+            Ok(_) => {
+                detail!(
+                    format!("Automatically increasing ulimit value to {}.", limit),
+                    opts.quiet
+                );
+            }
+            Err(_) => println!("{}", "ERROR. Failed to set ulimit value."),
+        }
+    }
+
+    let (rlim, _) = getrlimit(Resource::NOFILE).unwrap();
+
+    rlim
+}
+
+fn infer_batch_size(opts: &Opts, ulimit: rlimit::rlim) -> u16 {
+    let mut batch_size: rlimit::rlim = opts.batch_size.into();
+
+    // Adjust the batch size when the ulimit value is lower than the desired batch size
+    if ulimit < batch_size {
+        warning!("File limit is lower than default batch size. Consider upping with --ulimit. May cause harm to sensitive servers",
+            opts.quiet
+        );
+
+        // When the OS supports high file limits like 8000, but the user
+        // selected a batch size higher than this we should reduce it to
+        // a lower number.
+        if ulimit < AVERAGE_BATCH_SIZE {
+            // ulimit is smaller than aveage batch size
+            // user must have very small ulimit
+            // decrease batch size to half of ulimit
+            warning!("Your file limit is very small, which negatively impacts RustScan's speed. Use the Docker image, or up the Ulimit with '--ulimit 5000'. ");
+            info!("Halving batch_size because ulimit is smaller than average batch size");
+            batch_size = ulimit / 2
+        } else if ulimit > DEFAULT_FILE_DESCRIPTORS_LIMIT {
+            info!("Batch size is now average batch size");
+            batch_size = AVERAGE_BATCH_SIZE
+        } else {
+            batch_size = ulimit - 100
+        }
+    }
+    // When the ulimit is higher than the batch size let the user know that the
+    // batch size can be increased unless they specified the ulimit themselves.
+    else if ulimit + 2 > batch_size && (opts.ulimit.is_none()) {
+        detail!(format!(
+                "File limit higher than batch size. Can increase speed by increasing batch size '-b {}'.",
+                ulimit - 100
+            ), opts.quiet);
+    }
+
+    batch_size as u16
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{adjust_ulimit_size, infer_batch_size, parse_ips, print_opening, Opts, ScanOrder};
+
+    #[test]
+    fn batch_size_lowered() {
+        let opts = Opts {
+            ips_or_hosts: vec!["127.0.0.1".to_owned()],
+            ports: None,
+            range: None,
+            quiet: true,
+            batch_size: 50_000,
+            timeout: 1_000,
+            ulimit: Some(2_000),
+            command: Vec::new(),
+            accessible: false,
+            scan_order: ScanOrder::Serial,
+            no_nmap: false,
+            no_config: false,
+            ignore_config: false,
+            ignore_config: false,
+            no_nmap: false,
+            no_config: false,
+        };
+        let batch_size = infer_batch_size(&opts, 120);
+
+        assert!(batch_size < 50_000);
+    }
+
+    #[test]
+    fn batch_size_lowered_average_size() {
+        let opts = Opts {
+            ips_or_hosts: vec!["127.0.0.1".to_owned()],
+            ports: None,
+            range: None,
+            quiet: true,
+            batch_size: 50_000,
+            timeout: 1_000,
+            ulimit: Some(2_000),
+            command: Vec::new(),
+            accessible: false,
+            scan_order: ScanOrder::Serial,
+            no_nmap: false,
+            no_config: false,
+            ignore_config: false,
+            ignore_config: false,
+            no_nmap: false,
+            no_config: false,
+        };
+        let batch_size = infer_batch_size(&opts, 9_000);
+
+        assert!(batch_size == 3_000);
+    }
+    #[test]
+    fn batch_size_equals_ulimit_lowered() {
+        // because ulimit and batch size are same size, batch size is lowered
+        // to ULIMIT - 100
+        let opts = Opts {
+            ips_or_hosts: vec!["127.0.0.1".to_owned()],
+            ports: None,
+            range: None,
+            quiet: true,
+            batch_size: 50_000,
+            timeout: 1_000,
+            ulimit: Some(2_000),
+            command: Vec::new(),
+            accessible: false,
+            no_nmap: false,
+            scan_order: ScanOrder::Serial,
+            no_config: false,
+            ignore_config: false,
+            ignore_config: false,
+            no_config: false,
+        };
+        let batch_size = infer_batch_size(&opts, 5_000);
+
+        assert!(batch_size == 4_900);
+    }
+    #[test]
+    fn batch_size_adjusted_2000() {
+        // ulimit == batch_size
+        let opts = Opts {
+            ips_or_hosts: vec!["127.0.0.1".to_owned()],
+            ports: None,
+            range: None,
+            quiet: true,
+            batch_size: 50_000,
+            timeout: 1_000,
+            ulimit: Some(2_000),
+            command: Vec::new(),
+            accessible: false,
+            scan_order: ScanOrder::Serial,
+            no_nmap: false,
+            no_config: false,
+            ignore_config: false,
+            ignore_config: false,
+            no_nmap: false,
+            no_config: false,
+        };
+        let batch_size = adjust_ulimit_size(&opts);
+
+        assert!(batch_size == 2_000);
+    }
+    #[test]
+    fn test_print_opening_no_panic() {
+        // print opening should not panic
+        print_opening();
+        assert!(1 == 1);
+    }
+    #[test]
+    fn test_high_ulimit_no_quiet_mode() {
+        let opts = Opts {
+            ips_or_hosts: vec!["127.0.0.1".to_owned()],
+            ports: None,
+            range: None,
+            quiet: false,
+            batch_size: 10,
+            timeout: 1_000,
+            ulimit: None,
+            command: Vec::new(),
+            accessible: true,
+            scan_order: ScanOrder::Serial,
+            no_nmap: false,
+            no_config: false,
+            ignore_config: false,
+            ignore_config: false,
+            no_nmap: false,
+            no_config: false,
+        };
+
+        infer_batch_size(&opts, 1_000_000);
+
+        assert!(1 == 1);
+    }
+
+    #[test]
+    fn parse_correct_ips_or_hosts() {
+        let opts = Opts {
+            ips_or_hosts: vec!["127.0.0.1".to_owned(), "google.com".to_owned()],
+            ports: None,
+            range: None,
+            quiet: true,
+            batch_size: 10,
+            timeout: 1_000,
+            ulimit: Some(2_000),
+            command: Vec::new(),
+            accessible: false,
+            scan_order: ScanOrder::Serial,
+            no_nmap: false,
+            no_config: false,
+            ignore_config: false,
+            ignore_config: false,
+            no_nmap: false,
+            no_config: false,
+        };
+        let ips = parse_ips(&opts);
+
+        assert_eq!(2, ips.len());
+    }
+
+    #[test]
+    fn parse_correct_and_incorrect_ips_or_hosts() {
+        let opts = Opts {
+            ips_or_hosts: vec!["127.0.0.1".to_owned(), "im_wrong".to_owned()],
+            ports: None,
+            range: None,
+            quiet: true,
+            batch_size: 10,
+            timeout: 1_000,
+            ulimit: Some(2_000),
+            command: Vec::new(),
+            accessible: false,
+            scan_order: ScanOrder::Serial,
+            no_nmap: false,
+            no_config: false,
+            ignore_config: false,
+            ignore_config: false,
+            no_nmap: false,
+            no_config: false,
+        };
+        let ips = parse_ips(&opts);
+
+        assert_eq!(1, ips.len());
+    }
+
+    #[test]
+    fn parse_incorrect_ips_or_hosts() {
+        let opts = Opts {
+            ips_or_hosts: vec!["im_wrong".to_owned(), "300.10.1.1".to_owned()],
+            ports: None,
+            range: None,
+            quiet: true,
+            batch_size: 10,
+            timeout: 1_000,
+            ulimit: Some(2_000),
+            command: Vec::new(),
+            accessible: false,
+            scan_order: ScanOrder::Serial,
+            no_nmap: false,
+            no_config: false,
+            ignore_config: false,
+        };
+        let ips = parse_ips(&opts);
+            ignore_config: false,
+            no_nmap: false,
+            no_config: false,
+        };
+        let ips = parse_ips(&opts);
+
+        assert_eq!(0, ips.len());
+    }
+}