test: clean obsolete executable fixtures and CI hooks

Fixes a typo in the Scriptfile parser comment (Sriptfile → Scriptfile) and improves the wording for clarity.

.github/workflows/build.yml

@@ -37,11 +37,11 @@ jobs:
             path: target/aarch64-unknown-linux-gnu/release/rustscan
             pkg_config_path: /usr/lib/x86_64-linux-gnu/pkgconfig
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
       - name: Cache cargo & target directories
         uses: Swatinem/rust-cache@v2
       - name: Build binary
-        uses: houseabsolute/actions-rust-cross@v0
+        uses: houseabsolute/actions-rust-cross@v1
         with:
           command: build
           target: ${{ matrix.target }}
@@ -52,11 +52,11 @@ jobs:
         if: matrix.type == 'ubuntu-x64'
         run: |
           tar czf ${{ matrix.name }}.tar.gz -C target/x86_64-unknown-linux-musl/release rustscan
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v7
         with:
           name: ${{ matrix.name }}
           path: ${{ matrix.path }}
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v7
         if: matrix.type == 'ubuntu-x64'
         with:
           name: ${{ matrix.name }}.tar.gz
@@ -67,7 +67,7 @@ jobs:
     env:
       IN_PIPELINE: true
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
       - name: Install cargo-deb
         run: cargo install -f cargo-deb
       - uses: awalsh128/cache-apt-pkgs-action@v1
@@ -79,7 +79,7 @@ jobs:
       - name: Deb Build
         run: cargo deb --target=x86_64-unknown-linux-musl
       - name: Upload Deb Artifact
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v7
         with:
           name: rustscan.deb
           path: ./target/x86_64-unknown-linux-musl/debian/*
@@ -90,11 +90,11 @@ jobs:
     runs-on: macos-latest
     if: github.ref == 'refs/heads/master'
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
       - name: Cache cargo & target directories
         uses: Swatinem/rust-cache@v2
       - name: Build binary
-        uses: houseabsolute/actions-rust-cross@v0
+        uses: houseabsolute/actions-rust-cross@v1
         with:
           command: build
           target: x86_64-apple-darwin
@@ -104,11 +104,11 @@ jobs:
       - name: Build tar.gz for homebrew installs
         run: |
           tar czf x86_64-macos-rustscan.tar.gz -C target/x86_64-apple-darwin/release rustscan
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v7
         with:
           name: x86_64-macos-rustscan
           path: target/x86_64-apple-darwin/release/rustscan
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v7
         with:
           name: x86_64-macos-rustscan.tar.gz
           path: x86_64-macos-rustscan.tar.gz
@@ -119,11 +119,11 @@ jobs:
     runs-on: macos-latest
     if: github.ref == 'refs/heads/master'
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
       - name: Cache cargo & target directories
         uses: Swatinem/rust-cache@v2
       - name: Build binary
-        uses: houseabsolute/actions-rust-cross@v0
+        uses: houseabsolute/actions-rust-cross@v1
         with:
           command: build
           target: aarch64-apple-darwin
@@ -133,11 +133,11 @@ jobs:
       - name: Build tar.gz for homebrew installs
         run: |
           tar czf aarch64-macos-rustscan.tar.gz -C target/aarch64-apple-darwin/release rustscan
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v7
         with:
           name: aarch64-macos-rustscan
           path: target/aarch64-apple-darwin/release/rustscan
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v7
         with:
           name: aarch64-macos-rustscan.tar.gz
           path: aarch64-macos-rustscan.tar.gz
@@ -162,18 +162,18 @@ jobs:
             name: x86-windows-rustscan.exe
             path: target\i686-pc-windows-msvc\release\rustscan.exe
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
       - name: Cache cargo & target directories
         uses: Swatinem/rust-cache@v2
       - name: Build binary
-        uses: houseabsolute/actions-rust-cross@v0
+        uses: houseabsolute/actions-rust-cross@v1
         with:
           command: build
           target:  ${{ matrix.target }}
           args: "--locked --release"
           strip: true
           toolchain: stable
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v7
         with:
           name: ${{ matrix.name }}
           path: ${{ matrix.path }}

.github/workflows/dependabot.yml

@@ -1,9 +1,4 @@
 name: Dependabot Auto-Merge
-on: pull_request
-
-permissions:
-  contents: write
-  pull-requests: write
 
 jobs:
   dependabot:

.github/workflows/markdown.yml

@@ -1,21 +0,0 @@
-name: Check Markdown links
-
-on: 
-  push:
-    branches:
-    - master
-    paths-ignore:
-      - '.github/**'
-  schedule:
-  # Run everyday at 9:00 AM (See https://pubs.opengroup.org/onlinepubs/9699919799/utilities/crontab.html#tag_20_25_07)
-  - cron: "0 9 * * *"
-
-jobs:
-  markdown-link-check:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@master
-    - uses: gaurav-nelson/github-action-markdown-link-check@v1
-      with:
-        use-quiet-mode: 'yes'
-        config-file: './.github/workflows/mlc_config.json'

.github/workflows/test.yml

@@ -15,7 +15,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Checkout sources
-        uses: actions/checkout@v4
+        uses: actions/checkout@v7
 
       - name: Install stable toolchain
         uses: actions-rs/toolchain@v1
@@ -28,7 +28,7 @@ jobs:
       - uses: Swatinem/rust-cache@v2
 
       - name: Install Just
-        uses: extractions/setup-just@v2
+        uses: extractions/setup-just@v4
 
       - name: Run just
         run: just test

.travis.yml

@@ -17,12 +17,7 @@ jobs:
 script:
 - cargo build
 - cargo test
-- "ulimit -n 5000; cargo test timelimits:: -- --ignored --test-threads=1 --show-output"
 - cargo fmt -- --check
-after_failure:
-- wget https://raw.githubusercontent.com/DiscordHooks/travis-ci-discord-webhook/master/send.sh
-- chmod +x send.sh
-- "./send.sh failure $WEBHOOK_URL"
 after_success: |
   if [ -n "${GITHUB_TOKEN}" ]; then
     [ "${TRAVIS_BRANCH} " = master ] &&

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rustscan"
-version = "2.3.0"
+version = "2.4.1"
 authors = ["Autumn <[email protected]>"]
 edition = "2018"
 description = "Faster Nmap Scanning with Rust"
@@ -17,33 +17,32 @@ exclude = [
 ]
 
 [dependencies]
-clap = { version = "4.5.13", features = ["derive", "wrap_help"] }
-colored = "3.0.0"
-async-std = "1.13.0"
+clap = { version = "4.6.1", features = ["derive", "wrap_help"] }
+colored = "3.1.1"
+async-std = "1.13.2"
 futures = "0.3"
-rlimit = "0.10.2"
-log = "0.4.25"
-env_logger = "0.11.6"
-anstream = "=0.6.18"
-dirs = "6.0.0"
+rlimit = "0.11.0"
+log = "0.4.32"
+env_logger = "0.11.10"
+anstream = "=1.0.0"
+dirs = "7.0.0"
 gcd = "2.0.1"
-rand = "0.9.0"
+rand = "0.10.1"
 colorful = "0.3.2"
 ansi_term = "0.12.1"
-toml = "0.8.20"
+toml = "1.1.2"
 serde = "1.0.124"
 serde_derive = "1.0.116"
-cidr-utils = "0.6.1"
-itertools = "0.14.0"
+cidr-utils = "0.7.1"
+itertools = "0.15.0"
 hickory-resolver = { version = "0.24.3", features = ["dns-over-rustls"] }
 anyhow = "1.0.40"
 text_placeholder = { version = "0.5", features = ["struct_context"] }
-once_cell = "1.20.3"
+once_cell = "1.21.4"
 
 [dev-dependencies]
 parameterized = "2.0.0"
-wait-timeout = "0.2"
-criterion = { version = "0.5", features = ["html_reports"] }
+criterion = { version = "0.8", features = ["html_reports"] }
 
 [package.metadata.deb]
 depends = "$auto, nmap"
@@ -63,5 +62,5 @@ path = "src/main.rs"
 unexpected_cfgs = { level = "warn", check-cfg = ["cfg(tarpaulin_include)"] }
 
 [[bench]]
-name = "benchmark_portscan"
+name = "benchmark_helpers"
 harness = false

README.md

@@ -40,7 +40,7 @@ MacOS:
 Arch:
 
 ```
-  yay rustscan
+  pacman -S rustscan
 ```
 
 # ✨ Features
@@ -55,7 +55,7 @@ Arch:
 
 |         <!--Installation Guide-->          |          <!--Documentation-->          |       <!--Discord-->        |
 | :----------------------------------------: | :------------------------------------: | :-------------------------: |
-| :book: [Installation Guide][links-table-1] | :books: [Documentation][links-table-2] | :parrot: [Discord][discord] |
+| :book: [Installation Guide][toc-install] | :books: [Documentation][links-table-2] | :parrot: [Discord][discord] |
 
 ## 🙋 Table of Contents
 
@@ -209,7 +209,7 @@ This project follows the [all-contributors](https://github.com/all-contributors/
 [speed-3]: https://github.com/RustScan/RustScan/wiki/Increasing-Speed-&-Accuracy "Increasing Speed & Accuracy"
 [toc-community]: https://github.com/RustScan/RustScan#-community "Community"
 [links-table-1]: https://github.com/RustScan/RustScan#-full-installation-guide "Full installation guide"
-[links-table-2]: https://rustscan.github.io/RustScan/ "Rustscan"
+[links-table-2]: https://github.com/bee-san/RustScan/wiki "Rustscan"
 [discord]: http://discord.skerritt.blog "Discord blog"
 [toc-install]: https://github.com/RustScan/RustScan/wiki/Installation-Guide "Installation Guide Wiki"
 [toc-docker-usage]: https://github.com/RustScan/RustScan/wiki/Installation-Guide#docker- "Docker Installation Guide Wiki"

benches/benchmark_helpers.rs

@@ -0,0 +1,52 @@
+use criterion::{criterion_group, criterion_main, Criterion};
+use rustscan::input::{Opts, PortRange, ScanOrder};
+use rustscan::port_strategy::PortStrategy;
+use std::net::IpAddr;
+use std::time::Duration;
+
+fn bench_address() {
+    let _addrs = ["127.0.0.1".parse::<IpAddr>().unwrap()];
+}
+
+fn bench_port_strategy() {
+    let range = PortRange {
+        start: 1,
+        end: 1_000,
+    };
+    let _strategy = PortStrategy::pick(&Some(range.clone()), None, ScanOrder::Serial);
+}
+
+fn bench_address_parsing() {
+    let opts = Opts {
+        addresses: vec![
+            "127.0.0.1".to_owned(),
+            "10.2.0.1".to_owned(),
+            "192.168.0.0/24".to_owned(),
+        ],
+        exclude_addresses: Some(vec![
+            "10.0.0.0/8".to_owned(),
+            "172.16.0.0/12".to_owned(),
+            "192.168.0.0/16".to_owned(),
+            "172.16.0.1".to_owned(),
+        ]),
+        ..Default::default()
+    };
+    let _ips = rustscan::address::parse_addresses(&opts);
+}
+
+fn criterion_benchmark(c: &mut Criterion) {
+    // Benching helper functions
+    c.bench_function("parse address", |b| b.iter(bench_address));
+
+    c.bench_function("port strategy", |b| b.iter(bench_port_strategy));
+
+    let mut address_group = c.benchmark_group("address parsing");
+    address_group.measurement_time(Duration::from_secs(10));
+    address_group.bench_function("parse addresses with exclusions", |b| {
+        b.iter(bench_address_parsing)
+    });
+    address_group.finish();
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);

benches/benchmark_portscan.rs

@@ -1,80 +0,0 @@
-use async_std::task::block_on;
-use criterion::{black_box, criterion_group, criterion_main, Criterion};
-use rustscan::input::{PortRange, ScanOrder};
-use rustscan::port_strategy::PortStrategy;
-use rustscan::scanner::Scanner;
-use std::net::IpAddr;
-use std::time::Duration;
-
-fn portscan_tcp(scanner: &Scanner) {
-    let _scan_result = block_on(scanner.run());
-}
-
-fn portscan_udp(scanner: &Scanner) {
-    let _scan_result = block_on(scanner.run());
-}
-
-fn bench_address() {
-    let _addrs = ["127.0.0.1".parse::<IpAddr>().unwrap()];
-}
-
-fn bench_port_strategy() {
-    let range = PortRange {
-        start: 1,
-        end: 1_000,
-    };
-    let _strategy = PortStrategy::pick(&Some(range.clone()), None, ScanOrder::Serial);
-}
-
-fn criterion_benchmark(c: &mut Criterion) {
-    let addrs = vec!["127.0.0.1".parse::<IpAddr>().unwrap()];
-    let range = PortRange {
-        start: 1,
-        end: 1_000,
-    };
-    let strategy_tcp = PortStrategy::pick(&Some(range.clone()), None, ScanOrder::Serial);
-    let strategy_udp = PortStrategy::pick(&Some(range.clone()), None, ScanOrder::Serial);
-
-    let scanner_tcp = Scanner::new(
-        &addrs,
-        10,
-        Duration::from_millis(10),
-        1,
-        false,
-        strategy_tcp,
-        true,
-        vec![],
-        false,
-    );
-
-    c.bench_function("portscan tcp", |b| {
-        b.iter(|| portscan_tcp(black_box(&scanner_tcp)))
-    });
-
-    let scanner_udp = Scanner::new(
-        &addrs,
-        10,
-        Duration::from_millis(10),
-        1,
-        false,
-        strategy_udp,
-        true,
-        vec![],
-        true,
-    );
-
-    let mut udp_group = c.benchmark_group("portscan udp");
-    udp_group.measurement_time(Duration::from_secs(20));
-    udp_group.bench_function("portscan udp", |b| {
-        b.iter(|| portscan_udp(black_box(&scanner_udp)))
-    });
-    udp_group.finish();
-
-    // Benching helper functions
-    c.bench_function("parse address", |b| b.iter(bench_address));
-
-    c.bench_function("port strategy", |b| b.iter(bench_port_strategy));
-}
-
-criterion_group!(benches, criterion_benchmark);
-criterion_main!(benches);

build.rs

@@ -141,7 +141,7 @@ fn ports_v(fp_map: &BTreeMap<i32, String>) -> BTreeMap<i32, Vec<u16>> {
                 } else if !segment.is_empty() {
                     match segment.parse::<u16>() {
                         Ok(port) => port_list.push(port),
-                        Err(_) => println!("Error parsing port: {}", segment),
+                        Err(_) => println!("Error parsing port: {segment}"),
                     }
                 }
             }

contributing.Dockerfile

@@ -1,5 +1,5 @@
+# Dockerfile for RustScan development environment
+# Provides a containerized setup with Rust and development tools
 FROM rust
-# Install nmap first.
-RUN apt-get update -qy && apt-get install -qy nmap
-# Then install rustfmt and clippy for cargo.
-RUN rustup component add rustfmt clippy
+# Install rustfmt for code formatting and clippy for linting.
+RUN rustup component add rustfmt clippy

contributing.md

@@ -54,10 +54,10 @@ You can now modify RustScan files with your favorite editor, once you want to co
 root@container:/rustscan# cargo build
 ```
 
-You are now ready to use RustScan:
+You can check the command-line interface without starting a scan:
 
 ```bash
-root@container:/rustscan# cargo run -- -b 2000 -t 5000 -a 127.0.0.1
+root@container:/rustscan# cargo run -- --help
 ```
 
 You can also format, lint with `clippy` and test the code with the following commands:
@@ -67,3 +67,8 @@ root@container:/rustscan# cargo fmt
 root@container:/rustscan# cargo clippy
 root@container:/rustscan# cargo test
 ```
+
+Automated tests and benchmarks must run without network traffic or external script
+execution. Keep coverage focused on parsing, configuration, port ordering, socket
+address iteration, and timing helpers. Do not add tests that run TCP/UDP scans
+(including localhost), resolve hostnames, or launch Nmap or other scripts.

fixtures/.rustscan_scripts.toml

@@ -0,0 +1,4 @@
+tags = ["core_approved", "example"]
+ports = ["80", "443", "8080"]
+developer = ["example", "https://example.org"]
+directory = "fixtures/.rustscan_scripts" 

fixtures/.rustscan_scripts/test_script.pl

@@ -1,23 +0,0 @@
-#!/usr/bin/perl
-#tags = ["core_approved", "example",]
-#developer = [ "example", "https://example.org" ]
-#ports_separator = ","
-#call_format = "perl {{script}} {{ip}} {{port}}"
-
-# Sriptfile parser stops at the first blank line with parsing.
-# This script will run itself as an argument with the system installed perl interpreter, ports will be concatenated with "," .
-# Unused field: trigger_port = "80"
-# get total arg passed to this script
-my $total = $#ARGV + 1;
-my $counter = 1;
- 
-# get script name
-my $scriptname = $0;
- 
-print "Total args passed to $scriptname : $total\n";
- 
-# Use loop to print all args stored in an array called @ARGV
-foreach my $a(@ARGV) {
-	print "Arg # $counter : $a\n";
-	$counter++;
-}

fixtures/.rustscan_scripts/test_script.py

@@ -1,13 +0,0 @@
-#!/usr/bin/python3
-#tags = ["core_approved", "example",]
-#developer = [ "example", "https://example.org" ]
-#trigger_port = "80"
-#call_format = "python3 {{script}} {{ip}} {{port}}"
-
-# Sriptfile parser stops at the first blank line with parsing.
-# This script will run itself as an argument with the system installed python interpreter, only scanning port 80.
-# Unused filed: ports_separator = ","
-
-import sys
-
-print('Python script ran with arguments', str(sys.argv))

fixtures/.rustscan_scripts/test_script.sh

@@ -1,12 +0,0 @@
-#!/bin/bash 
-#tags = ["core_approved", "example",]
-#developer = [ "example", "https://example.org" ]
-#ports_separator = ","
-#call_format = "bash {{script}} {{ip}} {{port}}"
-
-# Sriptfile parser stops at the first blank line with parsing.
-# This script will run itself as an argument with the system installed bash interpreter, scanning all ports concatenated with "," .
-# Unused filed: trigger_port = "80"
-
-# print all arguments passed to the script
-echo $@

fixtures/.rustscan_scripts/test_script.txt

@@ -1,9 +1,7 @@
-#!intentional_blank_line
+Metadata-only test fixture; not executable.
 #tags = ["core_approved", "example"]
 #developer = [ "example", "https://example.org" ]
 #ports_separator = ","
-#call_format = "nmap -vvv -p {{port}} {{ip}}"
+#call_format = "fixture {{ip}} {{port}}"
 
-# Scriptfile parser stops at the first blank line with parsing.
-# This script will run the system installed nmap, ports will be concatenated with "," .
-# Unused field: trigger_port = "80"
+The parser reads only the metadata above. This file contains no script body.

fixtures/.rustscan_scripts/test_script_invalid_headers.txt

@@ -1,7 +1,7 @@
-#!intentional_blank_line
+Metadata-only test fixture; not executable.
 #tags = "core_approved"
 #developer = [ "example", "https://example.org" ]
 #ports_separator = ","
-#call_format = "nmap -vvv -p {{port}} {{ip}}"
+#call_format = "fixture {{ip}} {{port}}"
 
-# tags has to be an array, thus this file won't be parsed
+# tags has to be an array, thus this file won't be parsed

fixtures/hosts.txt

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

justfile

@@ -1,5 +1,5 @@
 test:
-    cargo nextest run
+    cargo test
     cargo clippy -- --deny warnings
     cargo clippy --tests -- --deny warnings
     cargo fmt --check

src/address.rs

@@ -6,7 +6,7 @@ use std::net::{IpAddr, SocketAddr, ToSocketAddrs};
 use std::path::Path;
 use std::str::FromStr;
 
-use cidr_utils::cidr::IpCidr;
+use cidr_utils::cidr::{IpCidr, IpInet};
 use hickory_resolver::{
     config::{NameServerConfig, Protocol, ResolverConfig, ResolverOpts},
     Resolver,
@@ -69,17 +69,11 @@ pub fn parse_addresses(input: &Opts) -> Vec<IpAddr> {
         }
     }
 
-    // Finally, craft a list of addresses to be excluded from the scan.
-    let mut excluded_ips: BTreeSet<IpAddr> = BTreeSet::new();
-    if let Some(exclude_addresses) = &input.exclude_addresses {
-        for addr in exclude_addresses {
-            excluded_ips.extend(parse_address(addr, &backup_resolver));
-        }
-    }
+    let excluded_cidrs = parse_excluded_networks(&input.exclude_addresses, &backup_resolver);
 
     // Remove duplicated/excluded IPs.
     let mut seen = BTreeSet::new();
-    ips.retain(|ip| seen.insert(*ip) && !excluded_ips.contains(ip));
+    ips.retain(|ip| seen.insert(*ip) && !excluded_cidrs.iter().any(|cidr| cidr.contains(ip)));
 
     ips
 }
@@ -98,16 +92,21 @@ pub fn parse_addresses(input: &Opts) -> Vec<IpAddr> {
 /// let ips = parse_address("127.0.0.1", &Resolver::default().unwrap());
 /// ```
 pub fn parse_address(address: &str, resolver: &Resolver) -> Vec<IpAddr> {
-    IpCidr::from_str(address)
-        .map(|cidr| cidr.iter().map(|c| c.address()).collect())
-        .ok()
-        .or_else(|| {
-            format!("{}:80", &address)
-                .to_socket_addrs()
-                .ok()
-                .map(|mut iter| vec![iter.next().unwrap().ip()])
-        })
-        .unwrap_or_else(|| resolve_ips_from_host(address, resolver))
+    if let Ok(addr) = IpAddr::from_str(address) {
+        // `address` is an IP string
+        vec![addr]
+    } else if let Ok(net_addr) = IpInet::from_str(address) {
+        // `address` is a CIDR string
+        net_addr.network().into_iter().addresses().collect()
+    } else {
+        // `address` is a hostname or DNS name
+        // attempt default DNS lookup
+        match format!("{address}:80").to_socket_addrs() {
+            Ok(mut iter) => vec![iter.next().unwrap().ip()],
+            // default lookup didn't work, so try again with the dedicated resolver
+            Err(_) => resolve_ips_from_host(address, resolver),
+        }
+    }
 }
 
 /// Uses DNS to get the IPS associated with host
@@ -125,6 +124,46 @@ fn resolve_ips_from_host(source: &str, backup_resolver: &Resolver) -> Vec<IpAddr
     ips
 }
 
+/// Parses excluded networks from a list of addresses.
+///
+/// This function handles three types of inputs:
+/// 1. CIDR notation (e.g. "192.168.0.0/24")
+/// 2. Single IP addresses (e.g. "192.168.0.1")
+/// 3. Hostnames that need to be resolved (e.g. "example.com")
+///
+/// ```rust
+/// # use rustscan::address::parse_excluded_networks;
+/// # use hickory_resolver::Resolver;
+/// let resolver = Resolver::default().unwrap();
+/// let excluded = parse_excluded_networks(&Some(vec!["192.168.0.0/24".to_owned()]), &resolver);
+/// ```
+pub fn parse_excluded_networks(
+    exclude_addresses: &Option<Vec<String>>,
+    resolver: &Resolver,
+) -> Vec<IpCidr> {
+    exclude_addresses
+        .iter()
+        .flatten()
+        .flat_map(|addr| parse_single_excluded_address(addr, resolver))
+        .collect()
+}
+
+/// Parses a single address into an IpCidr, handling CIDR notation, IP addresses, and hostnames.
+fn parse_single_excluded_address(addr: &str, resolver: &Resolver) -> Vec<IpCidr> {
+    if let Ok(cidr) = IpCidr::from_str(addr) {
+        return vec![cidr];
+    }
+
+    if let Ok(ip) = IpAddr::from_str(addr) {
+        return vec![IpCidr::new_host(ip)];
+    }
+
+    resolve_ips_from_host(addr, resolver)
+        .into_iter()
+        .map(IpCidr::new_host)
+        .collect()
+}
+
 /// Derive a DNS resolver.
 ///
 /// 1. if the `resolver` parameter has been set:
@@ -197,7 +236,7 @@ fn read_ips_from_file(
 
 #[cfg(test)]
 mod tests {
-    use super::{get_resolver, parse_addresses, Opts};
+    use super::{parse_addresses, Opts};
     use std::net::Ipv4Addr;
 
     #[test]
@@ -279,81 +318,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn parse_correct_host_addresses() {
-        let opts = Opts {
-            addresses: vec!["google.com".to_owned()],
-            ..Default::default()
-        };
-
-        let ips = parse_addresses(&opts);
-
-        assert_eq!(ips.len(), 1);
-    }
-
-    #[test]
-    fn parse_correct_and_incorrect_addresses() {
-        let opts = Opts {
-            addresses: vec!["127.0.0.1".to_owned(), "im_wrong".to_owned()],
-            ..Default::default()
-        };
-
-        let ips = parse_addresses(&opts);
-
-        assert_eq!(ips, [Ipv4Addr::new(127, 0, 0, 1),]);
-    }
-
-    #[test]
-    fn parse_incorrect_addresses() {
-        let opts = Opts {
-            addresses: vec!["im_wrong".to_owned(), "300.10.1.1".to_owned()],
-            ..Default::default()
-        };
-
-        let ips = parse_addresses(&opts);
-
-        assert!(ips.is_empty());
-    }
-
-    #[test]
-    fn parse_hosts_file_and_incorrect_hosts() {
-        // Host file contains IP, Hosts, incorrect IPs, incorrect hosts
-        let opts = Opts {
-            addresses: vec!["fixtures/hosts.txt".to_owned()],
-            ..Default::default()
-        };
-
-        let ips = parse_addresses(&opts);
-
-        assert_eq!(ips.len(), 3);
-    }
-
-    #[test]
-    fn parse_empty_hosts_file() {
-        // Host file contains IP, Hosts, incorrect IPs, incorrect hosts
-        let opts = Opts {
-            addresses: vec!["fixtures/empty_hosts.txt".to_owned()],
-            ..Default::default()
-        };
-
-        let ips = parse_addresses(&opts);
-
-        assert_eq!(ips.len(), 0);
-    }
-
-    #[test]
-    fn parse_naughty_host_file() {
-        // Host file contains IP, Hosts, incorrect IPs, incorrect hosts
-        let opts = Opts {
-            addresses: vec!["fixtures/naughty_string.txt".to_owned()],
-            ..Default::default()
-        };
-
-        let ips = parse_addresses(&opts);
-
-        assert_eq!(ips.len(), 0);
-    }
-
     #[test]
     fn parse_duplicate_cidrs() {
         let opts = Opts {
@@ -367,27 +331,15 @@ mod tests {
     }
 
     #[test]
-    fn resolver_default_cloudflare() {
-        let opts = Opts::default();
-
-        let resolver = get_resolver(&opts.resolver);
-        let lookup = resolver.lookup_ip("www.example.com.").unwrap();
-
-        assert!(opts.resolver.is_none());
-        assert!(lookup.iter().next().is_some());
-    }
-
-    #[test]
-    fn resolver_args_google_dns() {
-        // https://developers.google.com/speed/public-dns
+    fn parse_overspecific_cidr() {
+        // a canonical CIDR string has 0 in all host bits, but we want to treat any CIDR-like string as CIDR
         let opts = Opts {
-            resolver: Some("8.8.8.8,8.8.4.4".to_owned()),
+            addresses: vec!["192.128.1.1/24".to_owned()],
             ..Default::default()
         };
 
-        let resolver = get_resolver(&opts.resolver);
-        let lookup = resolver.lookup_ip("www.example.com.").unwrap();
+        let ips = parse_addresses(&opts);
 
-        assert!(lookup.iter().next().is_some());
+        assert_eq!(ips.len(), 256);
     }
 }

src/benchmark/mod.rs

@@ -42,13 +42,11 @@ impl Benchmark {
         let mut summary = String::from("\nRustScan Benchmark Summary");
 
         for timer in &self.named_timers {
-            if timer.start.is_some() && timer.end.is_some() {
-                let runtime_secs = timer
-                    .end
-                    .unwrap()
-                    .saturating_duration_since(timer.start.unwrap())
-                    .as_secs_f32();
-                summary.push_str(&format!("\n{0: <10} | {1: <10}s", timer.name, runtime_secs));
+            if let Some(start) = timer.start {
+                if let Some(end) = timer.end {
+                    let runtime_secs = end.saturating_duration_since(start).as_secs_f32();
+                    summary.push_str(&format!("\n{0: <10} | {1: <10}s", timer.name, runtime_secs));
+                }
             }
         }
         summary

src/input.rs

@@ -1,7 +1,6 @@
 //! Provides a means to read, parse and hold configuration options for scans.
 use clap::{Parser, ValueEnum};
 use serde_derive::Deserialize;
-use std::collections::HashMap;
 use std::fs;
 use std::path::PathBuf;
 
@@ -114,7 +113,7 @@ pub struct Opts {
     /// it will do every port at the same time. Although, your OS may not
     /// support this.
     #[arg(short, long, default_value = "4500")]
-    pub batch_size: u16,
+    pub batch_size: usize,
 
     /// The timeout in milliseconds before a port is assumed to be closed.
     #[arg(short, long, default_value = "1500")]
@@ -127,7 +126,7 @@ pub struct Opts {
 
     /// Automatically ups the ULIMIT with the value you provided.
     #[arg(short, long)]
-    pub ulimit: Option<u64>,
+    pub ulimit: Option<usize>,
 
     /// The order of scanning to be performed. The "serial" option will
     /// scan ports in ascending order while the "random" option will scan
@@ -201,7 +200,7 @@ impl Opts {
 
         merge_required!(
             addresses, greppable, accessible, batch_size, timeout, tries, scan_order, scripts,
-            command, udp
+            command, udp, no_banner
         );
     }
 
@@ -218,11 +217,7 @@ impl Opts {
 
         // Only use top ports when the user asks for them
         if self.top && config.ports.is_some() {
-            let mut ports: Vec<u16> = Vec::with_capacity(config.ports.as_ref().unwrap().len());
-            for entry in config.ports.as_ref().unwrap().keys() {
-                ports.push(entry.parse().unwrap());
-            }
-            self.ports = Some(ports);
+            self.ports = config.ports.clone();
         }
 
         merge_optional!(range, resolver, ulimit, exclude_ports, exclude_addresses);
@@ -263,14 +258,14 @@ impl Default for Opts {
 #[derive(Debug, Deserialize)]
 pub struct Config {
     addresses: Option<Vec<String>>,
-    ports: Option<HashMap<String, u16>>,
+    ports: Option<Vec<u16>>,
     range: Option<PortRange>,
     greppable: Option<bool>,
     accessible: Option<bool>,
-    batch_size: Option<u16>,
+    batch_size: Option<usize>,
     timeout: Option<u32>,
     tries: Option<u8>,
-    ulimit: Option<u64>,
+    ulimit: Option<usize>,
     resolver: Option<String>,
     scan_order: Option<ScanOrder>,
     command: Option<Vec<String>>,
@@ -278,6 +273,7 @@ pub struct Config {
     exclude_ports: Option<Vec<u16>>,
     exclude_addresses: Option<Vec<String>>,
     udp: Option<bool>,
+    no_banner: Option<bool>,
 }
 
 #[cfg(not(tarpaulin_include))]
@@ -298,7 +294,14 @@ impl Config {
     ///
     pub fn read(custom_config_path: Option<PathBuf>) -> Self {
         let mut content = String::new();
-        let config_path = custom_config_path.unwrap_or_else(default_config_path);
+        let config_path = custom_config_path.unwrap_or_else(|| {
+            let path = default_config_path();
+            match path.exists() {
+                true => path,
+                false => old_default_config_path(),
+            }
+        });
+
         if config_path.exists() {
             content = match fs::read_to_string(config_path) {
                 Ok(content) => content,
@@ -320,6 +323,15 @@ impl Config {
 
 /// Constructs default path to config toml
 pub fn default_config_path() -> PathBuf {
+    let Some(mut config_path) = dirs::config_dir() else {
+        panic!("Could not infer config file path.");
+    };
+    config_path.push(".rustscan.toml");
+    config_path
+}
+
+/// Returns the deprecated home directory config path used for backwards compatibility.
+pub fn old_default_config_path() -> PathBuf {
     let Some(mut config_path) = dirs::home_dir() else {
         panic!("Could not infer config file path.");
     };
@@ -353,6 +365,7 @@ mod tests {
                 exclude_ports: None,
                 exclude_addresses: None,
                 udp: Some(false),
+                no_banner: None,
             }
         }
     }

src/lib.rs

@@ -7,7 +7,9 @@
 //! [`Scanner`](crate::scanner::Scanner) which in turn requires a
 //! [`PortStrategy`](crate::port_strategy::PortStrategy):
 //!
-//! ```rust
+//! This example is compiled but never executed by the test suite.
+//!
+//! ```no_run
 //! use async_std::task::block_on;
 //! use std::{net::IpAddr, time::Duration};
 //!

src/main.rs

@@ -23,9 +23,9 @@ extern crate dirs;
 
 // Average value for Ubuntu
 #[cfg(unix)]
-const DEFAULT_FILE_DESCRIPTORS_LIMIT: u64 = 8000;
+const DEFAULT_FILE_DESCRIPTORS_LIMIT: usize = 8000;
 // Safest batch size based on experimentation
-const AVERAGE_BATCH_SIZE: u16 = 3000;
+const AVERAGE_BATCH_SIZE: usize = 3000;
 
 #[macro_use]
 extern crate log;
@@ -46,7 +46,7 @@ fn main() {
     let config = Config::read(opts.config_path.clone());
     opts.merge(&config);
 
-    debug!("Main() `opts` arguments are {:?}", opts);
+    debug!("Main() `opts` arguments are {opts:?}");
 
     let scripts_to_run: Vec<ScriptFile> = match init_scripts(&opts.scripts) {
         Ok(scripts_to_run) => scripts_to_run,
@@ -60,7 +60,7 @@ fn main() {
         }
     };
 
-    debug!("Scripts initialized {:?}", &scripts_to_run);
+    debug!("Scripts initialized {scripts_to_run:?}");
 
     if !opts.greppable && !opts.accessible && !opts.no_banner {
         print_opening(&opts);
@@ -78,10 +78,10 @@ fn main() {
     }
 
     #[cfg(unix)]
-    let batch_size: u16 = infer_batch_size(&opts, adjust_ulimit_size(&opts));
+    let batch_size: usize = infer_batch_size(&opts, adjust_ulimit_size(&opts));
 
     #[cfg(not(unix))]
-    let batch_size: u16 = AVERAGE_BATCH_SIZE;
+    let batch_size: usize = AVERAGE_BATCH_SIZE;
 
     let scanner = Scanner::new(
         &ips,
@@ -94,7 +94,7 @@ fn main() {
         opts.exclude_ports.unwrap_or_default(),
         opts.udp,
     );
-    debug!("Scanner finished building: {:?}", scanner);
+    debug!("Scanner finished building: {scanner:?}");
 
     let mut portscan_bench = NamedTimer::start("Portscan");
     let scan_result = block_on(scanner.run());
@@ -136,7 +136,7 @@ fn main() {
 
         // if option scripts is none, no script will be spawned
         if opts.greppable || opts.scripts == ScriptsRequired::None {
-            println!("{} -> [{}]", &ip, ports_str);
+            println!("{ip} -> [{ports_str}]");
             continue;
         }
         detail!("Starting Script(s)", opts.greppable, opts.accessible);
@@ -146,7 +146,7 @@ fn main() {
             // This part allows us to add commandline arguments to the Script call_format, appending them to the end of the command.
             if !opts.command.is_empty() {
                 let user_extra_args = &opts.command.join(" ");
-                debug!("Extra args vec {:?}", user_extra_args);
+                debug!("Extra args vec {user_extra_args:?}");
                 if script_f.call_format.is_some() {
                     let mut call_f = script_f.call_format.unwrap();
                     call_f.push(' ');
@@ -156,7 +156,7 @@ fn main() {
                         opts.greppable,
                         opts.accessible
                     );
-                    debug!("Call format {}", call_f);
+                    debug!("Call format {call_f}");
                     script_f.call_format = Some(call_f);
                 }
             }
@@ -173,7 +173,7 @@ fn main() {
             );
             match script.run() {
                 Ok(script_result) => {
-                    detail!(script_result.to_string(), opts.greppable, opts.accessible);
+                    detail!(script_result.clone(), opts.greppable, opts.accessible);
                 }
                 Err(e) => {
                     warning!(&format!("Error {e}"), opts.greppable, opts.accessible);
@@ -187,7 +187,7 @@ fn main() {
     benchmarks.push(script_bench);
     rustscan_bench.end();
     benchmarks.push(rustscan_bench);
-    debug!("Benchmarks raw {:?}", benchmarks);
+    debug!("Benchmarks raw {benchmarks:?}");
     info!("{}", benchmarks.summary());
 }
 
@@ -219,13 +219,26 @@ The Modern Day Port Scanner."#;
         opts.greppable,
         opts.accessible
     );
+
+    if opts.config_path.is_none() {
+        let old_config_path = input::old_default_config_path();
+        detail!(
+            format!(
+                "For backwards compatibility, the config file may also be at {old_config_path:?}"
+            ),
+            opts.greppable,
+            opts.accessible
+        );
+    }
 }
 
 #[cfg(unix)]
-fn adjust_ulimit_size(opts: &Opts) -> u64 {
+fn adjust_ulimit_size(opts: &Opts) -> usize {
     use rlimit::Resource;
+    use std::convert::TryInto;
 
     if let Some(limit) = opts.ulimit {
+        let limit = limit as u64;
         if Resource::NOFILE.set(limit, limit).is_ok() {
             detail!(
                 format!("Automatically increasing ulimit value to {limit}."),
@@ -242,14 +255,12 @@ fn adjust_ulimit_size(opts: &Opts) -> u64 {
     }
 
     let (soft, _) = Resource::NOFILE.get().unwrap();
-    soft
+    soft.try_into().unwrap_or(usize::MAX)
 }
 
 #[cfg(unix)]
-fn infer_batch_size(opts: &Opts, ulimit: u64) -> u16 {
-    use std::convert::TryInto;
-
-    let mut batch_size: u64 = opts.batch_size.into();
+fn infer_batch_size(opts: &Opts, ulimit: usize) -> usize {
+    let mut batch_size = opts.batch_size;
 
     // Adjust the batch size when the ulimit value is lower than the desired batch size
     if ulimit < batch_size {
@@ -260,7 +271,7 @@ fn infer_batch_size(opts: &Opts, ulimit: u64) -> u16 {
         // 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.into() {
+        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
@@ -269,7 +280,7 @@ fn infer_batch_size(opts: &Opts, ulimit: u64) -> u16 {
             batch_size = ulimit / 2;
         } else if ulimit > DEFAULT_FILE_DESCRIPTORS_LIMIT {
             info!("Batch size is now average batch size");
-            batch_size = AVERAGE_BATCH_SIZE.into();
+            batch_size = AVERAGE_BATCH_SIZE;
         } else {
             batch_size = ulimit - 100;
         }
@@ -282,8 +293,6 @@ fn infer_batch_size(opts: &Opts, ulimit: u64) -> u16 {
     }
 
     batch_size
-        .try_into()
-        .expect("Couldn't fit the batch size into a u16.")
 }
 
 #[cfg(test)]
@@ -313,7 +322,7 @@ mod tests {
         };
         let batch_size = infer_batch_size(&opts, 9_000);
 
-        assert!(batch_size == 3_000);
+        assert_eq!(batch_size, 3_000);
     }
     #[test]
     #[cfg(unix)]
@@ -326,7 +335,7 @@ mod tests {
         };
         let batch_size = infer_batch_size(&opts, 5_000);
 
-        assert!(batch_size == 4_900);
+        assert_eq!(batch_size, 4_900);
     }
     #[test]
     #[cfg(unix)]
@@ -339,7 +348,7 @@ mod tests {
         };
         let batch_size = adjust_ulimit_size(&opts);
 
-        assert!(batch_size == 2_000);
+        assert_eq!(batch_size, 2_000);
     }
 
     #[test]
@@ -353,7 +362,7 @@ mod tests {
 
         let batch_size = infer_batch_size(&opts, 1_000_000);
 
-        assert!(batch_size == opts.batch_size);
+        assert_eq!(batch_size, opts.batch_size);
     }
 
     #[test]

src/port_strategy/range_iterator.rs

@@ -1,5 +1,5 @@
 use gcd::Gcd;
-use rand::Rng;
+use rand::RngExt;
 use std::convert::TryInto;
 
 pub struct RangeIterator {

src/scanner/mod.rs

@@ -29,7 +29,7 @@ use std::{
 #[derive(Debug)]
 pub struct Scanner {
     ips: Vec<IpAddr>,
-    batch_size: u16,
+    batch_size: usize,
     timeout: Duration,
     tries: NonZeroU8,
     greppable: bool,
@@ -44,7 +44,7 @@ pub struct Scanner {
 impl Scanner {
     pub fn new(
         ips: &[IpAddr],
-        batch_size: u16,
+        batch_size: usize,
         timeout: Duration,
         tries: u8,
         greppable: bool,
@@ -94,7 +94,7 @@ impl Scanner {
         debug!("Start scanning sockets. \nBatch size {}\nNumber of ip-s {}\nNumber of ports {}\nTargets all together {} ",
             self.batch_size,
             self.ips.len(),
-            &ports.len(),
+            ports.len(),
             (self.ips.len() * ports.len()));
 
         while let Some(result) = ftrs.next().await {
@@ -112,8 +112,8 @@ impl Scanner {
                 }
             }
         }
-        debug!("Typical socket connection errors {:?}", errors);
-        debug!("Open Sockets found: {:?}", &open_sockets);
+        debug!("Typical socket connection errors {errors:?}");
+        debug!("Open Sockets found: {:?}", open_sockets);
         open_sockets
     }
 
@@ -144,16 +144,13 @@ impl Scanner {
         for nr_try in 1..=tries {
             match self.connect(socket).await {
                 Ok(tcp_stream) => {
-                    debug!(
-                        "Connection was successful, shutting down stream {}",
-                        &socket
-                    );
+                    debug!("Connection was successful, shutting down stream {}", socket);
                     if let Err(e) = tcp_stream.shutdown(Shutdown::Both) {
-                        debug!("Shutdown stream error {}", &e);
+                        debug!("Shutdown stream error {}", e);
                     }
                     self.fmt_ports(socket);
 
-                    debug!("Return Ok after {} tries", nr_try);
+                    debug!("Return Ok after {nr_try} tries");
                     return Ok(socket);
                 }
                 Err(e) => {
@@ -164,7 +161,7 @@ impl Scanner {
                     if nr_try == tries {
                         error_string.push(' ');
                         error_string.push_str(&socket.ip().to_string());
-                        return Err(io::Error::new(io::ErrorKind::Other, error_string));
+                        return Err(io::Error::other(error_string));
                     }
                 }
             };
@@ -193,10 +190,9 @@ impl Scanner {
             }
         }
 
-        Err(io::Error::new(
-            io::ErrorKind::Other,
-            format!("UDP scan timed-out for all tries on socket {}", socket),
-        ))
+        Err(io::Error::other(format!(
+            "UDP scan timed-out for all tries on socket {socket}"
+        )))
     }
 
     /// Performs the connection to the socket with timeout
@@ -275,7 +271,7 @@ impl Scanner {
 
                 match io::timeout(wait, udp_socket.recv(&mut buf)).await {
                     Ok(size) => {
-                        debug!("Received {} bytes", size);
+                        debug!("Received {size} bytes");
                         self.fmt_ports(socket);
                         Ok(true)
                     }
@@ -289,7 +285,7 @@ impl Scanner {
                 }
             }
             Err(e) => {
-                println!("Err E binding sock {:?}", e);
+                println!("Err E binding sock {e:?}");
                 Err(e)
             }
         }
@@ -306,222 +302,3 @@ impl Scanner {
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::input::{PortRange, ScanOrder};
-    use async_std::task::block_on;
-    use std::{net::IpAddr, time::Duration};
-
-    #[test]
-    fn scanner_runs() {
-        // Makes sure the program still runs and doesn't panic
-        let addrs = vec!["127.0.0.1".parse::<IpAddr>().unwrap()];
-        let range = PortRange {
-            start: 1,
-            end: 1_000,
-        };
-        let strategy = PortStrategy::pick(&Some(range), None, ScanOrder::Random);
-        let scanner = Scanner::new(
-            &addrs,
-            10,
-            Duration::from_millis(100),
-            1,
-            true,
-            strategy,
-            true,
-            vec![9000],
-            false,
-        );
-        block_on(scanner.run());
-        // if the scan fails, it wouldn't be able to assert_eq! as it panicked!
-        assert_eq!(1, 1);
-    }
-    #[test]
-    fn ipv6_scanner_runs() {
-        // Makes sure the program still runs and doesn't panic
-        let addrs = vec!["::1".parse::<IpAddr>().unwrap()];
-        let range = PortRange {
-            start: 1,
-            end: 1_000,
-        };
-        let strategy = PortStrategy::pick(&Some(range), None, ScanOrder::Random);
-        let scanner = Scanner::new(
-            &addrs,
-            10,
-            Duration::from_millis(100),
-            1,
-            true,
-            strategy,
-            true,
-            vec![9000],
-            false,
-        );
-        block_on(scanner.run());
-        // if the scan fails, it wouldn't be able to assert_eq! as it panicked!
-        assert_eq!(1, 1);
-    }
-    #[test]
-    fn quad_zero_scanner_runs() {
-        let addrs = vec!["0.0.0.0".parse::<IpAddr>().unwrap()];
-        let range = PortRange {
-            start: 1,
-            end: 1_000,
-        };
-        let strategy = PortStrategy::pick(&Some(range), None, ScanOrder::Random);
-        let scanner = Scanner::new(
-            &addrs,
-            10,
-            Duration::from_millis(100),
-            1,
-            true,
-            strategy,
-            true,
-            vec![9000],
-            false,
-        );
-        block_on(scanner.run());
-        assert_eq!(1, 1);
-    }
-    #[test]
-    fn google_dns_runs() {
-        let addrs = vec!["8.8.8.8".parse::<IpAddr>().unwrap()];
-        let range = PortRange {
-            start: 400,
-            end: 445,
-        };
-        let strategy = PortStrategy::pick(&Some(range), None, ScanOrder::Random);
-        let scanner = Scanner::new(
-            &addrs,
-            10,
-            Duration::from_millis(100),
-            1,
-            true,
-            strategy,
-            true,
-            vec![9000],
-            false,
-        );
-        block_on(scanner.run());
-        assert_eq!(1, 1);
-    }
-    #[test]
-    fn infer_ulimit_lowering_no_panic() {
-        // Test behaviour on MacOS where ulimit is not automatically lowered
-        let addrs = vec!["8.8.8.8".parse::<IpAddr>().unwrap()];
-
-        // mac should have this automatically scaled down
-        let range = PortRange {
-            start: 400,
-            end: 600,
-        };
-        let strategy = PortStrategy::pick(&Some(range), None, ScanOrder::Random);
-        let scanner = Scanner::new(
-            &addrs,
-            10,
-            Duration::from_millis(100),
-            1,
-            true,
-            strategy,
-            true,
-            vec![9000],
-            false,
-        );
-        block_on(scanner.run());
-        assert_eq!(1, 1);
-    }
-
-    #[test]
-    fn udp_scan_runs() {
-        // Makes sure the program still runs and doesn't panic
-        let addrs = vec!["127.0.0.1".parse::<IpAddr>().unwrap()];
-        let range = PortRange {
-            start: 1,
-            end: 1_000,
-        };
-        let strategy = PortStrategy::pick(&Some(range), None, ScanOrder::Random);
-        let scanner = Scanner::new(
-            &addrs,
-            10,
-            Duration::from_millis(100),
-            1,
-            true,
-            strategy,
-            true,
-            vec![9000],
-            true,
-        );
-        block_on(scanner.run());
-        // if the scan fails, it wouldn't be able to assert_eq! as it panicked!
-        assert_eq!(1, 1);
-    }
-    #[test]
-    fn udp_ipv6_runs() {
-        // Makes sure the program still runs and doesn't panic
-        let addrs = vec!["::1".parse::<IpAddr>().unwrap()];
-        let range = PortRange {
-            start: 1,
-            end: 1_000,
-        };
-        let strategy = PortStrategy::pick(&Some(range), None, ScanOrder::Random);
-        let scanner = Scanner::new(
-            &addrs,
-            10,
-            Duration::from_millis(100),
-            1,
-            true,
-            strategy,
-            true,
-            vec![9000],
-            true,
-        );
-        block_on(scanner.run());
-        // if the scan fails, it wouldn't be able to assert_eq! as it panicked!
-        assert_eq!(1, 1);
-    }
-    #[test]
-    fn udp_quad_zero_scanner_runs() {
-        let addrs = vec!["0.0.0.0".parse::<IpAddr>().unwrap()];
-        let range = PortRange {
-            start: 1,
-            end: 1_000,
-        };
-        let strategy = PortStrategy::pick(&Some(range), None, ScanOrder::Random);
-        let scanner = Scanner::new(
-            &addrs,
-            10,
-            Duration::from_millis(100),
-            1,
-            true,
-            strategy,
-            true,
-            vec![9000],
-            true,
-        );
-        block_on(scanner.run());
-        assert_eq!(1, 1);
-    }
-    #[test]
-    fn udp_google_dns_runs() {
-        let addrs = vec!["8.8.8.8".parse::<IpAddr>().unwrap()];
-        let range = PortRange {
-            start: 100,
-            end: 150,
-        };
-        let strategy = PortStrategy::pick(&Some(range), None, ScanOrder::Random);
-        let scanner = Scanner::new(
-            &addrs,
-            10,
-            Duration::from_millis(100),
-            1,
-            true,
-            strategy,
-            true,
-            vec![9000],
-            true,
-        );
-        block_on(scanner.run());
-        assert_eq!(1, 1);
-    }
-}

src/scripts/mod.rs

@@ -46,12 +46,9 @@
 //!
 //! - `fixtures/test_rustscan_scripts.toml`
 //!
-//! Script file examples:
+//! Metadata-only test fixture:
 //!
-//! - `fixtures/test_script.py`
-//! - `fixtures/test_script.pl`
-//! - `fixtures/test_script.sh`
-//! - `fixtures/test_script.txt`
+//! - `fixtures/.rustscan_scripts/test_script.txt`
 //!
 //! `call_format` in script files can be of 2 variants:
 //!
@@ -108,16 +105,20 @@ pub fn init_scripts(scripts: &ScriptsRequired) -> Result<Vec<ScriptFile>> {
             scripts_to_run.push(default_script);
         }
         ScriptsRequired::Custom => {
-            let scripts_dir_base =
-                dirs::home_dir().ok_or_else(|| anyhow!("Could not infer scripts path."))?;
-            let script_paths = find_scripts(scripts_dir_base)?;
-            debug!("Scripts paths \n{:?}", script_paths);
+            let script_config = ScriptConfig::read_config()?;
+            debug!("Script config \n{script_config:?}");
+
+            let script_dir_base = if let Some(config_directory) = &script_config.directory {
+                PathBuf::from(config_directory)
+            } else {
+                dirs::home_dir().ok_or_else(|| anyhow!("Could not infer scripts path."))?
+            };
+
+            let script_paths = find_scripts(script_dir_base)?;
+            debug!("Scripts paths \n{script_paths:?}");
 
             let parsed_scripts = parse_scripts(script_paths);
-            debug!("Scripts parsed \n{:?}", parsed_scripts);
-
-            let script_config = ScriptConfig::read_config()?;
-            debug!("Script config \n{:?}", script_config);
+            debug!("Scripts parsed \n{parsed_scripts:?}");
 
             // Only Scripts that contain all the tags found in ScriptConfig will be selected.
             if let Some(config_hashset) = script_config.tags {
@@ -131,14 +132,14 @@ pub fn init_scripts(scripts: &ScriptsRequired) -> Result<Vec<ScriptFile>> {
                         } else {
                             debug!(
                                 "\nScript tags does not match config tags {:?} {}",
-                                &script_hashset,
+                                script_hashset,
                                 script.path.unwrap().display()
                             );
                         }
                     }
                 }
             }
-            debug!("\nScript(s) to run {:?}", scripts_to_run);
+            debug!("\nScript(s) to run {scripts_to_run:?}");
         }
     }
 
@@ -148,7 +149,7 @@ pub fn init_scripts(scripts: &ScriptsRequired) -> Result<Vec<ScriptFile>> {
 pub fn parse_scripts(scripts: Vec<PathBuf>) -> Vec<ScriptFile> {
     let mut parsed_scripts: Vec<ScriptFile> = Vec::with_capacity(scripts.len());
     for script in scripts {
-        debug!("Parsing script {}", &script.display());
+        debug!("Parsing script {}", script.display());
         if let Some(script_file) = ScriptFile::new(script) {
             parsed_scripts.push(script_file);
         }
@@ -220,7 +221,7 @@ impl Script {
     // Some variables get changed before read, and compiler throws warning on warn(unused_assignments)
     #[allow(unused_assignments)]
     pub fn run(self) -> Result<String> {
-        debug!("run self {:?}", &self);
+        debug!("run self {:?}", self);
 
         let separator = self.ports_separator.unwrap_or_else(|| ",".into());
 
@@ -265,14 +266,14 @@ impl Script {
             };
             to_run = default_template.fill_with_struct(&exec_parts)?;
         }
-        debug!("\nScript format to run {}", to_run);
+        debug!("\nScript format to run {to_run}");
         execute_script(&to_run)
     }
 }
 
 #[cfg(not(tarpaulin_include))]
 fn execute_script(script: &str) -> Result<String> {
-    debug!("\nScript arguments {}", script);
+    debug!("\nScript arguments {script}");
 
     let (cmd, arg) = if cfg!(unix) {
         ("sh", "-c")
@@ -310,16 +311,15 @@ fn execute_script(script: &str) -> Result<String> {
             Ok(String::from_utf8_lossy(&output.stdout).into_owned())
         }
         Err(error) => {
-            debug!("Command error {}", error.to_string());
+            debug!("Command error {error}",);
             Err(anyhow!(error.to_string()))
         }
     }
 }
 
-pub fn find_scripts(mut path: PathBuf) -> Result<Vec<PathBuf>> {
-    path.push(".rustscan_scripts");
+pub fn find_scripts(path: PathBuf) -> Result<Vec<PathBuf>> {
     if path.is_dir() {
-        debug!("Scripts folder found {}", &path.display());
+        debug!("Scripts folder found {}", path.display());
         let mut files_vec: Vec<PathBuf> = Vec::new();
         for entry in fs::read_dir(path)? {
             let entry = entry?;
@@ -357,20 +357,20 @@ impl ScriptFile {
                 }
             }
         } else {
-            debug!("Failed to read file: {}", &real_path.display());
+            debug!("Failed to read file: {}", real_path.display());
             return None;
         }
-        debug!("ScriptFile {} lines\n{}", &real_path.display(), &lines_buf);
+        debug!("ScriptFile {} lines\n{}", real_path.display(), lines_buf);
 
         match toml::from_str::<ScriptFile>(&lines_buf) {
             Ok(mut parsed) => {
-                debug!("Parsed ScriptFile{} \n{:?}", &real_path.display(), &parsed);
+                debug!("Parsed ScriptFile{} \n{:?}", real_path.display(), parsed);
                 parsed.path = Some(real_path);
                 // parsed_scripts.push(parsed);
                 Some(parsed)
             }
             Err(e) => {
-                debug!("Failed to parse ScriptFile headers {}", e.to_string());
+                debug!("Failed to parse ScriptFile headers {e}");
                 None
             }
         }
@@ -382,6 +382,7 @@ pub struct ScriptConfig {
     pub tags: Option<Vec<String>>,
     pub ports: Option<Vec<String>>,
     pub developer: Option<Vec<String>>,
+    pub directory: Option<String>,
 }
 
 #[cfg(not(tarpaulin_include))]
@@ -400,27 +401,13 @@ impl ScriptConfig {
 
 #[cfg(test)]
 mod tests {
-    use super::{find_scripts, parse_scripts, Script, ScriptFile};
-
-    // Function for testing only, it inserts static values into ip and open_ports
-    // Doesn't use impl in case it's implemented in the super module at some point
-    fn into_script(script_f: ScriptFile) -> Script {
-        Script::build(
-            script_f.path,
-            "127.0.0.1".parse().unwrap(),
-            vec![80, 8080],
-            script_f.port,
-            script_f.ports_separator,
-            script_f.tags,
-            script_f.call_format,
-        )
-    }
+    use super::*;
 
     #[test]
     fn find_and_parse_scripts() {
-        let scripts = find_scripts("fixtures/".into()).unwrap();
+        let scripts = find_scripts("fixtures/.rustscan_scripts".into()).unwrap();
         let scripts = parse_scripts(scripts);
-        assert_eq!(scripts.len(), 4);
+        assert_eq!(scripts.len(), 1);
     }
 
     #[test]
@@ -436,26 +423,6 @@ mod tests {
             .unwrap();
     }
 
-    #[test]
-    #[should_panic]
-    fn open_script_file_invalid_call_format() {
-        let mut script_f =
-            ScriptFile::new("fixtures/.rustscan_scripts/test_script.txt".into()).unwrap();
-        script_f.call_format = Some("qwertyuiop".to_string());
-        let script: Script = into_script(script_f);
-        let _output = script.run().unwrap();
-    }
-
-    #[test]
-    #[should_panic]
-    fn open_script_file_missing_call_format() {
-        let mut script_f =
-            ScriptFile::new("fixtures/.rustscan_scripts/test_script.txt".into()).unwrap();
-        script_f.call_format = None;
-        let script: Script = into_script(script_f);
-        let _output = script.run().unwrap();
-    }
-
     #[test]
     #[should_panic]
     fn open_nonexisting_script_file() {
@@ -480,39 +447,52 @@ mod tests {
         assert_eq!(script_f.ports_separator, Some(",".to_string()));
         assert_eq!(
             script_f.call_format,
-            Some("nmap -vvv -p {{port}} {{ip}}".to_string())
+            Some("fixture {{ip}} {{port}}".to_string())
         );
     }
 
     #[test]
-    #[cfg(unix)]
-    fn run_bash_script() {
-        let script_f = ScriptFile::new("fixtures/.rustscan_scripts/test_script.sh".into()).unwrap();
-        let script: Script = into_script(script_f);
-        let output = script.run().unwrap();
-        // output has a newline at the end by default, .trim() trims it
-        assert_eq!(output.trim(), "127.0.0.1 80,8080");
-    }
+    fn test_custom_directory_config() {
+        // Create test config
+        let config_str = r#"
+            tags = ["core_approved", "example"]
+            directory = "fixtures/.rustscan_scripts"
+        "#;
 
-    #[test]
-    fn run_python_script() {
-        let script_f = ScriptFile::new("fixtures/.rustscan_scripts/test_script.py".into()).unwrap();
-        let script: Script = into_script(script_f);
-        let output = script.run().unwrap();
-        // output has a newline at the end by default, .trim() trims it
+        let config: ScriptConfig = toml::from_str(config_str).unwrap();
         assert_eq!(
-            output.trim(),
-            "Python script ran with arguments ['fixtures/.rustscan_scripts/test_script.py', '127.0.0.1', '80,8080']"
+            config.directory,
+            Some("fixtures/.rustscan_scripts".to_string())
         );
+
+        // Test that the directory is actually used
+        let script_dir_base = PathBuf::from(config.directory.unwrap());
+        let scripts = find_scripts(script_dir_base).unwrap();
+
+        // Verify we found the test script
+        assert!(scripts.iter().any(|p| p
+            .file_name()
+            .and_then(|f| f.to_str())
+            .map(|s| s == "test_script.txt")
+            .unwrap_or(false)));
     }
 
     #[test]
-    #[cfg(unix)]
-    fn run_perl_script() {
-        let script_f = ScriptFile::new("fixtures/.rustscan_scripts/test_script.pl".into()).unwrap();
-        let script: Script = into_script(script_f);
-        let output = script.run().unwrap();
-        // output has a newline at the end by default, .trim() trims it
-        assert_eq!(output.trim(), "Total args passed to fixtures/.rustscan_scripts/test_script.pl : 2\nArg # 1 : 127.0.0.1\nArg # 2 : 80,8080");
+    fn test_default_directory_fallback() {
+        let config_str = r#"
+            tags = ["core_approved", "example"]
+        "#;
+
+        let config: ScriptConfig = toml::from_str(config_str).unwrap();
+        assert_eq!(config.directory, None);
+
+        // Test fallback to home directory
+        let script_dir_base = if let Some(config_directory) = &config.directory {
+            PathBuf::from(config_directory)
+        } else {
+            dirs::home_dir().unwrap()
+        };
+
+        assert_eq!(script_dir_base, dirs::home_dir().unwrap());
     }
 }

src/tui.rs

@@ -43,7 +43,7 @@ macro_rules! output {
     ($name:expr) => {
         println!(
             "{} {}",
-            RGansi_term::Colour::RGB(0, 255, 9).bold().paint("[>]"),
+            ansi_term::Colour::RGB(0, 255, 9).bold().paint("[>]"),
             $name
         );
     };
@@ -97,6 +97,7 @@ macro_rules! funny_opening {
             "RustScan: Exploring the digital landscape, one IP at a time.",
             "TreadStone was here 🚀",
             "With RustScan, I scan ports so fast, even my firewall gets whiplash 💨",
+            "Scanning ports so fast, even the internet got a speeding ticket!",
         ];
         let random_quote = quotes.choose(&mut rand::rng()).unwrap();
 

tests/timelimits.rs

@@ -1,163 +0,0 @@
-/*
- * Test rustscan against different targets with a time limit.
- * The tests assumes target/debug/rustscan has already been built.
- *
- * The tests are #[ignore] to avoid running them during normal development.
- *
- * Their tests in the timelimits module are run by travis during CI.
- */
-
-use std::process::Command;
-use std::time::Duration;
-use wait_timeout::ChildExt;
-
-const TIMEOUT_MARGIN: u32 = 3;
-
-#[cfg(not(tarpaulin_include))]
-fn run_rustscan_with_timeout(args: &[&str], timeout: Duration) {
-    println!("Running: target/debug/rustscan: {}", args.join(" "));
-
-    use std::time::Instant;
-
-    let start = Instant::now();
-
-    let mut child = Command::new("target/debug/rustscan")
-        .args(args)
-        .spawn()
-        .unwrap();
-
-    let mut tries = TIMEOUT_MARGIN;
-    loop {
-        match child.wait_timeout(timeout).unwrap() {
-            Some(_status) => break,
-            None => {
-                tries -= 1;
-                if tries == 0 {
-                    // child hasn't exited yet
-                    child.kill().unwrap();
-                    child.wait().unwrap().code().unwrap();
-                    panic!("Timeout while running command");
-                }
-            }
-        }
-    }
-    let end = Instant::now();
-    let duration = end.saturating_duration_since(start).as_secs_f32();
-
-    println!("time: {:1.1}s", duration);
-}
-
-mod timelimits {
-
-    #[test]
-    #[ignore]
-    fn scan_localhost() {
-        let timeout = super::Duration::from_secs(25);
-        super::run_rustscan_with_timeout(&["--greppable", "--no-nmap", "127.0.0.1"], timeout);
-    }
-
-    #[test]
-    #[ignore]
-    fn scan_google_com() {
-        super::run_rustscan_with_timeout(
-            &[
-                "--greppable",
-                "--no-nmap",
-                "-u",
-                "5000",
-                "-b",
-                "2500",
-                "google.com",
-            ],
-            super::Duration::from_secs(28),
-        );
-    }
-
-    #[test]
-    #[ignore]
-    fn scan_example_com() {
-        super::run_rustscan_with_timeout(
-            &[
-                "--greppable",
-                "--no-nmap",
-                "-u",
-                "5000",
-                "-b",
-                "2500",
-                "example.com",
-            ],
-            super::Duration::from_secs(28),
-        );
-    }
-
-    #[test]
-    #[ignore]
-    fn scan_rustscan_cmnatic_co_uk() {
-        super::run_rustscan_with_timeout(
-            &[
-                "--greppable",
-                "--no-nmap",
-                "-u",
-                "5000",
-                "-b",
-                "2500",
-                "rustscan.cmnatic.co.uk",
-            ],
-            super::Duration::from_secs(26),
-        );
-    }
-    #[test]
-    #[ignore]
-    fn udp_scan_localhost() {
-        let timeout = super::Duration::from_secs(25);
-        super::run_rustscan_with_timeout(&["--greppable", "127.0.0.1", "--udp"], timeout);
-    }
-    #[test]
-    #[ignore]
-    fn udp_scan_google_com() {
-        super::run_rustscan_with_timeout(
-            &[
-                "--udp",
-                "--greppable",
-                "-u",
-                "5000",
-                "-b",
-                "2500",
-                "google.com",
-            ],
-            super::Duration::from_secs(28),
-        );
-    }
-    #[test]
-    #[ignore]
-    fn udp_scan_example_com() {
-        super::run_rustscan_with_timeout(
-            &[
-                "--udp",
-                "--greppable",
-                "-u",
-                "5000",
-                "-b",
-                "2500",
-                "example.com",
-            ],
-            super::Duration::from_secs(28),
-        );
-    }
-    #[test]
-    #[ignore]
-    fn udp_scan_rustscan_cmnatic_co_uk() {
-        super::run_rustscan_with_timeout(
-            &[
-                "--udp",
-                "--greppable",
-                "-u",
-                "5000",
-                "-b",
-                "2500",
-                "rustscan.cmnatic.co.uk",
-            ],
-            super::Duration::from_secs(26),
-        );
-    }
-}