Bee ci changes (#250)

* 1.10.0 release

* building CI

* building CI

.all-contributorsrc

@@ -193,6 +193,15 @@
         "bug",
         "design"
       ]
+    },
+    {
+      "login": "dmitris",
+      "name": "Dmitry Savintsev",
+      "avatar_url": "https://avatars0.githubusercontent.com/u/31205?v=4",
+      "profile": "https://github.com/dmitris",
+      "contributions": [
+        "code"
+      ]
     }
   ],
   "contributorsPerLine": 7,

.github/FUNDING.yml

@@ -1,4 +1 @@
 github: bee-san
-patreon: brandonskerritt
-ko_fi: hacker
-custom: ["https://monzo.me/bee", "https://paypal.me/brandonskerritt"]

.github/workflows/bump.yml

@@ -0,0 +1,19 @@
+name: Bump
+
+on:
+    push:
+      tags:
+        - '*'
+
+jobs:
+  bump:
+    runs-on: macos-latest
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@v2
+      - name: Bump formulae
+        uses: dawidd6/action-homebrew-bump-formula@v3
+        continue-on-error: true
+        with:
+          token: ${{secrets.brew}}
+          formula: rustscan

.gitignore

@@ -43,3 +43,80 @@ pkg/
 
 # End of https://www.toptal.com/developers/gitignore/api/rust,archlinuxpackages
 *.deb
+
+
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/**/usage.statistics.xml
+.idea/**/dictionaries
+.idea/**/shelf
+
+# Generated files
+.idea/**/contentModel.xml
+
+# Sensitive or high-churn files
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+.idea/**/dbnavigator.xml
+
+# Gradle
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# Gradle and Maven with auto-import
+# When using Gradle or Maven with auto-import, you should exclude module files,
+# since they will be recreated, and may cause churn.  Uncomment if using
+# auto-import.
+# .idea/artifacts
+# .idea/compiler.xml
+# .idea/jarRepositories.xml
+# .idea/modules.xml
+# .idea/*.iml
+# .idea/modules
+# *.iml
+# *.ipr
+
+# CMake
+cmake-build-*/
+
+# Mongo Explorer plugin
+.idea/**/mongoSettings.xml
+
+# File-based project format
+*.iws
+
+# IntelliJ
+out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+# Editor-based Rest Client
+.idea/httpRequests
+
+# Android studio 3.1+ serialized cache file
+.idea/caches/build_file_checksums.ser
+
+.idea/*
+.idea
+.idea*

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rustscan"
-version = "1.8.0"
+version = "1.10.0"
 authors = ["Bee <[email protected]>"]
 edition = "2018"
 description = "Faster Nmap Scanning with Rust"
@@ -18,7 +18,7 @@ exclude = [
 
 [dependencies]
 colored = "2.0.0"
-structopt = "0.3.17"
+structopt = "0.3.18"
 async-std = "1.6.4"
 futures = "0.3"
 rlimit = "0.4.0"
@@ -35,6 +35,7 @@ serde = "1.0.116"
 serde_derive = "1.0.116"
 cidr-utils = "0.5.0"
 itertools = "0.9.0"
+trust-dns-resolver = { version = "0.19.5", features = ["dns-over-rustls"] }
 
 [package.metadata.deb]
 depends = "$auto, nmap"

Dockerfile

@@ -1,8 +1,11 @@
 FROM rust:alpine as builder
+LABEL maintainer="CMNatic <https://github.com/CMNatic">
 RUN apk add --no-cache build-base
 
+# Encourage some layer caching here rather then copying entire directory that includes docs to builder container ~CMN
 WORKDIR /usr/src/rustscan
-COPY . .
+COPY Cargo.toml Cargo.lock ./
+COPY src src
 RUN cargo install --path .
 
 FROM alpine:3.12
@@ -13,4 +16,4 @@ RUN addgroup -S rustscan && \
     apk add --no-cache nmap nmap-scripts wget
 COPY --from=builder /usr/local/cargo/bin/rustscan /usr/local/bin/rustscan
 USER rustscan
-ENTRYPOINT [ "/usr/local/bin/rustscan" ]
+ENTRYPOINT [ "/usr/local/bin/rustscan" ]

README.md

@@ -24,7 +24,7 @@
 | <p align="center"><a href="https://hub.docker.com/r/cmnatic/rustscan">🐋 Docker (Recommended) </a></p>            | <p align="center"><a href="https://github.com/RustScan/RustScan/releases">👩‍💻 Kali / Debian </p>                 | <p align="center"><a href="https://aur.archlinux.org/packages/rustscan/">🏗️ Arch </a></p>                       | <p align="center"><a href="https://crates.io/crates/rustscan">🔧 Cargo (Universal) </a></p>                     |
 | ----------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
 | <p align="center"><img src="https://github.com/RustScan/RustScan/blob/master/pictures/docker.png?raw=true" /></p> | <p align="center"><img src="https://github.com/RustScan/RustScan/blob/master/pictures/kali.png?raw=true" /></p> | <p align="center"><img src="https://github.com/RustScan/RustScan/blob/master/pictures/arch.png?raw=true" /></p> | <p align="center"><img src="https://github.com/RustScan/RustScan/blob/master/pictures/rust.png?raw=true" /></p> |
-| `docker pull rustscan/rustscan:v1.8.0` <p>[Usage](https://github.com/RustScan/RustScan#docker-whale)              | [Read the install guide](https://github.com/Rustscan/RustScan/blob/master/README.md#%EF%B8%8F-debian--kali)     | `yay -S rustscan`                                                                                               | `cargo install rustscan`                                                                                        |
+| `docker pull rustscan/rustscan:v1.9.0` <p>[Usage](https://github.com/RustScan/RustScan#docker-whale)              | [Read the install guide](https://github.com/Rustscan/RustScan/blob/master/README.md#%EF%B8%8F-debian--kali)     | `yay -S rustscan`                                                                                               | `cargo install rustscan`                                                                                        |
 
 <hr>
 
@@ -130,22 +130,22 @@ To install Docker, [follow their guide](https://docs.docker.com/engine/install/)
 
 **Once Docker is installed, you can either build your own image using the `Dockerfile` (alpine) provided in the repo, or alternatively, use the published Docker image like below (most convenient)**
 
-Please see our [DockerHub](https://hub.docker.com/repository/docker/rustscan/rustscan) for further our published versions. However, we recommend using our latest release [v1.8.0](https://github.com/RustScan/RustScan/releases/tag/1.8.0)
+Please see our [DockerHub](https://hub.docker.com/repository/docker/rustscan/rustscan) for further our published versions. However, we recommend using our latest release [v1.9.0](https://github.com/RustScan/RustScan/releases/tag/1.9.0)
 
 ```
-Stable and supported: rustscan/rustscan:v1.8.0
+Stable and supported: rustscan/rustscan:v1.9.0
 
 Bleeding edge (run at your own risk!): rustscan/rustscan:latest
 ```
 
-We strongly recommend using the `v1.8.0` tag, as this is the latest major - stable - release of RustScan. This README uses the `v1.8.0` image by default, however, note that the `latest` image is considered experimental.
+We strongly recommend using the `v1.9.0` tag, as this is the latest major - stable - release of RustScan. This README uses the `v1.9.0` image by default, however, note that the `latest` image is considered experimental.
 
 #### To get started:
 
 Simply run this command against the IP you want to target:
 
 ```bash
-docker run -it --rm --name rustscan rustscan/rustscan:v1.8.0 <rustscan arguments here> <ip address to scan>
+docker run -it --rm --name rustscan rustscan/rustscan:v1.9.0 <rustscan arguments here> <ip address to scan>
 ```
 
 Note: this will scan the Docker's localhost, not your own.
@@ -155,7 +155,7 @@ Once done, you will no longer need to re-download the image (except when RustSca
 You will have to run this command every time, so we suggest aliasing it to something memorable.
 
 ```bash
-alias rustscan='docker run -it --rm --name rustscan rustscan/rustscan:v1.8.0'
+alias rustscan='docker run -it --rm --name rustscan rustscan/rustscan:v1.9.0'
 ```
 
 Then we can scan:
@@ -188,15 +188,7 @@ docker build -t <yourimagename> .
 
 **Note for Mac users** Mac OS has a very, very small ulimit size. This will negatively impact RustScan by a significant amount. Please use the Docker container, or tell RustScan to up the ulimit size on every run.
 
-Tap the brew:
-
-```bash
-brew tap brandonskerritt/rustscan
 ```
-
-Install it:
-
-```bash
 brew install rustscan
 ```
 
@@ -435,7 +427,7 @@ Please read the [contributing.md file](contributing.md)
 ## Contributors ✨
 
 <!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section -->
-[![All Contributors](https://img.shields.io/badge/all_contributors-19-orange.svg?style=flat-square)](#contributors-)
+[![All Contributors](https://img.shields.io/badge/all_contributors-20-orange.svg?style=flat-square)](#contributors-)
 <!-- ALL-CONTRIBUTORS-BADGE:END -->
 
 Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):
@@ -468,6 +460,7 @@ Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/d
     <td align="center"><a href="https://liberapay.com/Artem4/"><img src="https://avatars0.githubusercontent.com/u/5614476?v=4" width="100px;" alt=""/><br /><sub><b>Artem Polishchuk</b></sub></a><br /><a href="#platform-tim77" title="Packaging/porting to new platform">📦</a></td>
     <td align="center"><a href="https://github.com/buermarc"><img src="https://avatars2.githubusercontent.com/u/44375277?v=4" width="100px;" alt=""/><br /><sub><b>buermarc</b></sub></a><br /><a href="https://github.com/RustScan/RustScan/commits?author=buermarc" title="Code">💻</a></td>
     <td align="center"><a href="https://github.com/bergabman"><img src="https://avatars1.githubusercontent.com/u/44554109?v=4" width="100px;" alt=""/><br /><sub><b>bergabman</b></sub></a><br /><a href="https://github.com/RustScan/RustScan/commits?author=bergabman" title="Code">💻</a> <a href="https://github.com/RustScan/RustScan/issues?q=author%3Abergabman" title="Bug reports">🐛</a> <a href="#design-bergabman" title="Design">🎨</a></td>
+    <td align="center"><a href="https://github.com/dmitris"><img src="https://avatars0.githubusercontent.com/u/31205?v=4" width="100px;" alt=""/><br /><sub><b>Dmitry Savintsev</b></sub></a><br /><a href="https://github.com/RustScan/RustScan/commits?author=dmitris" title="Code">💻</a></td>
   </tr>
 </table>
 

fixtures/hosts.txt

@@ -0,0 +1,6 @@
+127.0.0.1
+google.com
+example.com
+66666666666666.666666666666666666.66666666666666666.6666666666
+....
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855.radiatorFixtures

src/input.rs

@@ -24,6 +24,7 @@ pub struct PortRange {
     pub end: u16,
 }
 
+#[cfg(not(tarpaulin_include))]
 fn parse_range(input: &str) -> Result<PortRange, String> {
     let range = input
         .split("-")
@@ -117,6 +118,7 @@ pub struct Opts {
     pub top: bool,
 }
 
+#[cfg(not(tarpaulin_include))]
 impl Opts {
     pub fn read() -> Self {
         let mut opts = Opts::from_args();
@@ -183,6 +185,7 @@ impl Opts {
 /// Struct used to deserialize the options specified within our config file.
 /// These will be further merged with our command line arguments in order to
 /// generate the final Opts struct.
+#[cfg(not(tarpaulin_include))]
 #[derive(Debug, Deserialize)]
 pub struct Config {
     addresses: Option<Vec<String>>,
@@ -198,6 +201,7 @@ pub struct Config {
     command: Option<Vec<String>>,
 }
 
+#[cfg(not(tarpaulin_include))]
 impl Config {
     /// Reads the configuration file with TOML format and parses it into a
     /// Config struct.
@@ -239,43 +243,53 @@ impl Config {
 #[cfg(test)]
 mod tests {
     use super::{Config, Opts, PortRange, ScanOrder};
+    impl Config {
+        fn default() -> Self {
+            Self {
+                addresses: Some(vec!["127.0.0.1".to_owned()]),
+                ports: None,
+                range: None,
+                greppable: Some(true),
+                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),
+            }
+        }
+    }
+
+    impl Opts {
+        pub fn default() -> Self {
+            Self {
+                addresses: vec![],
+                ports: None,
+                range: None,
+                greppable: true,
+                batch_size: 0,
+                timeout: 0,
+                ulimit: None,
+                command: vec![],
+                accessible: false,
+                no_nmap: false,
+                scan_order: ScanOrder::Serial,
+                no_config: true,
+                top: false,
+            }
+        }
+    }
 
     #[test]
     fn opts_no_merge_when_config_is_ignored() {
-        let mut opts = Opts {
-            addresses: vec![],
-            ports: None,
-            range: None,
-            greppable: false,
-            batch_size: 0,
-            timeout: 0,
-            ulimit: None,
-            command: vec![],
-            accessible: false,
-            no_nmap: false,
-            scan_order: ScanOrder::Serial,
-            no_config: true,
-            top: false,
-        };
-
-        let config = Config {
-            addresses: Some(vec!["127.0.0.1".to_owned()]),
-            ports: None,
-            range: None,
-            greppable: Some(true),
-            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),
-        };
+        let mut opts = Opts::default();
+        let config = Config::default();
 
         opts.merge(&config);
 
         assert_eq!(opts.addresses, vec![] as Vec<String>);
-        assert_eq!(opts.greppable, false);
+        assert_eq!(opts.greppable, true);
         assert_eq!(opts.accessible, false);
         assert_eq!(opts.timeout, 0);
         assert_eq!(opts.command, vec![] as Vec<String>);
@@ -284,35 +298,8 @@ mod tests {
 
     #[test]
     fn opts_merge_required_arguments() {
-        let mut opts = Opts {
-            addresses: vec![],
-            ports: None,
-            range: None,
-            greppable: false,
-            batch_size: 0,
-            timeout: 0,
-            ulimit: None,
-            command: vec![],
-            accessible: false,
-            scan_order: ScanOrder::Serial,
-            no_nmap: false,
-            no_config: false,
-            top: false,
-        };
-
-        let config = Config {
-            addresses: Some(vec!["127.0.0.1".to_owned()]),
-            ports: None,
-            no_nmap: Some(false),
-            range: None,
-            greppable: Some(true),
-            batch_size: Some(25_000),
-            timeout: Some(1_000),
-            ulimit: None,
-            command: Some(vec!["-A".to_owned()]),
-            accessible: Some(true),
-            scan_order: Some(ScanOrder::Random),
-        };
+        let mut opts = Opts::default();
+        let config = Config::default();
 
         opts.merge_required(&config);
 
@@ -326,38 +313,13 @@ mod tests {
 
     #[test]
     fn opts_merge_optional_arguments() {
-        let mut opts = Opts {
-            addresses: vec![],
-            ports: None,
-            range: None,
-            greppable: false,
-            batch_size: 0,
-            timeout: 0,
-            ulimit: None,
-            command: vec![],
-            accessible: false,
-            scan_order: ScanOrder::Serial,
-            no_nmap: false,
-            no_config: false,
-            top: false,
-        };
-
-        let config = Config {
-            addresses: None,
-            ports: None,
-            range: Some(PortRange {
-                start: 1,
-                end: 1_000,
-            }),
-            greppable: None,
-            batch_size: None,
-            timeout: None,
-            no_nmap: Some(false),
-            ulimit: Some(1_000),
-            command: None,
-            accessible: None,
-            scan_order: None,
-        };
+        let mut opts = Opts::default();
+        let mut config = Config::default();
+        config.range = Some(PortRange {
+            start: 1,
+            end: 1_000,
+        });
+        config.ulimit = Some(1_000);
 
         opts.merge_optional(&config);
 

src/main.rs

@@ -21,9 +21,14 @@ use futures::executor::block_on;
 use rlimit::Resource;
 use rlimit::{getrlimit, setrlimit};
 use std::collections::HashMap;
+use std::fs::File;
+use std::io::prelude::*;
+use std::io::BufReader;
 use std::net::ToSocketAddrs;
 use std::process::Command;
 use std::{net::IpAddr, time::Duration};
+use trust_dns_resolver::config::*;
+use trust_dns_resolver::Resolver;
 
 extern crate colorful;
 extern crate dirs;
@@ -204,25 +209,97 @@ fn build_nmap_arguments<'a>(
     arguments
 }
 
+/// Goes through all possible IP inputs (files or via argparsing)
+/// Parses the string(s) into IPs
 fn parse_addresses(opts: &Opts) -> Vec<IpAddr> {
     let mut ips: Vec<IpAddr> = Vec::new();
+    let resolver =
+        &Resolver::new(ResolverConfig::cloudflare_tls(), ResolverOpts::default()).unwrap();
 
     for ip_or_host in &opts.addresses {
-        match IpCidr::from_str(ip_or_host) {
-            Ok(cidr) => cidr.iter().for_each(|ip| ips.push(ip)),
-            _ => match format!("{}:{}", &ip_or_host, 80).to_socket_addrs() {
-                Ok(mut iter) => ips.push(iter.nth(0).unwrap().ip()),
+        match read_ips_from_file(ip_or_host.to_owned(), &resolver) {
+            Ok(x) => ips.extend(x),
+            _ => match parse_to_ip(ip_or_host.to_owned(), &resolver) {
+                Ok(x) => ips.extend(x),
                 _ => {
-                    let failed_to_resolve = format!("Host {:?} could not be resolved.", ip_or_host);
-                    warning!(failed_to_resolve, opts.greppable, opts.accessible);
+                    warning!(
+                        format!("Host {:?} could not be resolved.", ip_or_host),
+                        opts.greppable,
+                        opts.accessible
+                    );
                 }
             },
         }
     }
-
     ips
 }
 
+/// Uses DNS to get the IPS assiocated with host
+fn resolve_ips_from_host(
+    source: &String,
+    resolver: &Resolver,
+) -> Result<Vec<IpAddr>, std::io::Error> {
+    let mut ips: Vec<std::net::IpAddr> = Vec::new();
+
+    match resolver.lookup_ip(&source) {
+        Ok(x) => {
+            for ip in x.iter() {
+                ips.push(ip);
+            }
+        }
+        _ => (),
+    };
+    return Ok(ips);
+}
+
+#[cfg(not(tarpaulin_include))]
+/// Parses an input file of IPs and uses those
+fn read_ips_from_file(
+    ips: String,
+    resolver: &Resolver,
+) -> Result<Vec<std::net::IpAddr>, std::io::Error> {
+    // if we cannot open it as a file, it is not a file so move on
+    let file = File::open(ips)?;
+    let reader = BufReader::new(file);
+
+    let mut ips: Vec<std::net::IpAddr> = Vec::new();
+
+    for str_ip in reader.lines() {
+        match str_ip {
+            Ok(x) => match parse_to_ip(x, resolver) {
+                Ok(result) => ips.extend(result),
+                Err(e) => {
+                    debug!("{} is not a valid IP or host", e);
+                }
+            },
+            Err(_) => {
+                debug!("Line in file is not valid");
+            }
+        }
+    }
+    Ok(ips)
+}
+
+/// Given a string, parse it as an host, IP address, or CIDR.
+/// This allows us to pass files as hosts or cidr or IPs easily
+/// Call this everytime you have a possible IP_or_host
+fn parse_to_ip(address: String, resolver: &Resolver) -> Result<Vec<IpAddr>, std::io::Error> {
+    let mut ips: Vec<IpAddr> = Vec::new();
+
+    match IpCidr::from_str(&address) {
+        Ok(cidr) => cidr.iter().for_each(|ip| ips.push(ip)),
+        _ => match format!("{}:{}", &address, 80).to_socket_addrs() {
+            Ok(mut iter) => ips.push(iter.nth(0).unwrap().ip()),
+            _ => match resolve_ips_from_host(&address, resolver) {
+                Ok(hosts) => ips.extend(hosts),
+                _ => (),
+            },
+        },
+    };
+
+    Ok(ips)
+}
+
 fn adjust_ulimit_size(opts: &Opts) -> rlimit::rlim {
     if opts.ulimit.is_some() {
         let limit: rlimit::rlim = opts.ulimit.unwrap();
@@ -235,7 +312,13 @@ fn adjust_ulimit_size(opts: &Opts) -> rlimit::rlim {
                     opts.accessible
                 );
             }
-            Err(_) => println!("{}", "ERROR. Failed to set ulimit value."),
+            Err(_) => {
+                warning!(
+                    "ERROR. Failed to set ulimit value.",
+                    opts.greppable,
+                    opts.accessible
+                );
+            }
         }
     }
 
@@ -273,10 +356,8 @@ fn infer_batch_size(opts: &Opts, ulimit: rlimit::rlim) -> u16 {
     // 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.greppable, opts.accessible);
+        detail!(format!("File limit higher than batch size. Can increase speed by increasing batch size '-b {}'.", ulimit - 100), 
+            opts.greppable, opts.accessible);
     }
 
     batch_size as u16
@@ -284,50 +365,22 @@ fn infer_batch_size(opts: &Opts, ulimit: rlimit::rlim) -> u16 {
 
 #[cfg(test)]
 mod tests {
-    use crate::{
-        adjust_ulimit_size, infer_batch_size, parse_addresses, print_opening, Opts, ScanOrder,
-    };
+    use crate::{adjust_ulimit_size, infer_batch_size, parse_addresses, print_opening, Opts};
     use std::net::Ipv4Addr;
 
     #[test]
     fn batch_size_lowered() {
-        let opts = Opts {
-            addresses: vec!["127.0.0.1".to_owned()],
-            ports: None,
-            range: None,
-            greppable: true,
-            batch_size: 50_000,
-            timeout: 1_000,
-            ulimit: Some(2_000),
-            command: Vec::new(),
-            accessible: false,
-            scan_order: ScanOrder::Serial,
-            no_config: false,
-            no_nmap: false,
-            top: false,
-        };
+        let mut opts = Opts::default();
+        opts.batch_size = 50_000;
         let batch_size = infer_batch_size(&opts, 120);
 
-        assert!(batch_size < 50_000);
+        assert!(batch_size < opts.batch_size);
     }
 
     #[test]
     fn batch_size_lowered_average_size() {
-        let opts = Opts {
-            addresses: vec!["127.0.0.1".to_owned()],
-            ports: None,
-            range: None,
-            greppable: true,
-            batch_size: 50_000,
-            timeout: 1_000,
-            ulimit: Some(2_000),
-            command: Vec::new(),
-            accessible: false,
-            scan_order: ScanOrder::Serial,
-            no_config: false,
-            no_nmap: false,
-            top: false,
-        };
+        let mut opts = Opts::default();
+        opts.batch_size = 50_000;
         let batch_size = infer_batch_size(&opts, 9_000);
 
         assert!(batch_size == 3_000);
@@ -336,21 +389,8 @@ mod tests {
     fn batch_size_equals_ulimit_lowered() {
         // because ulimit and batch size are same size, batch size is lowered
         // to ULIMIT - 100
-        let opts = Opts {
-            addresses: vec!["127.0.0.1".to_owned()],
-            ports: None,
-            range: None,
-            greppable: true,
-            batch_size: 50_000,
-            timeout: 1_000,
-            ulimit: Some(2_000),
-            command: Vec::new(),
-            accessible: false,
-            scan_order: ScanOrder::Serial,
-            no_config: false,
-            no_nmap: false,
-            top: false,
-        };
+        let mut opts = Opts::default();
+        opts.batch_size = 50_000;
         let batch_size = infer_batch_size(&opts, 5_000);
 
         assert!(batch_size == 4_900);
@@ -358,86 +398,36 @@ mod tests {
     #[test]
     fn batch_size_adjusted_2000() {
         // ulimit == batch_size
-        let opts = Opts {
-            addresses: vec!["127.0.0.1".to_owned()],
-            ports: None,
-            range: None,
-            greppable: true,
-            batch_size: 50_000,
-            timeout: 1_000,
-            ulimit: Some(2_000),
-            command: Vec::new(),
-            accessible: false,
-            scan_order: ScanOrder::Serial,
-            no_config: false,
-            no_nmap: false,
-            top: false,
-        };
+        let mut opts = Opts::default();
+        opts.batch_size = 50_000;
+        opts.ulimit = Some(2_000);
         let batch_size = adjust_ulimit_size(&opts);
 
         assert!(batch_size == 2_000);
     }
     #[test]
     fn test_print_opening_no_panic() {
-        let opts = Opts {
-            addresses: vec!["127.0.0.1".to_owned()],
-            ports: None,
-            range: None,
-            greppable: true,
-            batch_size: 50_000,
-            timeout: 1_000,
-            ulimit: Some(2_000),
-            command: Vec::new(),
-            accessible: false,
-            scan_order: ScanOrder::Serial,
-            no_config: false,
-            no_nmap: false,
-            top: false,
-        };
+        let mut opts = Opts::default();
+        opts.ulimit = Some(2_000);
         // print opening should not panic
         print_opening(&opts);
         assert!(1 == 1);
     }
     #[test]
-    fn test_high_ulimit_no_quiet_mode() {
-        let opts = Opts {
-            addresses: vec!["127.0.0.1".to_owned()],
-            ports: None,
-            range: None,
-            greppable: false,
-            batch_size: 10,
-            timeout: 1_000,
-            ulimit: None,
-            command: Vec::new(),
-            accessible: true,
-            scan_order: ScanOrder::Serial,
-            no_config: false,
-            no_nmap: false,
-            top: false,
-        };
+    fn test_high_ulimit_no_greppable_mode() {
+        let mut opts = Opts::default();
+        opts.batch_size = 10;
+        opts.greppable = false;
 
-        infer_batch_size(&opts, 1_000_000);
+        let batch_size = infer_batch_size(&opts, 1_000_000);
 
-        assert!(1 == 1);
+        assert!(batch_size == opts.batch_size);
     }
 
     #[test]
     fn parse_correct_addresses() {
-        let opts = Opts {
-            addresses: vec!["127.0.0.1".to_owned(), "192.168.0.0/30".to_owned()],
-            ports: None,
-            range: None,
-            greppable: true,
-            batch_size: 10,
-            timeout: 1_000,
-            ulimit: Some(2_000),
-            command: Vec::new(),
-            accessible: false,
-            scan_order: ScanOrder::Serial,
-            no_config: false,
-            no_nmap: false,
-            top: false,
-        };
+        let mut opts = Opts::default();
+        opts.addresses = vec!["127.0.0.1".to_owned(), "192.168.0.0/30".to_owned()];
         let ips = parse_addresses(&opts);
 
         assert_eq!(
@@ -454,21 +444,8 @@ mod tests {
 
     #[test]
     fn parse_correct_host_addresses() {
-        let opts = Opts {
-            addresses: vec!["google.com".to_owned()],
-            ports: None,
-            range: None,
-            greppable: true,
-            batch_size: 10,
-            timeout: 1_000,
-            ulimit: Some(2_000),
-            command: Vec::new(),
-            accessible: false,
-            scan_order: ScanOrder::Serial,
-            no_config: false,
-            no_nmap: false,
-            top: false,
-        };
+        let mut opts = Opts::default();
+        opts.addresses = vec!["google.com".to_owned()];
         let ips = parse_addresses(&opts);
 
         assert_eq!(ips.len(), 1);
@@ -476,21 +453,8 @@ mod tests {
 
     #[test]
     fn parse_correct_and_incorrect_addresses() {
-        let opts = Opts {
-            addresses: vec!["127.0.0.1".to_owned(), "im_wrong".to_owned()],
-            ports: None,
-            range: None,
-            greppable: true,
-            batch_size: 10,
-            timeout: 1_000,
-            ulimit: Some(2_000),
-            command: Vec::new(),
-            accessible: false,
-            scan_order: ScanOrder::Serial,
-            no_config: false,
-            no_nmap: false,
-            top: false,
-        };
+        let mut opts = Opts::default();
+        opts.addresses = vec!["127.0.0.1".to_owned(), "im_wrong".to_owned()];
         let ips = parse_addresses(&opts);
 
         assert_eq!(ips, [Ipv4Addr::new(127, 0, 0, 1),]);
@@ -498,23 +462,18 @@ mod tests {
 
     #[test]
     fn parse_incorrect_addresses() {
-        let opts = Opts {
-            addresses: vec!["im_wrong".to_owned(), "300.10.1.1".to_owned()],
-            ports: None,
-            range: None,
-            greppable: true,
-            batch_size: 10,
-            timeout: 1_000,
-            ulimit: Some(2_000),
-            command: Vec::new(),
-            accessible: false,
-            scan_order: ScanOrder::Serial,
-            no_config: false,
-            no_nmap: false,
-            top: false,
-        };
+        let mut opts = Opts::default();
+        opts.addresses = vec!["im_wrong".to_owned(), "300.10.1.1".to_owned()];
         let ips = parse_addresses(&opts);
 
         assert_eq!(ips.is_empty(), true);
     }
+    #[test]
+    fn parse_hosts_file_and_incorrect_hosts() {
+        // Host file contains IP, Hosts, incorrect IPs, incorrect hosts
+        let mut opts = Opts::default();
+        opts.addresses = vec!["fixtures/hosts.txt".to_owned()];
+        let ips = parse_addresses(&opts);
+        assert_eq!(ips.len(), 3);
+    }
 }

src/scanner/mod.rs

@@ -26,7 +26,7 @@ pub struct Scanner {
     ips: Vec<IpAddr>,
     batch_size: u16,
     timeout: Duration,
-    quiet: bool,
+    greppable: bool,
     port_strategy: PortStrategy,
     accessible: bool,
 }
@@ -36,14 +36,14 @@ impl Scanner {
         ips: &[IpAddr],
         batch_size: u16,
         timeout: Duration,
-        quiet: bool,
+        greppable: bool,
         port_strategy: PortStrategy,
         accessible: bool,
     ) -> Self {
         Self {
             batch_size,
             timeout,
-            quiet,
+            greppable,
             port_strategy,
             ips: ips.iter().map(|ip| ip.to_owned()).collect(),
             accessible,
@@ -110,7 +110,7 @@ impl Scanner {
                     Err(e) => debug!("Shutdown stream error {}", &e),
                     _ => {}
                 }
-                if !self.quiet {
+                if !self.greppable {
                     if self.accessible {
                         println!("Open {}", socket.to_string());
                     } else {