test: remove network scans and external script execution

2026-11-10 09:21:25 -10:00 · 2026-10-01 17:39:16 +09:00
29 changed files with 460 additions and 1749 deletions
@@ -1,22 +1,13 @@
 name: CD Pipeline

-on:
-  push:
-    branches:
-      - "master"
-    tags:
-      - "*"
-
-# Build jobs only need to read the repository. The publish job below is the
-# only job that gets write access, and it only runs for tag pushes.
-permissions:
-  contents: read
+on: [push]

 jobs:
  build-nix:
    env:
      IN_PIPELINE: true
    runs-on: ${{ matrix.os }}
+    if: github.ref == 'refs/heads/master'
    strategy:
      matrix:
        type: [ubuntu-x64, ubuntu-x86, armv7, aarch64]
@@ -48,23 +39,28 @@ jobs:
    steps:
      - uses: actions/checkout@v7
      - name: Cache cargo & target directories
-        uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2
+        uses: Swatinem/rust-cache@v2
      - name: Build binary
-        uses: houseabsolute/actions-rust-cross@21b0f18dc621b25bfae556ff2791fca4173121e8 # v1.0.8
+        uses: houseabsolute/actions-rust-cross@v1
        with:
          command: build
          target: ${{ matrix.target }}
          args: "--locked --release"
          strip: true
          toolchain: stable
-      - name: Package and upload artifacts
-        uses: houseabsolute/actions-rust-release@9e126fd5fc18f4cecf358b3909f3991ad59663dc # v1.0.1
+      - name: Build tar.gz for homebrew installs
+        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@v7
        with:
-          executable-name: rustscan
-          target: ${{ matrix.target }}
-          archive-name: ${{ matrix.name }}
-          changes-file: ""
-
+          name: ${{ matrix.name }}
+          path: ${{ matrix.path }}
+      - uses: actions/upload-artifact@v7
+        if: matrix.type == 'ubuntu-x64'
+        with:
+          name: ${{ matrix.name }}.tar.gz
+          path: ${{ matrix.name }}.tar.gz
  build-deb:
    needs: [build-nix]
    runs-on: ubuntu-latest
@@ -74,7 +70,7 @@ jobs:
      - uses: actions/checkout@v7
      - name: Install cargo-deb
        run: cargo install -f cargo-deb
-      - uses: awalsh128/cache-apt-pkgs-action@553a35bb8ebd9fcabcb1c9451aa4c98e1b4ca8a9 # v1.6.3
+      - uses: awalsh128/cache-apt-pkgs-action@v1
        with:
          packages: musl-tools # provides musl-gcc
          version: 1.0
@@ -92,54 +88,65 @@ jobs:
    env:
      IN_PIPELINE: true
    runs-on: macos-latest
+    if: github.ref == 'refs/heads/master'
    steps:
      - uses: actions/checkout@v7
      - name: Cache cargo & target directories
-        uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2
+        uses: Swatinem/rust-cache@v2
      - name: Build binary
-        uses: houseabsolute/actions-rust-cross@21b0f18dc621b25bfae556ff2791fca4173121e8 # v1.0.8
+        uses: houseabsolute/actions-rust-cross@v1
        with:
          command: build
          target: x86_64-apple-darwin
          args: "--locked --release"
          strip: true
          toolchain: stable
-      - name: Package and upload artifacts
-        uses: houseabsolute/actions-rust-release@9e126fd5fc18f4cecf358b3909f3991ad59663dc # v1.0.1
+      - 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@v7
        with:
-          executable-name: rustscan
-          target: x86_64-apple-darwin
-          archive-name: x86_64-macos-rustscan
-          changes-file: ""
-
+          name: x86_64-macos-rustscan
+          path: target/x86_64-apple-darwin/release/rustscan
+      - uses: actions/upload-artifact@v7
+        with:
+          name: x86_64-macos-rustscan.tar.gz
+          path: x86_64-macos-rustscan.tar.gz
+  
  build-macos-aarch64:
    env:
      IN_PIPELINE: true
    runs-on: macos-latest
+    if: github.ref == 'refs/heads/master'
    steps:
      - uses: actions/checkout@v7
      - name: Cache cargo & target directories
-        uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2
+        uses: Swatinem/rust-cache@v2
      - name: Build binary
-        uses: houseabsolute/actions-rust-cross@21b0f18dc621b25bfae556ff2791fca4173121e8 # v1.0.8
+        uses: houseabsolute/actions-rust-cross@v1
        with:
          command: build
          target: aarch64-apple-darwin
          args: "--locked --release"
          strip: true
          toolchain: stable
-      - name: Package and upload artifacts
-        uses: houseabsolute/actions-rust-release@9e126fd5fc18f4cecf358b3909f3991ad59663dc # v1.0.1
+      - 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@v7
        with:
-          executable-name: rustscan
-          target: aarch64-apple-darwin
-          archive-name: aarch64-macos-rustscan
-          changes-file: ""
+          name: aarch64-macos-rustscan
+          path: target/aarch64-apple-darwin/release/rustscan
+      - uses: actions/upload-artifact@v7
+        with:
+          name: aarch64-macos-rustscan.tar.gz
+          path: aarch64-macos-rustscan.tar.gz

  build-windows:
    env:
      IN_PIPELINE: true
    runs-on: ${{ matrix.os }}
+    if: github.ref == 'refs/heads/master'
    strategy:
      matrix:
        type: [windows-x64, windows-x86]
@@ -147,55 +154,26 @@ jobs:
          - type: windows-x64
            os: windows-latest
            target: x86_64-pc-windows-msvc
-            name: x86_64-windows-rustscan
+            name: x86_64-windows-rustscan.exe
+            path: target\x86_64-pc-windows-msvc\release\rustscan.exe
          - type: windows-x86
            os: windows-latest
            target: i686-pc-windows-msvc
-            name: x86-windows-rustscan
+            name: x86-windows-rustscan.exe
+            path: target\i686-pc-windows-msvc\release\rustscan.exe
    steps:
      - uses: actions/checkout@v7
      - name: Cache cargo & target directories
-        uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2
+        uses: Swatinem/rust-cache@v2
      - name: Build binary
-        uses: houseabsolute/actions-rust-cross@21b0f18dc621b25bfae556ff2791fca4173121e8 # v1.0.8
+        uses: houseabsolute/actions-rust-cross@v1
        with:
          command: build
-          target: ${{ matrix.target }}
+          target:  ${{ matrix.target }}
          args: "--locked --release"
          strip: true
          toolchain: stable
-      - name: Package and upload artifacts
-        uses: houseabsolute/actions-rust-release@9e126fd5fc18f4cecf358b3909f3991ad59663dc # v1.0.1
+      - uses: actions/upload-artifact@v7
        with:
-          executable-name: rustscan
-          target: ${{ matrix.target }}
-          archive-name: ${{ matrix.name }}
-          changes-file: ""
-
-  # Runs only for tag pushes (tags can only be created by maintainers), and
-  # only after every build job succeeded, so a release never ships partially.
-  publish:
-    if: github.ref_type == 'tag'
-    needs:
-      - build-nix
-      - build-deb
-      - build-macos
-      - build-macos-aarch64
-      - build-windows
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write # create the release / upload release assets
-    steps:
-      - name: Download build artifacts
-        uses: actions/download-artifact@v8
-        with:
-          merge-multiple: true
-      - name: Publish artifacts to GitHub release
-        uses: softprops/action-gh-release@efb35369e0ad2afab669f228072c1b0d510eae64 # v3.0.3
-        with:
-          fail_on_unmatched_files: true
-          files: |
-            *.deb
-            *.sha256
-            *.tar.gz
-            *.zip
+          name: ${{ matrix.name }}
+          path: ${{ matrix.path }}
@@ -0,0 +1,14 @@
+name: Dependabot Auto-Merge
+
+jobs:
+  dependabot:
+    runs-on: ubuntu-latest
+    if: ${{ github.actor == 'dependabot[bot]' }}
+    steps:
+      - name: Enable auto-merge for Dependabot PRs
+        run: |
+          gh pr review --approve "$PR_URL"
+          gh pr merge --auto --merge "$PR_URL"
+        env:
+          PR_URL: ${{ github.event.pull_request.html_url }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -1,39 +1,28 @@
 name: Test
-
 on:
  pull_request:
    branches: [master]
  push:
    branches:
      - master
-
-permissions:
-  contents: read
-
 jobs:
  test:
    name: Test Suite
    strategy:
      matrix:
-        # ubuntu-24.04-arm is the GitHub-hosted arm64 Linux runner;
-        # macos-latest already runs on Apple Silicon (arm64).
-        os: [ubuntu-latest, ubuntu-24.04-arm, macos-latest, windows-latest]
+        os: [ubuntu-latest, macos-latest, windows-latest]
        rust: [stable]
    runs-on: ${{ matrix.os }}
-
    steps:
      - name: Checkout sources
        uses: actions/checkout@v7

-      - name: Setup Rust
-        uses: actions-rust-lang/setup-rust-toolchain@166cdcfd11aee3cb47222f9ddb555ce30ddb9659 # v1.17.0
+      - name: Install stable toolchain
+        uses: actions-rs/toolchain@v1
        with:
+          profile: minimal
          toolchain: ${{ matrix.rust }}
-          components: clippy, rustfmt
-          # Caching is handled by Swatinem/rust-cache below.
-          cache: false
-          # Keep RUSTFLAGS unset; `just test` already denies Clippy warnings.
-          rustflags: ""
+          override: true

      - uses: taiki-e/install-action@nextest
      - uses: Swatinem/rust-cache@v2
@@ -41,5 +30,5 @@ jobs:
      - name: Install Just
        uses: extractions/setup-just@v4

-      - name: Run tests
+      - name: Run just
        run: just test
@@ -18,6 +18,10 @@ script:
 - cargo build
 - cargo test
 - 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 ] &&
@@ -239,7 +239,7 @@ checksum = "644dd749086bf3771a2fbc5f256fdb982d53f011c7d5d560304eafeecebce79d"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.117",
+ "syn",
 ]

 [[package]]
@@ -390,9 +390,9 @@ dependencies = [

 [[package]]
 name = "clap"
-version = "4.6.7"
+version = "4.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aa8876b300ab35ba921adea3dfd70157a46249b33f95c9084ae5709785478946"
+checksum = "dd059f9da4f5c36b3787f65d38ccaab1cc315f07b01f89abc8359ee6a8205011"
 dependencies = [
 "clap_builder",
 "clap_derive",
@@ -400,9 +400,9 @@ dependencies = [

 [[package]]
 name = "clap_builder"
-version = "4.6.7"
+version = "4.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec0797fb7aeb1406c84efac526901f7ec3ead2124f946b494e72879d4b54704d"
+checksum = "f09628afdcc538b57f3c6341e9c8e9970f18e4a481690a64974d7023bd33548b"
 dependencies = [
 "anstream",
 "anstyle",
@@ -413,14 +413,14 @@ dependencies = [

 [[package]]
 name = "clap_derive"
-version = "4.6.7"
+version = "4.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f9c751b79415d4e559e3d1fcf128e09e720eb673a06d26cf6f392d37d75b66e0"
+checksum = "f2ce8604710f6733aa641a2b3731eaa1e8b3d9973d5e3565da11800813f997a9"
 dependencies = [
 "heck",
 "proc-macro2",
 "quote",
- "syn 3.0.6",
+ "syn",
 ]

 [[package]]
@@ -569,7 +569,7 @@ checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.117",
+ "syn",
 ]

 [[package]]
@@ -587,7 +587,7 @@ dependencies = [
 "heck",
 "proc-macro2",
 "quote",
- "syn 2.0.117",
+ "syn",
 ]

 [[package]]
@@ -746,7 +746,7 @@ checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.117",
+ "syn",
 ]

 [[package]]
@@ -1056,7 +1056,7 @@ checksum = "1ec89e9337638ecdc08744df490b221a7399bf8d164eb52a665454e60e075ad6"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.117",
+ "syn",
 ]

 [[package]]
@@ -1177,7 +1177,7 @@ checksum = "2a8c8b344124222efd714b73bb41f8b5120b27a7cc1c75593a6ff768d9d05aa4"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.117",
+ "syn",
 ]

 [[package]]
@@ -1388,7 +1388,7 @@ dependencies = [
 "indexmap 1.9.3",
 "proc-macro2",
 "quote",
- "syn 2.0.117",
+ "syn",
 ]

 [[package]]
@@ -1523,7 +1523,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6837b9e10d61f45f987d50808f83d1ee3d206c66acf650c3e4ae2e1f6ddedf55"
 dependencies = [
 "proc-macro2",
- "syn 2.0.117",
+ "syn",
 ]

 [[package]]
@@ -1569,9 +1569,9 @@ dependencies = [

 [[package]]
 name = "rand"
-version = "0.10.3"
+version = "0.10.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "65c9fb96cbc91e3478eaae79a69fcd3f1ae4ad052e471fe6732fff548984b4af"
+checksum = "c7f5fa3a058cd35567ef9bfa5e75732bee0f9e4c55fa90477bef2dfcdbc4be80"
 dependencies = [
 "chacha20",
 "getrandom 0.4.1",
@@ -1790,7 +1790,7 @@ dependencies = [
 "log",
 "once_cell",
 "parameterized",
- "rand 0.10.3",
+ "rand 0.10.2",
 "rlimit",
 "serde",
 "serde_derive",
@@ -1868,7 +1868,7 @@ checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.117",
+ "syn",
 ]

 [[package]]
@@ -1946,17 +1946,6 @@ dependencies = [
 "unicode-ident",
 ]

-[[package]]
-name = "syn"
-version = "3.0.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8593e8e72159ed2257d083c7a454a85cbf854f37a0966d8d483aff8c8a3ebcee"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
-
 [[package]]
 name = "synstructure"
 version = "0.13.1"
@@ -1965,7 +1954,7 @@ checksum = "c8af7666ab7b6390ab78131fb5b0fce11d6b7a6951602017c35fa82800708971"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.117",
+ "syn",
 ]

 [[package]]
@@ -2015,7 +2004,7 @@ checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.117",
+ "syn",
 ]

 [[package]]
@@ -2026,7 +2015,7 @@ checksum = "26afc1baea8a989337eeb52b6e72a039780ce45c3edfcc9c5b9d112feeb173c2"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.117",
+ "syn",
 ]

 [[package]]
@@ -2091,9 +2080,9 @@ dependencies = [

 [[package]]
 name = "toml"
-version = "1.1.6+spec-1.1.0"
+version = "1.1.5+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "920602543f0911ab71da12c50d59701da54c196d1a2bf5cb4b75667f137a406a"
+checksum = "12c0ba9680044b4ce98d391a62094047eada0d64860b80166c39f4a6b5640785"
 dependencies = [
 "indexmap 2.13.0",
 "serde_core",
@@ -2147,7 +2136,7 @@ checksum = "395ae124c09f9e6918a2310af6038fba074bcf474ac352496d5910dd59a2226d"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.117",
+ "syn",
 ]

 [[package]]
@@ -2274,7 +2263,7 @@ dependencies = [
 "log",
 "proc-macro2",
 "quote",
- "syn 2.0.117",
+ "syn",
 "wasm-bindgen-shared",
 ]

@@ -2309,7 +2298,7 @@ checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.117",
+ "syn",
 "wasm-bindgen-backend",
 "wasm-bindgen-shared",
 ]
@@ -2678,7 +2667,7 @@ dependencies = [
 "heck",
 "indexmap 2.13.0",
 "prettyplease",
- "syn 2.0.117",
+ "syn",
 "wasm-metadata",
 "wit-bindgen-core",
 "wit-component",
@@ -2694,7 +2683,7 @@ dependencies = [
 "prettyplease",
 "proc-macro2",
 "quote",
- "syn 2.0.117",
+ "syn",
 "wit-bindgen-core",
 "wit-bindgen-rust",
 ]
@@ -2768,7 +2757,7 @@ checksum = "2380878cad4ac9aac1e2435f3eb4020e8374b5f13c296cb75b4620ff8e229154"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.117",
+ "syn",
 "synstructure",
 ]

@@ -2790,7 +2779,7 @@ checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.117",
+ "syn",
 ]

 [[package]]
@@ -2810,7 +2799,7 @@ checksum = "595eed982f7d355beb85837f651fa22e90b3c044842dc7f2c2842c086f295808"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.117",
+ "syn",
 "synstructure",
 ]

@@ -2833,5 +2822,5 @@ checksum = "6eafa6dfb17584ea3e2bd6e76e0cc15ad7af12b09abdd1ca55961bed9b1063c6"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.117",
+ "syn",
 ]
@@ -56,13 +56,11 @@ Arch:
 |         <!--Installation Guide-->          |          <!--Documentation-->          |       <!--Discord-->        |
 | :----------------------------------------: | :------------------------------------: | :-------------------------: |
 | :book: [Installation Guide][toc-install] | :books: [Documentation][links-table-2] | :parrot: [Discord][discord] |
-|                                          | :penguin: [ARM Support](docs/arm-support.md) |                           |

 ## 🙋 Table of Contents

 - 📖 [Installation Guide][toc-install]
 - 🐋 [Docker Usage][toc-docker-usage]
- 🐧 [ARM Support](docs/arm-support.md)
 - 🦜 [Discord][discord]
 - 🤸 [Usage][usage-1]

@@ -1,10 +1,6 @@
 use criterion::{criterion_group, criterion_main, Criterion};
-use rustscan::generated::get_parsed_data;
-use rustscan::input::{Opts, PortRanges, ScanOrder};
+use rustscan::input::{Opts, PortRange, ScanOrder};
 use rustscan::port_strategy::PortStrategy;
-use rustscan::scanner::build_udp_payload_lookup;
-use std::collections::BTreeMap;
-use std::hint::black_box;
 use std::net::IpAddr;
 use std::time::Duration;

@@ -13,7 +9,10 @@ fn bench_address() {
 }

 fn bench_port_strategy() {
-    let range = PortRanges(vec![(1, 1_000)]);
+    let range = PortRange {
+        start: 1,
+        end: 1_000,
+    };
    let _strategy = PortStrategy::pick(&Some(range.clone()), None, ScanOrder::Serial);
 }

@@ -35,18 +34,6 @@ fn bench_address_parsing() {
    let _ips = rustscan::address::parse_addresses(&opts);
 }

-// Replicates the old UDP payload selection behavior:
-// scan the whole UDP payload map and find the last payload whose port list contains `port`.
-fn old_payload_for_port(udp_map: &'static BTreeMap<Vec<u16>, Vec<u8>>, port: u16) -> &'static [u8] {
-    let mut payload: &'static [u8] = b"";
-    for (ports, value) in udp_map.iter() {
-        if ports.contains(&port) {
-            payload = value.as_slice();
-        }
-    }
-    payload
-}
-
 fn criterion_benchmark(c: &mut Criterion) {
    // Benching helper functions
    c.bench_function("parse address", |b| b.iter(bench_address));
@@ -59,30 +46,6 @@ fn criterion_benchmark(c: &mut Criterion) {
        b.iter(bench_address_parsing)
    });
    address_group.finish();
-
-    // UDP payload lookup micro-benchmark: compares the old linear scan of the
-    // payload map with the precomputed port -> payload lookup. No sockets.
-    let udp_map = get_parsed_data();
-    let lookup = build_udp_payload_lookup(udp_map);
-    let ports: Vec<u16> = (1..=4096).collect();
-
-    c.bench_function("udp payload lookup/old scan map 1..4096", |b| {
-        b.iter(|| {
-            for &p in ports.iter() {
-                let payload = old_payload_for_port(black_box(udp_map), black_box(p));
-                black_box(payload);
-            }
-        })
-    });
-
-    c.bench_function("udp payload lookup/new hashmap 1..4096", |b| {
-        b.iter(|| {
-            for &p in ports.iter() {
-                let payload = lookup.get(&p).copied().unwrap_or(b"");
-                black_box(payload);
-            }
-        })
-    });
 }

 criterion_group!(benches, criterion_benchmark);
@@ -25,10 +25,6 @@ pub fn main() {
    let mut curr = String::new();

    for line in data.trim().split('\n') {
-        // Strip a trailing carriage return so CRLF checkouts parse
-        // identically to LF ones (otherwise `\r` pollutes port tokens and
-        // blank lines stop looking blank).
-        let line = line.strip_suffix('\r').unwrap_or(line);
        if line.contains('#') || line.is_empty() {
            continue;
        }
@@ -171,43 +167,38 @@ fn payloads_v(fp_map: &BTreeMap<i32, String>) -> BTreeMap<i32, Vec<u8>> {
    let mut payb_linenr: BTreeMap<i32, Vec<u8>> = BTreeMap::new();

    for (&line_nr, data) in fp_map {
-        if data.contains('"') {
-            let start = data.find('"').expect("payload opening \" not found");
-            // Pass from the opening quote: the decoder pairs quotes itself
-            // to split multi-line segments.
-            payb_linenr.insert(line_nr, parser(data[start..].trim()));
+        if data.contains('\"') {
+            let start = data.find('\"').expect("payload opening \" not found");
+            let payloads = &data[start + 1..];
+            payb_linenr.insert(line_nr, parser(payloads.trim()));
        }
    }

    payb_linenr
 }

-/// Converts a quoted Nmap payload block to bytes.
+/// Converts a hexadecimal string to a Vec<u8>
 ///
 /// # Arguments
 ///
-/// * `payload` - The raw block text starting at its first opening quote:
-///   one or more `"..."` segments separated by whitespace
+/// * `payload` - A string slice containing the hexadecimal payload
 ///
 /// # Returns
 ///
-/// The decoded probe bytes: segments are decoded with [`decode_segment`]
-/// and concatenated with no separators, so multi-line probes reassemble
-/// exactly.
+/// A vector of bytes representing the decoded payload
 fn parser(payload: &str) -> Vec<u8> {
+    let payload = payload.trim_matches('"');
+    let mut tmp_str = String::new();
    let mut bytes: Vec<u8> = Vec::new();
-    let mut rest = payload.trim();
-    while let Some(open) = rest.find('"') {
-        let after_open = &rest[open + 1..];
-        match split_segment(after_open) {
-            Some((segment, remainder)) => {
-                decode_segment(segment, &mut bytes);
-                rest = remainder;
-            }
-            None => {
-                // Unterminated trailing quote: decode what's left literally.
-                decode_segment(after_open, &mut bytes);
-                break;
+
+    for (idx, char) in payload.chars().enumerate() {
+        if char == '\\' && payload.chars().nth(idx + 1) == Some('x') {
+            continue;
+        } else if char.is_ascii_hexdigit() {
+            tmp_str.push(char);
+            if tmp_str.len() == 2 {
+                bytes.push(u8::from_str_radix(&tmp_str, 16).unwrap());
+                tmp_str.clear();
            }
        }
    }
@@ -215,69 +206,6 @@ fn parser(payload: &str) -> Vec<u8> {
    bytes
 }

-/// Splits off the first `"..."` segment: `text` must start just after an
-/// opening quote. Escaped quotes (`\"`) do not terminate the segment.
-///
-/// Returns the segment body and the remainder after the closing quote.
-fn split_segment(text: &str) -> Option<(&str, &str)> {
-    let mut escaped = false;
-    for (i, c) in text.char_indices() {
-        if escaped {
-            escaped = false;
-            continue;
-        }
-        if c == '\\' {
-            escaped = true;
-            continue;
-        }
-        if c == '"' {
-            return Some((&text[..i], &text[i + 1..]));
-        }
-    }
-    None
-}
-
-/// Decodes one quoted Nmap payload segment in C-style escape format:
-/// `\xNN` becomes a byte, common single-char escapes (`\\`, `\"`,
-/// `\0`, `\n`, `\r`, `\t`) decode to their value, and every other
-/// character contributes its literal bytes.
-///
-/// Preserving literal text matters: several probes embed plain-text
-/// protocol words (the SNMP `public` community string, NetBIOS names,
-/// LDAP `objectClass`, SSDP headers). The previous hexdigits-only
-/// decoding mangled them into wrong bytes, so agents never answered.
-fn decode_segment(segment: &str, bytes: &mut Vec<u8>) {
-    let mut chars = segment.chars();
-    while let Some(c) = chars.next() {
-        if c != '\\' {
-            let mut buf = [0; 4];
-            bytes.extend_from_slice(c.encode_utf8(&mut buf).as_bytes());
-            continue;
-        }
-        match chars.next() {
-            Some('x') => {
-                let hi = chars.next().unwrap_or('0');
-                let lo = chars.next().unwrap_or('0');
-                let hex: String = [hi, lo].iter().collect();
-                bytes.push(u8::from_str_radix(&hex, 16).unwrap_or(0));
-            }
-            Some('0') => bytes.push(0),
-            Some('n') => bytes.push(b'\n'),
-            Some('r') => bytes.push(b'\r'),
-            Some('t') => bytes.push(b'\t'),
-            Some('\\') => bytes.push(b'\\'),
-            Some('"') => bytes.push(b'"'),
-            // Unknown escape: keep the character literally, matching Nmap,
-            // which passes unrecognized escapes through untouched.
-            Some(other) => {
-                let mut buf = [0; 4];
-                bytes.extend_from_slice(other.encode_utf8(&mut buf).as_bytes());
-            }
-            None => bytes.push(b'\\'),
-        }
-    }
-}
-
 /// Combines the ports BTreeMap and the Payloads BTreeMap
 ///
 /// # Arguments
@@ -1,5 +1,7 @@
 # Dockerfile for RustScan development environment
-# Provides a containerized setup with Rust and development tools
+# Provides a containerized setup with Rust, nmap, and development tools
 FROM rust
-# Install rustfmt for code formatting and clippy for linting.
-RUN rustup component add rustfmt clippy
+# Install nmap first.
+RUN apt-get update -qy && apt-get install -qy nmap
+# Then install rustfmt for code formatting and clippy for linting.
+RUN rustup component add rustfmt clippy
@@ -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 can check the command-line interface without starting a scan:
+You are now ready to use RustScan:

 ```bash
-root@container:/rustscan# cargo run -- --help
+root@container:/rustscan# cargo run -- -b 2000 -t 5000 -a 127.0.0.1
 ```

 You can also format, lint with `clippy` and test the code with the following commands:
@@ -1,38 +0,0 @@
-# ARM support
-
-This page covers which ARM targets RustScan's CI builds and tests, and how to build ARM binaries yourself.
-
-## What CI covers
-
-| Target | Built by | Tested by |
-| --- | --- | --- |
-| `aarch64-unknown-linux-gnu` (64-bit ARM Linux) | `build-nix` job in [build.yml](../.github/workflows/build.yml) | `Test Suite (ubuntu-24.04-arm)` in [test.yml](../.github/workflows/test.yml) |
-| `armv7-unknown-linux-gnueabihf` (32-bit ARM Linux) | `build-nix` job in [build.yml](../.github/workflows/build.yml) | not tested in CI |
-| `aarch64-apple-darwin` (Apple Silicon macOS) | `build-macos-aarch64` job in [build.yml](../.github/workflows/build.yml) | `Test Suite (macos-latest)` in [test.yml](../.github/workflows/test.yml) |
-
- **Builds** use [`houseabsolute/actions-rust-cross`](https://github.com/houseabsolute/actions-rust-cross). It cross-compiles the Linux ARM targets with [`cross`](https://github.com/cross-rs/cross) on x86_64 runners.
- **Tests** run natively on GitHub-hosted arm64 runners: `ubuntu-24.04-arm` for Linux, and `macos-latest`, which runs on Apple Silicon. They run the same `just test` recipe as every other platform.
-
-## Building ARM binaries locally
-
-The simplest option is `cross`, which runs the build in a container that already has the right toolchain and linker. It needs Docker or Podman.
-
-```sh
-cargo install cross
-cross build --locked --release --target aarch64-unknown-linux-gnu
-# or, for 32-bit ARM:
-cross build --locked --release --target armv7-unknown-linux-gnueabihf
-```
-
-The binary ends up at `target/<target>/release/rustscan`.
-
-On an ARM machine (for example a Raspberry Pi running a 64-bit OS, or an Apple Silicon Mac) you don't need `cross`; a normal native build works:
-
-```sh
-cargo build --locked --release
-```
-
-## Troubleshooting
-
- **`error[E0463]: can't find crate for std`, or linker errors:** you're cross-compiling with plain `cargo`. Either use `cross`, or install the target (`rustup target add <target>`) along with a matching cross linker.
- **`cross` can't pull its image:** check that Docker or Podman is running and that your user can reach it.
@@ -0,0 +1,23 @@
+#!/usr/bin/perl
+#tags = ["core_approved", "example",]
+#developer = [ "example", "https://example.org" ]
+#ports_separator = ","
+#call_format = "perl {{script}} {{ip}} {{port}}"
+
+# The Scriptfile parser stops parsing at the first blank line.
+# 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++;
+}
@@ -0,0 +1,13 @@
+#!/usr/bin/python3
+#tags = ["core_approved", "example",]
+#developer = [ "example", "https://example.org" ]
+#trigger_port = "80"
+#call_format = "python3 {{script}} {{ip}} {{port}}"
+
+# The Scriptfile parser stops parsing at the first blank line.
+# 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))
@@ -0,0 +1,12 @@
+#!/bin/bash 
+#tags = ["core_approved", "example",]
+#developer = [ "example", "https://example.org" ]
+#ports_separator = ","
+#call_format = "bash {{script}} {{ip}} {{port}}"
+
+# The Scriptfile parser stops parsing at the first blank line.
+# 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 $@
@@ -1,7 +1,9 @@
-Metadata-only test fixture; not executable.
+#!intentional_blank_line
 #tags = ["core_approved", "example"]
 #developer = [ "example", "https://example.org" ]
 #ports_separator = ","
-#call_format = "fixture {{ip}} {{port}}"
+#call_format = "nmap -vvv -p {{port}} {{ip}}"

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

-# 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
@@ -0,0 +1,6 @@
+127.0.0.1
+google.com
+example.com
+66666666666666.666666666666666666.66666666666666666.6666666666
+....
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855.radiatorFixtures
@@ -191,56 +191,17 @@ fn get_resolver(resolver: &Option<String>) -> Resolver {
                    Protocol::Udp,
                ));
            }
-            Resolver::new(config, resolver_opts()).unwrap()
+            Resolver::new(config, ResolverOpts::default()).unwrap()
        }
-        None => match system_resolver() {
+        None => match Resolver::from_system_conf() {
            Ok(resolver) => resolver,
-            Err(_) => Resolver::new(ResolverConfig::cloudflare_tls(), resolver_opts()).unwrap(),
+            Err(_) => {
+                Resolver::new(ResolverConfig::cloudflare_tls(), ResolverOpts::default()).unwrap()
+            }
        },
    }
 }

-/// `true` on Windows when the `SystemRoot` environment variable is unset.
-///
-/// hickory-resolver locates the hosts file via
-/// `std::env::var_os("SystemRoot").expect(...)`, which panics when the
-/// variable is missing. Processes spawned with a minimal environment
-/// (services, scheduled tasks, WMI) can lack `SystemRoot`, and the panic is
-/// fatal under this crate's `panic = "abort"` release profile.
-fn windows_system_root_missing() -> bool {
-    cfg!(windows) && std::env::var_os("SystemRoot").is_none()
-}
-
-/// Derives a resolver from the system configuration, e.g. `/etc/resolv.conf`
-/// on *nix or the registry on Windows.
-///
-/// Returns an error without touching the system configuration when doing so
-/// would panic inside hickory-resolver (see [`windows_system_root_missing`]).
-fn system_resolver() -> std::io::Result<Resolver> {
-    if windows_system_root_missing() {
-        debug!("SystemRoot is not set; skipping system resolver configuration");
-        return Err(std::io::Error::new(
-            std::io::ErrorKind::NotFound,
-            "SystemRoot environment variable is not set",
-        ));
-    }
-
-    Resolver::from_system_conf()
-}
-
-/// Resolver options that are safe to use in the current environment.
-///
-/// hickory-resolver eagerly loads the hosts file when `use_hosts_file` is set
-/// (the default), which hits the same missing-`SystemRoot` panic described in
-/// [`windows_system_root_missing`]; disable it in that case.
-fn resolver_opts() -> ResolverOpts {
-    let mut opts = ResolverOpts::default();
-    if windows_system_root_missing() {
-        opts.use_hosts_file = false;
-    }
-    opts
-}
-
 /// Parses and input file of IPs for use in DNS resolution.
 fn read_resolver_from_file(path: &str) -> Result<Vec<IpAddr>, std::io::Error> {
    let ips = fs::read_to_string(path)?
@@ -276,7 +237,7 @@ fn read_ips_from_file(
 #[cfg(test)]
 mod tests {
    use super::{parse_addresses, Opts};
-    use std::net::{IpAddr, Ipv4Addr};
+    use std::net::Ipv4Addr;

    #[test]
    fn parse_correct_addresses() {
@@ -381,91 +342,4 @@ mod tests {

        assert_eq!(ips.len(), 256);
    }
-
-    #[test]
-    fn parse_non_canonical_cidr_mid_block() {
-        // 192.168.1.13/29: .13 = 0000 1101, mask clears last 3 bits → .8 = 0000 1000
-        // network is 192.168.1.8/29, spanning .8 through .15
-        let opts = Opts {
-            addresses: vec!["192.168.1.13/29".to_owned()],
-            ..Default::default()
-        };
-        let ips = parse_addresses(&opts);
-        assert_eq!(
-            ips,
-            [
-                Ipv4Addr::new(192, 168, 1, 8),
-                Ipv4Addr::new(192, 168, 1, 9),
-                Ipv4Addr::new(192, 168, 1, 10),
-                Ipv4Addr::new(192, 168, 1, 11),
-                Ipv4Addr::new(192, 168, 1, 12),
-                Ipv4Addr::new(192, 168, 1, 13),
-                Ipv4Addr::new(192, 168, 1, 14),
-                Ipv4Addr::new(192, 168, 1, 15),
-            ]
-        );
-    }
-
-    #[test]
-    fn parse_non_canonical_cidr_last_in_block() {
-        // 192.168.1.15/29: last address in the block, should still resolve to same .8–.15 network
-        let opts = Opts {
-            addresses: vec!["192.168.1.15/29".to_owned()],
-            ..Default::default()
-        };
-        let ips = parse_addresses(&opts);
-        assert_eq!(
-            ips,
-            [
-                Ipv4Addr::new(192, 168, 1, 8),
-                Ipv4Addr::new(192, 168, 1, 9),
-                Ipv4Addr::new(192, 168, 1, 10),
-                Ipv4Addr::new(192, 168, 1, 11),
-                Ipv4Addr::new(192, 168, 1, 12),
-                Ipv4Addr::new(192, 168, 1, 13),
-                Ipv4Addr::new(192, 168, 1, 14),
-                Ipv4Addr::new(192, 168, 1, 15),
-            ]
-        );
-    }
-
-    #[test]
-    fn parse_non_canonical_cidr_crosses_third_octet() {
-        // 192.168.1.5/23: host bits span into the third octet
-        // .1.5 in 23-bit context → network is 192.168.0.0/23, spanning .0.0 through .1.255 (512 addresses)
-        let opts = Opts {
-            addresses: vec!["192.168.1.5/23".to_owned()],
-            ..Default::default()
-        };
-        let ips = parse_addresses(&opts);
-        assert_eq!(
-            ips.first(),
-            Some(&IpAddr::V4(Ipv4Addr::new(192, 168, 0, 0)))
-        );
-        assert_eq!(
-            ips.last(),
-            Some(&IpAddr::V4(Ipv4Addr::new(192, 168, 1, 255)))
-        );
-        assert_eq!(ips.len(), 512);
-    }
-
-    #[test]
-    fn parse_non_canonical_cidr_slash30() {
-        // 10.0.0.7/30: .7 = 0000 0111, mask clears last 2 bits → .4 = 0000 0100
-        // network is 10.0.0.4/30, spanning .4 through .7
-        let opts = Opts {
-            addresses: vec!["10.0.0.7/30".to_owned()],
-            ..Default::default()
-        };
-        let ips = parse_addresses(&opts);
-        assert_eq!(
-            ips,
-            [
-                Ipv4Addr::new(10, 0, 0, 4),
-                Ipv4Addr::new(10, 0, 0, 5),
-                Ipv4Addr::new(10, 0, 0, 6),
-                Ipv4Addr::new(10, 0, 0, 7),
-            ]
-        );
-    }
 }
@@ -1,9 +1,6 @@
 //! Provides a means to read, parse and hold configuration options for scans.
-use clap::parser::ValueSource;
-use clap::{CommandFactory, FromArgMatches, Parser, ValueEnum};
+use clap::{Parser, ValueEnum};
 use serde_derive::Deserialize;
-use std::collections::HashSet;
-use std::ffi::OsString;
 use std::fs;
 use std::path::PathBuf;

@@ -30,94 +27,35 @@ pub enum ScriptsRequired {
    Custom,
 }

-/// The port ranges to scan, as inclusive `(start, end)` pairs.
-///
-/// Parsed from `-r/--range` (e.g. `1-500,1000-2500`) and from the `range`
-/// key of the configuration file.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct PortRanges(pub Vec<(u16, u16)>);
-
-/// Accepted spellings of `range` in the configuration file.
-#[derive(Deserialize)]
-#[serde(untagged)]
-enum PortRangesConfig {
-    /// `range = { start = 1, end = 1000 }`: the format used before multiple
-    /// ranges were supported, kept so existing configuration files still work.
-    Single { start: u16, end: u16 },
-    /// `range = "1-500,1000-2500"`: the same syntax as `--range`.
-    Text(String),
-    /// `range = [[1, 500], [1000, 2500]]`.
-    Pairs(Vec<(u16, u16)>),
-}
-
-impl<'de> serde::Deserialize<'de> for PortRanges {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        let pairs = match PortRangesConfig::deserialize(deserializer)? {
-            PortRangesConfig::Single { start, end } => vec![(start, end)],
-            PortRangesConfig::Text(text) => {
-                return parse_ranges(&text).map_err(serde::de::Error::custom)
-            }
-            PortRangesConfig::Pairs(pairs) => pairs,
-        };
-
-        if pairs.is_empty() {
-            return Err(serde::de::Error::custom("expected at least one port range"));
-        }
-        if let Some(&(start, end)) = pairs.iter().find(|&&(start, end)| start > end) {
-            return Err(serde::de::Error::custom(format!(
-                "invalid port range {start}-{end}: start must not be greater than end"
-            )));
-        }
-
-        Ok(PortRanges(pairs))
-    }
+/// Represents the range of ports to be scanned.
+#[derive(Deserialize, Debug, Clone, PartialEq, Eq)]
+pub struct PortRange {
+    pub start: u16,
+    pub end: u16,
 }

 #[cfg(not(tarpaulin_include))]
-/// Parse a single `start-end` token (e.g. "100-200") into `(start, end)`.
-/// Returns `None` when the token is malformed, cannot be parsed as `u16`,
-/// or `start > end`.
-fn parse_range(input: &str) -> Option<(u16, u16)> {
-    let mut parts = input.trim().splitn(2, '-').map(str::trim);
-    let a = parts.next()?;
-    let b = parts.next()?;
+fn parse_range(input: &str) -> Result<PortRange, String> {
+    let range = input
+        .split('-')
+        .map(str::parse)
+        .collect::<Result<Vec<u16>, std::num::ParseIntError>>();

-    let start = a.parse::<u16>().ok()?;
-    let end = b.parse::<u16>().ok()?;
-
-    if start <= end {
-        Some((start, end))
-    } else {
-        None
-    }
-}
-#[cfg(not(tarpaulin_include))]
-/// Parse a comma-separated list of `start-end` ranges into `PortRanges`.
-///
-/// Errors with a helpful message identifying the bad token.
-fn parse_ranges(input: &str) -> Result<PortRanges, String> {
-    let s = input.trim();
-    if s.is_empty() {
-        return Err("empty input: expected one or more comma-separated 'start-end' pairs".into());
+    if range.is_err() {
+        return Err(String::from(
+            "the range format must be 'start-end'. Example: 1-1000.",
+        ));
    }

-    let ranges_res: Result<Vec<(u16, u16)>, String> = s
-        .split(',')
-        .map(|token| {
-            let t = token.trim();
-            parse_range(t).ok_or_else(|| {
-                format!(
-                    "invalid range token `{}` — expected `start-end` with 0 <= start <= end <= 65535",
-                    t
-                )
-            })
-        })
-        .collect();
-
-    ranges_res.map(PortRanges)
+    match range.unwrap().as_slice() {
+        [start, end] => Ok(PortRange {
+            start: *start,
+            end: *end,
+        }),
+        _ => Err(String::from(
+            "the range format must be 'start-end'. Example: 1-1000.",
+        )),
+    }
 }

 #[derive(Parser, Debug, Clone)]
@@ -142,9 +80,9 @@ pub struct Opts {
    #[arg(short, long, value_delimiter = ',')]
    pub ports: Option<Vec<u16>>,

-    /// Ranges of ports as comma-separated start-end pairs. Example: 1-500,1000-2500,4000-7000
-    #[arg(short, long, conflicts_with = "ports", value_parser = parse_ranges)]
-    pub range: Option<PortRanges>,
+    /// A range of ports with format start-end. Example: 1-1000.
+    #[arg(short, long, conflicts_with = "ports", value_parser = parse_range)]
+    pub range: Option<PortRange>,

    /// Whether to ignore the configuration file or not.
    #[arg(short, long)]
@@ -186,8 +124,7 @@ pub struct Opts {
    #[arg(long, default_value = "1")]
    pub tries: u8,

-    /// Automatically increases the Unix file-descriptor limit.
-    #[cfg_attr(not(unix), arg(hide = true))]
+    /// Automatically ups the ULIMIT with the value you provided.
    #[arg(short, long)]
    pub ulimit: Option<usize>,

@@ -224,84 +161,25 @@ pub struct Opts {
    /// UDP scanning mode, finds UDP ports that send back responses
    #[arg(long)]
    pub udp: bool,
-
-    /// Also list TCP ports that actively refused the connection (closed).
-    /// Closed ports are only printed; scripts are never run against them.
-    #[arg(long)]
-    pub closed: bool,
-
-    /// Milliseconds to wait after scanning a port (on every address) before
-    /// scanning the next one, for slow, low-noise scans. 0 disables the delay.
-    #[arg(long, default_value = "0", value_name = "MS")]
-    pub interval: u64,
-
-    /// Ids of the options given explicitly on the command line. The
-    /// configuration file never overrides these (see [`Opts::merge`]).
-    #[arg(skip)]
-    pub cli_args: HashSet<String>,
 }

 #[cfg(not(tarpaulin_include))]
 impl Opts {
    pub fn read() -> Self {
-        Self::try_read_from(std::env::args_os()).unwrap_or_else(|e| e.exit())
-    }
-
-    /// Parses `args` like [`Opts::read`] does, returning an error instead of
-    /// exiting.
-    fn try_read_from<I, T>(args: I) -> Result<Self, clap::Error>
-    where
-        I: IntoIterator<Item = T>,
-        T: Into<OsString> + Clone,
-    {
-        let mut command = Self::command();
-        let mut matches = command.try_get_matches_from_mut(args)?;
-
-        // clap fills in default values, so the parsed struct alone cannot
-        // tell `-b 4500` apart from no `-b` at all. Record what the user
-        // actually typed so that `merge` lets it win over the config file.
-        let cli_args = command
-            .get_arguments()
-            .map(|arg| arg.get_id().as_str())
-            .filter(|id| matches.value_source(id) == Some(ValueSource::CommandLine))
-            .map(str::to_owned)
-            .collect();
-
-        let mut opts =
-            Self::from_arg_matches_mut(&mut matches).map_err(|e| e.format(&mut command))?;
-        opts.cli_args = cli_args;
+        let mut opts = Opts::parse();

        if opts.ports.is_none() && opts.range.is_none() {
-            opts.range = Some(PortRanges(vec![(LOWEST_PORT_NUMBER, TOP_PORT_NUMBER)]));
+            opts.range = Some(PortRange {
+                start: LOWEST_PORT_NUMBER,
+                end: TOP_PORT_NUMBER,
+            });
        }

-        Ok(opts)
-    }
-
-    /// Validates options whose availability or semantics depend on the
-    /// operating system.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error when an option is unsupported on the current platform.
-    pub fn validate_platform(&self) -> Result<(), String> {
-        #[cfg(not(unix))]
-        {
-            if self.ulimit.is_some() {
-                return Err(
-                    "--ulimit is only supported on Unix-like operating systems. \
-                     On Windows, use --batch-size (-b) to control scan concurrency."
-                        .to_owned(),
-                );
-            }
-        }
-
-        Ok(())
+        opts
    }

    /// Reads the command line arguments into an Opts struct and merge
-    /// values found within the user configuration file. Options given on the
-    /// command line take precedence over the configuration file.
+    /// values found within the user configuration file.
    pub fn merge(&mut self, config: &Config) {
        if !self.no_config {
            self.merge_required(config);
@@ -314,9 +192,7 @@ impl Opts {
            ($($field: ident),+) => {
                $(
                    if let Some(e) = &config.$field {
-                        if !self.cli_args.contains(stringify!($field)) {
-                            self.$field = e.clone();
-                        }
+                        self.$field = e.clone();
                    }
                )+
            }
@@ -324,7 +200,7 @@ impl Opts {

        merge_required!(
            addresses, greppable, accessible, batch_size, timeout, tries, scan_order, scripts,
-            command, udp, no_banner, closed, interval
+            command, udp, no_banner
        );
    }

@@ -332,7 +208,7 @@ impl Opts {
        macro_rules! merge_optional {
            ($($field: ident),+) => {
                $(
-                    if config.$field.is_some() && !self.cli_args.contains(stringify!($field)) {
+                    if config.$field.is_some() {
                        self.$field = config.$field.clone();
                    }
                )+
@@ -371,9 +247,6 @@ impl Default for Opts {
            exclude_ports: None,
            exclude_addresses: None,
            udp: false,
-            closed: false,
-            interval: 0,
-            cli_args: HashSet::new(),
        }
    }
 }
@@ -386,7 +259,7 @@ impl Default for Opts {
 pub struct Config {
    addresses: Option<Vec<String>>,
    ports: Option<Vec<u16>>,
-    range: Option<PortRanges>,
+    range: Option<PortRange>,
    greppable: Option<bool>,
    accessible: Option<bool>,
    batch_size: Option<usize>,
@@ -401,8 +274,6 @@ pub struct Config {
    exclude_addresses: Option<Vec<String>>,
    udp: Option<bool>,
    no_banner: Option<bool>,
-    closed: Option<bool>,
-    interval: Option<u64>,
 }

 #[cfg(not(tarpaulin_include))]
@@ -420,24 +291,15 @@ impl Config {
    /// scan_order = "Serial"
    /// exclude_ports = [8080, 9090, 80]
    /// udp = false
-    /// closed = false
-    /// interval = 0
    ///
    pub fn read(custom_config_path: Option<PathBuf>) -> Self {
        let mut content = String::new();
        let config_path = custom_config_path.unwrap_or_else(|| {
-            // Try the XDG-idiomatic location first, then fall back to legacy
-            // paths so existing users keep working unchanged.
-            for path in [
-                default_config_path(),
-                legacy_dot_config_path(),
-                old_default_config_path(),
-            ] {
-                if path.exists() {
-                    return path;
-                }
+            let path = default_config_path();
+            match path.exists() {
+                true => path,
+                false => old_default_config_path(),
            }
-            default_config_path()
        });

        if config_path.exists() {
@@ -450,9 +312,7 @@ impl Config {
        let config: Config = match toml::from_str(&content) {
            Ok(config) => config,
            Err(e) => {
-                crate::tui::println_safe(format_args!(
-                    "Found {e} in configuration file.\nAborting scan.\n"
-                ));
+                println!("Found {e} in configuration file.\nAborting scan.\n");
                std::process::exit(1);
            }
        };
@@ -461,21 +321,8 @@ impl Config {
    }
 }

-/// Returns the preferred config file path: `$XDG_CONFIG_HOME/rustscan/config.toml`
-/// on Linux (with the usual `~/.config` fallback when the variable is unset),
-/// and the platform-equivalent `dirs::config_dir()` location on macOS / Windows.
+/// 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");
-    config_path.push("config.toml");
-    config_path
-}
-
-/// Returns the transitional `$XDG_CONFIG_HOME/.rustscan.toml` path that older
-/// builds wrote to. Kept readable for backwards compatibility.
-pub fn legacy_dot_config_path() -> PathBuf {
    let Some(mut config_path) = dirs::config_dir() else {
        panic!("Could not infer config file path.");
    };
@@ -496,9 +343,8 @@ pub fn old_default_config_path() -> PathBuf {
 mod tests {
    use clap::{CommandFactory, Parser};
    use parameterized::parameterized;
-    use std::collections::HashSet;

-    use super::{Config, Opts, PortRanges, ScanOrder, ScriptsRequired};
+    use super::{Config, Opts, PortRange, ScanOrder, ScriptsRequired};

    impl Config {
        fn default() -> Self {
@@ -520,8 +366,6 @@ mod tests {
                exclude_addresses: None,
                udp: Some(false),
                no_banner: None,
-                closed: Some(false),
-                interval: None,
            }
        }
    }
@@ -551,82 +395,6 @@ mod tests {
        assert_eq!(command, opts.command);
    }

-    #[test]
-    fn parses_explicit_batch_size() {
-        let opts = Opts::parse_from(["rustscan", "-a", "127.0.0.1", "-b", "1234"]);
-
-        assert_eq!(opts.batch_size, 1234);
-    }
-
-    #[test]
-    fn parses_explicit_long_batch_size() {
-        let opts = Opts::parse_from(["rustscan", "-a", "127.0.0.1", "--batch-size", "4321"]);
-
-        assert_eq!(opts.batch_size, 4321);
-    }
-
-    #[test]
-    #[cfg(windows)]
-    fn windows_platform_validation_accepts_batch_size() {
-        let opts = Opts::parse_from(["rustscan", "-a", "127.0.0.1", "--batch-size", "500"]);
-
-        assert!(opts.validate_platform().is_ok());
-        assert_eq!(opts.batch_size, 500);
-    }
-
-    #[test]
-    #[cfg(windows)]
-    fn windows_rejects_ulimit() {
-        let opts = Opts::parse_from(["rustscan", "-a", "127.0.0.1", "--ulimit", "5000"]);
-
-        let error = opts
-            .validate_platform()
-            .expect_err("Windows must reject --ulimit");
-
-        assert!(error.contains("--ulimit"));
-        assert!(error.contains("Unix"));
-        assert!(error.contains("--batch-size"));
-    }
-
-    #[test]
-    #[cfg(windows)]
-    fn windows_hides_ulimit_from_help() {
-        let help = Opts::command().render_long_help().to_string();
-
-        assert!(
-            !help.contains("--ulimit"),
-            "--ulimit should not be advertised on Windows"
-        );
-    }
-
-    #[test]
-    #[cfg(windows)]
-    fn windows_rejects_ulimit_from_config_merge() {
-        let mut opts = Opts {
-            no_config: false,
-            ..Default::default()
-        };
-        let mut config = Config::default();
-        config.ulimit = Some(5_000);
-
-        opts.merge(&config);
-
-        let error = opts
-            .validate_platform()
-            .expect_err("Windows must reject --ulimit supplied by configuration");
-
-        assert!(error.contains("--ulimit"));
-    }
-
-    #[test]
-    #[cfg(unix)]
-    fn unix_platform_validation_accepts_ulimit() {
-        let opts = Opts::parse_from(["rustscan", "-a", "127.0.0.1", "--ulimit", "5000"]);
-
-        assert!(opts.validate_platform().is_ok());
-        assert_eq!(opts.ulimit, Some(5_000));
-    }
-
    #[test]
    fn opts_no_merge_when_config_is_ignored() {
        let mut opts = Opts::default();
@@ -662,7 +430,10 @@ mod tests {
    fn opts_merge_optional_arguments() {
        let mut opts = Opts::default();
        let mut config = Config::default();
-        config.range = Some(PortRanges(vec![(1, 1_000)]));
+        config.range = Some(PortRange {
+            start: 1,
+            end: 1_000,
+        });
        config.ulimit = Some(1_000);
        config.resolver = Some("1.1.1.1".to_owned());

@@ -672,159 +443,4 @@ mod tests {
        assert_eq!(opts.ulimit, config.ulimit);
        assert_eq!(opts.resolver, config.resolver);
    }
-
-    #[test]
-    fn cli_arguments_override_config() {
-        // Regression test for #722: the config file used to silently replace
-        // options given on the command line, e.g. `-r` with its `range`.
-        let mut opts = Opts::try_read_from([
-            "rustscan",
-            "-a",
-            "192.168.0.1",
-            "-r",
-            "8600-8650",
-            "-b",
-            "100",
-            // Passing clap's default value explicitly must still win.
-            "-t",
-            "1500",
-            "--tries",
-            "3",
-            "--scan-order",
-            "serial",
-            "--scripts",
-            "none",
-            "-g",
-            "--",
-            "-sV",
-        ])
-        .unwrap();
-        let config: Config = toml::from_str(
-            r#"
-            addresses = ["127.0.0.1"]
-            range = { start = 1, end = 100 }
-            batch_size = 25000
-            timeout = 1000
-            tries = 1
-            scan_order = "Random"
-            scripts = "Custom"
-            greppable = false
-            command = ["-A"]
-            "#,
-        )
-        .unwrap();
-
-        opts.merge(&config);
-
-        assert_eq!(opts.addresses, vec!["192.168.0.1".to_owned()]);
-        assert_eq!(opts.range, Some(PortRanges(vec![(8_600, 8_650)])));
-        assert_eq!(opts.batch_size, 100);
-        assert_eq!(opts.timeout, 1_500);
-        assert_eq!(opts.tries, 3);
-        assert_eq!(opts.scan_order, ScanOrder::Serial);
-        assert_eq!(opts.scripts, ScriptsRequired::None);
-        assert!(opts.greppable);
-        assert_eq!(opts.command, vec!["-sV".to_owned()]);
-    }
-
-    #[test]
-    fn config_fills_arguments_not_given_on_cli() {
-        let mut opts = Opts::try_read_from(["rustscan", "-a", "192.168.0.1"]).unwrap();
-        let config: Config = toml::from_str(
-            r#"
-            addresses = ["127.0.0.1"]
-            range = { start = 1, end = 100 }
-            batch_size = 25000
-            timeout = 1000
-            tries = 3
-            scan_order = "Random"
-            greppable = true
-            command = ["-A"]
-            "#,
-        )
-        .unwrap();
-
-        opts.merge(&config);
-
-        // Only `-a` was typed; clap defaults such as `-b 4500` must not count.
-        assert_eq!(opts.cli_args, HashSet::from(["addresses".to_owned()]));
-        assert_eq!(opts.addresses, vec!["192.168.0.1".to_owned()]);
-        assert_eq!(opts.range, Some(PortRanges(vec![(1, 100)])));
-        assert_eq!(opts.batch_size, 25_000);
-        assert_eq!(opts.timeout, 1_000);
-        assert_eq!(opts.tries, 3);
-        assert_eq!(opts.scan_order, ScanOrder::Random);
-        assert!(opts.greppable);
-        assert_eq!(opts.command, vec!["-A".to_owned()]);
-    }
-
-    #[test]
-    fn parses_comma_separated_ranges() {
-        let opts = Opts::parse_from([
-            "rustscan",
-            "-a",
-            "127.0.0.1",
-            "-r",
-            "1-100, 200-300,5000-5100",
-        ]);
-
-        assert_eq!(
-            opts.range,
-            Some(PortRanges(vec![(1, 100), (200, 300), (5_000, 5_100)]))
-        );
-    }
-
-    #[test]
-    fn rejects_malformed_ranges() {
-        for range in ["", "300-200", "1-100,", "1-2-3", "a-b", "1-70000"] {
-            assert!(
-                Opts::try_parse_from(["rustscan", "-a", "127.0.0.1", "-r", range]).is_err(),
-                "{:?} should be rejected",
-                range
-            );
-        }
-    }
-
-    #[test]
-    fn config_range_accepts_legacy_table() {
-        let config: Config = toml::from_str("range = { start = 1, end = 1000 }").unwrap();
-
-        assert_eq!(config.range, Some(PortRanges(vec![(1, 1_000)])));
-    }
-
-    #[test]
-    fn config_range_accepts_string_and_pairs() {
-        let expected = Some(PortRanges(vec![(1, 100), (200, 300)]));
-
-        let config: Config = toml::from_str("range = \"1-100,200-300\"").unwrap();
-        assert_eq!(config.range, expected);
-
-        let config: Config = toml::from_str("range = [[1, 100], [200, 300]]").unwrap();
-        assert_eq!(config.range, expected);
-    }
-
-    #[test]
-    fn config_range_rejects_invalid_ranges() {
-        for range in [
-            "range = { start = 10, end = 1 }",
-            "range = [[10, 1]]",
-            "range = []",
-            "range = \"10-1\"",
-        ] {
-            assert!(
-                toml::from_str::<Config>(range).is_err(),
-                "{:?} should be rejected",
-                range
-            );
-        }
-    }
-
-    #[test]
-    fn parses_interval_in_milliseconds() {
-        let opts = Opts::parse_from(["rustscan", "-a", "127.0.0.1", "--interval", "250"]);
-        assert_eq!(opts.interval, 250);
-
-        let opts = Opts::parse_from(["rustscan", "-a", "127.0.0.1"]);
-        assert_eq!(opts.interval, 0);
-    }
 }
@@ -13,13 +13,16 @@
 //! use async_std::task::block_on;
 //! use std::{net::IpAddr, time::Duration};
 //!
-//! use rustscan::input::{PortRanges, ScanOrder};
+//! use rustscan::input::{PortRange, ScanOrder};
 //! use rustscan::port_strategy::PortStrategy;
 //! use rustscan::scanner::Scanner;
 //!
 //! fn main() {
 //!     let addrs = vec!["127.0.0.1".parse::<IpAddr>().unwrap()];
-//!     let range = PortRanges(vec![(1, 1_000)]);
+//!     let range = PortRange {
+//!         start: 1,
+//!         end: 1_000,
+//!     };
 //!     let strategy = PortStrategy::pick(&Some(range), None, ScanOrder::Random); // can be serial, random or manual https://github.com/RustScan/RustScan/blob/master/src/port_strategy/mod.rs
 //!     let scanner = Scanner::new(
 //!         &addrs, // the addresses to scan
@@ -5,9 +5,8 @@
 use rustscan::benchmark::{Benchmark, NamedTimer};
 use rustscan::input::{self, Config, Opts, ScriptsRequired};
 use rustscan::port_strategy::PortStrategy;
-use rustscan::scanner::{PortStatus, Scanner};
+use rustscan::scanner::Scanner;
 use rustscan::scripts::{init_scripts, Script, ScriptFile};
-use rustscan::tui::println_safe;
 use rustscan::{detail, funny_opening, output, warning};

 use colorful::{Color, Colorful};
@@ -26,7 +25,6 @@ extern crate dirs;
 #[cfg(unix)]
 const DEFAULT_FILE_DESCRIPTORS_LIMIT: usize = 8000;
 // Safest batch size based on experimentation
-#[cfg(unix)]
 const AVERAGE_BATCH_SIZE: usize = 3000;

 #[macro_use]
@@ -48,11 +46,6 @@ fn main() {
    let config = Config::read(opts.config_path.clone());
    opts.merge(&config);

-    if let Err(message) = opts.validate_platform() {
-        eprintln!("error: {message}");
-        std::process::exit(2);
-    }
-
    debug!("Main() `opts` arguments are {opts:?}");

    let scripts_to_run: Vec<ScriptFile> = match init_scripts(&opts.scripts) {
@@ -84,10 +77,13 @@ fn main() {
        std::process::exit(1);
    }

-    let batch_size = effective_batch_size(&opts);
-    debug!("Effective batch size: {batch_size}");
+    #[cfg(unix)]
+    let batch_size: usize = infer_batch_size(&opts, adjust_ulimit_size(&opts));

-    let mut scanner = Scanner::new(
+    #[cfg(not(unix))]
+    let batch_size: usize = AVERAGE_BATCH_SIZE;
+
+    let scanner = Scanner::new(
        &ips,
        batch_size,
        Duration::from_millis(opts.timeout.into()),
@@ -97,30 +93,21 @@ fn main() {
        opts.accessible,
        opts.exclude_ports.unwrap_or_default(),
        opts.udp,
-    )
-    .with_open_port_output();
-    if opts.closed {
-        scanner = scanner.with_closed_ports();
-    }
-    if opts.interval > 0 {
-        scanner = scanner.with_interval(Duration::from_millis(opts.interval));
-    }
+    );
    debug!("Scanner finished building: {scanner:?}");

    let mut portscan_bench = NamedTimer::start("Portscan");
-    let scan_result = block_on(scanner.run_with_status());
+    let scan_result = block_on(scanner.run());
    portscan_bench.end();
    benchmarks.push(portscan_bench);

-    let mut ports_per_ip: HashMap<IpAddr, Vec<u16>> = HashMap::new();
-    let mut closed_ports_per_ip: HashMap<IpAddr, Vec<u16>> = HashMap::new();
+    let mut ports_per_ip = HashMap::new();

-    for status in scan_result {
-        let (map, socket) = match status {
-            PortStatus::Open(socket) => (&mut ports_per_ip, socket),
-            PortStatus::Closed(socket) => (&mut closed_ports_per_ip, socket),
-        };
-        map.entry(socket.ip()).or_default().push(socket.port());
+    for socket in scan_result {
+        ports_per_ip
+            .entry(socket.ip())
+            .or_insert_with(Vec::new)
+            .push(socket.port());
    }

    for ip in ips {
@@ -135,7 +122,7 @@ fn main() {
        \n*I used {} batch size, consider lowering it with {} or a comfortable number for your system.
        \n Alternatively, increase the timeout if your ping is high. Rustscan -t 2000 for 2000 milliseconds (2s) timeout.\n",
        ip,
-        batch_size,
+        opts.batch_size,
        "'rustscan -b <batch_size> -a <ip address>'");
        warning!(x, opts.greppable, opts.accessible);
    }
@@ -149,15 +136,13 @@ fn main() {

        // if option scripts is none, no script will be spawned
        if opts.greppable || opts.scripts == ScriptsRequired::None {
-            println_safe(format_args!("{ip} -> [{ports_str}]"));
+            println!("{ip} -> [{ports_str}]");
            continue;
        }
        detail!("Starting Script(s)", opts.greppable, opts.accessible);

        // Run all the scripts we found and parsed based on the script config file tags field.
-        for script_f in &scripts_to_run {
-            // Clone only the script being run instead of the whole list per IP.
-            let mut script_f = script_f.clone();
+        for mut script_f in scripts_to_run.clone() {
            // 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(" ");
@@ -197,19 +182,6 @@ fn main() {
        }
    }

-    // Closed ports are only listed; scripts are never run against them.
-    if opts.closed {
-        println_safe(format_args!("closed ports:"));
-        for (ip, ports) in &closed_ports_per_ip {
-            let ports_str = ports
-                .iter()
-                .map(ToString::to_string)
-                .collect::<Vec<_>>()
-                .join(",");
-            println_safe(format_args!("{ip} -> [{ports_str}]"));
-        }
-    }
-
    // To use the runtime benchmark, run the process as: RUST_LOG=info ./rustscan
    script_bench.end();
    benchmarks.push(script_bench);
@@ -219,23 +191,6 @@ fn main() {
    info!("{}", benchmarks.summary());
 }

-/// Determines the actual batch size used by the scanner.
-///
-/// Unix systems may reduce the requested batch size according to the process
-/// file-descriptor limit. Other platforms, including Windows, use the batch
-/// size explicitly requested by the user.
-fn effective_batch_size(opts: &Opts) -> usize {
-    #[cfg(unix)]
-    {
-        infer_batch_size(opts, adjust_ulimit_size(opts))
-    }
-
-    #[cfg(not(unix))]
-    {
-        opts.batch_size
-    }
-}
-
 /// Prints the opening title of RustScan
 #[allow(clippy::items_after_statements, clippy::needless_raw_string_hashes)]
 fn print_opening(opts: &Opts) {
@@ -246,12 +201,12 @@ fn print_opening(opts: &Opts) {
 `-' `-'`-----'`----'  `-'  `----'  `---' `-'  `-'`-' `-'
 The Modern Day Port Scanner."#;

-    println_safe(format_args!("{}", s.gradient(Color::Green).bold()));
+    println!("{}", s.gradient(Color::Green).bold());
    let info = r#"________________________________________
 : http://discord.skerritt.blog         :
 : https://github.com/RustScan/RustScan :
 --------------------------------------"#;
-    println_safe(format_args!("{}", info.gradient(Color::Yellow).bold()));
+    println!("{}", info.gradient(Color::Yellow).bold());
    funny_opening!();

    let config_path = opts
@@ -300,10 +255,7 @@ fn adjust_ulimit_size(opts: &Opts) -> usize {
    }

    let (soft, _) = Resource::NOFILE.get().unwrap();
-    // On 32-bit targets the soft limit (e.g. RLIM_INFINITY) may not fit in a
-    // usize. Fall back to the conservative default rather than usize::MAX,
-    // which would skip every batch-size adjustment in infer_batch_size.
-    soft.try_into().unwrap_or(DEFAULT_FILE_DESCRIPTORS_LIMIT)
+    soft.try_into().unwrap_or(usize::MAX)
 }

 #[cfg(unix)]
@@ -320,7 +272,7 @@ fn infer_batch_size(opts: &Opts, ulimit: usize) -> usize {
        // selected a batch size higher than this we should reduce it to
        // a lower number.
        if ulimit < AVERAGE_BATCH_SIZE {
-            // ulimit is smaller than average batch size
+            // ulimit is smaller than aveage batch size
            // user must have very small ulimit
            // decrease batch size to half of ulimit
            warning!("Your file limit is very small, which negatively impacts RustScan's speed. Use the Docker image, or up the Ulimit with '--ulimit 5000'. ", opts.greppable, opts.accessible);
@@ -345,8 +297,6 @@ fn infer_batch_size(opts: &Opts, ulimit: usize) -> usize {

 #[cfg(test)]
 mod tests {
-    #[cfg(windows)]
-    use super::effective_batch_size;
    #[cfg(unix)]
    use super::{adjust_ulimit_size, infer_batch_size};
    use super::{print_opening, Opts};
@@ -417,41 +367,11 @@ mod tests {

    #[test]
    fn test_print_opening_no_panic() {
-        let opts = Opts::default();
+        let opts = Opts {
+            ulimit: Some(2_000),
+            ..Default::default()
+        };
        // print opening should not panic
        print_opening(&opts);
    }
-
-    #[test]
-    #[cfg(windows)]
-    fn windows_batch_size_uses_requested_value() {
-        let opts = Opts {
-            batch_size: 50,
-            ..Default::default()
-        };
-
-        assert_eq!(effective_batch_size(&opts), 50);
-    }
-
-    #[test]
-    #[cfg(windows)]
-    fn windows_batch_size_preserves_large_requested_value() {
-        let opts = Opts {
-            batch_size: 12_345,
-            ..Default::default()
-        };
-
-        assert_eq!(effective_batch_size(&opts), 12_345);
-    }
-
-    #[test]
-    #[cfg(windows)]
-    fn windows_batch_size_preserves_single_connection() {
-        let opts = Opts {
-            batch_size: 1,
-            ..Default::default()
-        };
-
-        assert_eq!(effective_batch_size(&opts), 1);
-    }
 }
@@ -1,6 +1,6 @@
 //! Provides a means to hold configuration options specifically for port scanning.
 mod range_iterator;
-use crate::input::{PortRanges, ScanOrder};
+use crate::input::{PortRange, ScanOrder};
 use rand::rng;
 use rand::seq::SliceRandom;
 use range_iterator::RangeIterator;
@@ -17,18 +17,20 @@ pub enum PortStrategy {
 }

 impl PortStrategy {
-    pub fn pick(range: &Option<PortRanges>, ports: Option<Vec<u16>>, order: ScanOrder) -> Self {
+    pub fn pick(range: &Option<PortRange>, ports: Option<Vec<u16>>, order: ScanOrder) -> Self {
        match order {
            ScanOrder::Serial if ports.is_none() => {
-                let port_ranges = range.as_ref().unwrap();
+                let range = range.as_ref().unwrap();
                PortStrategy::Serial(SerialRange {
-                    range: port_ranges.0.clone(),
+                    start: range.start,
+                    end: range.end,
                })
            }
            ScanOrder::Random if ports.is_none() => {
-                let port_ranges = range.as_ref().unwrap();
+                let range = range.as_ref().unwrap();
                PortStrategy::Random(RandomRange {
-                    range: port_ranges.0.clone(),
+                    start: range.start,
+                    end: range.end,
                })
            }
            ScanOrder::Serial => PortStrategy::Manual(ports.unwrap()),
@@ -60,12 +62,13 @@ trait RangeOrder {
 /// ascending order.
 #[derive(Debug)]
 pub struct SerialRange {
-    range: Vec<(u16, u16)>,
+    start: u16,
+    end: u16,
 }

 impl RangeOrder for SerialRange {
    fn generate(&self) -> Vec<u16> {
-        RangeIterator::new_serial(&self.range).collect()
+        (self.start..=self.end).collect()
    }
 }

@@ -73,7 +76,8 @@ impl RangeOrder for SerialRange {
 /// a random order. This vector is built following the LCG algorithm.
 #[derive(Debug)]
 pub struct RandomRange {
-    range: Vec<(u16, u16)>,
+    start: u16,
+    end: u16,
 }

 impl RangeOrder for RandomRange {
@@ -87,47 +91,33 @@ impl RangeOrder for RandomRange {
    // port numbers close to each other are pretty slim due to the way the
    // algorithm works.
    fn generate(&self) -> Vec<u16> {
-        RangeIterator::new_random(&self.range).collect()
+        RangeIterator::new(self.start.into(), self.end.into()).collect()
    }
 }

 #[cfg(test)]
 mod tests {
    use super::PortStrategy;
-    use crate::input::{PortRanges, ScanOrder};
-    use std::collections::HashSet;
+    use crate::input::{PortRange, ScanOrder};

-    fn expected_ports_from_ranges(input: &[(u16, u16)]) -> Vec<u16> {
-        let mut s = HashSet::new();
-        for &(start, end) in input {
-            for p in start..=end {
-                s.insert(p);
-            }
-        }
-        let mut v: Vec<u16> = s.into_iter().collect();
-        v.sort_unstable();
-        v
-    }
    #[test]
    fn serial_strategy_with_range() {
-        let ranges = PortRanges(vec![(1u16, 10u16), (20u16, 30u16), (100u16, 110u16)]);
-        let strategy = PortStrategy::pick(&Some(ranges.clone()), None, ScanOrder::Serial);
+        let range = PortRange { start: 1, end: 100 };
+        let strategy = PortStrategy::pick(&Some(range), None, ScanOrder::Serial);
        let result = strategy.order();
-        let expected = expected_ports_from_ranges(&ranges.0);
-
-        assert_eq!(expected, result);
+        let expected_range = (1..=100).collect::<Vec<u16>>();
+        assert_eq!(expected_range, result);
    }
    #[test]
    fn random_strategy_with_range() {
-        let ranges = PortRanges(vec![(1u16, 10u16), (20u16, 30u16), (100u16, 110u16)]);
-        let strategy = PortStrategy::pick(&Some(ranges.clone()), None, ScanOrder::Random);
+        let range = PortRange { start: 1, end: 100 };
+        let strategy = PortStrategy::pick(&Some(range), None, ScanOrder::Random);
        let mut result = strategy.order();
-        let expected = expected_ports_from_ranges(&ranges.0);
+        let expected_range = (1..=100).collect::<Vec<u16>>();
+        assert_ne!(expected_range, result);

-        assert_ne!(expected, result);
        result.sort_unstable();
-
-        assert_eq!(expected, result);
+        assert_eq!(expected_range, result);
    }

    #[test]
@@ -141,10 +131,10 @@ mod tests {
    fn random_strategy_with_ports() {
        let strategy = PortStrategy::pick(&None, Some((1..10).collect()), ScanOrder::Random);
        let mut result = strategy.order();
-        let expected = (1..10).collect::<Vec<u16>>();
-        assert_ne!(expected, result);
+        let expected_range = (1..10).collect::<Vec<u16>>();
+        assert_ne!(expected_range, result);

        result.sort_unstable();
-        assert_eq!(expected, result);
+        assert_eq!(expected_range, result);
    }
 }
@@ -2,195 +2,70 @@ use gcd::Gcd;
 use rand::RngExt;
 use std::convert::TryInto;

-/// Yields ports produced from a collection of (possibly overlapping)
-/// inclusive `u16` ranges in two modes:
-///
-/// **Randomized** — created by `RangeIterator::new_random`:
-///    - The algorithm generates a permutation of indices `0..N-1` using the
-///      additive congruential step `x_{i+1} = (x_i + step) % N`.
-///    - `step` is chosen so `gcd(step, N) == 1` to ensure the sequence is a
-///      full-length cycle (visits each index exactly once).
-///    - `x_0` (the seed stored as `normalized_first_pick`) is chosen uniformly
-///      in `0..N`.
-///
-///      For more information: <https://en.wikipedia.org/wiki/Linear_congruential_generator>
-///
-/// **Serial** — `RangeIterator::new_serial`:
-///     Iterates the input ranges in the **original input order** and yields
-///     each port the first time it is encountered. Duplicate ports (from
-///     overlapping ranges) are skipped using a 65_536-entry "seen" table.
 pub struct RangeIterator {
    active: bool,
-    total: u32,
+    normalized_end: u32,
    normalized_first_pick: u32,
    normalized_pick: u32,
+    actual_start: u32,
    step: u32,
-    ranges: Vec<(u32, u32)>,
-    prefix: Vec<u32>,
-    serial_itr: Option<Box<dyn Iterator<Item = u16>>>,
-    /// `seen[port]` is true once `port` has been yielded (serial mode only).
-    serial_seen: Option<Vec<bool>>,
 }

+/// An iterator that follows the `Linear Congruential Generator` algorithm.
+///
+/// For more information: <https://en.wikipedia.org/wiki/Linear_congruential_generator>
 impl RangeIterator {
-    /// Construct a randomized iterator (LCG permutation).
+    /// Receives the start and end of a range and normalize
+    /// these values before selecting a coprime for the end of the range
+    /// which will server as the step for the algorithm.
    ///
-    /// Preconditions:
-    /// - `input` must contain at least one `(u16,u16)`
-    ///   and each pair must satisfy `start <= end`.
-    pub fn new_random(input: &[(u16, u16)]) -> Self {
-        // normalize & merge into (start, len) u32 pairs
-        // Example: [(10,12),(11,15)] -> merged [(10,6)]
-        let mut ranges: Vec<(u32, u32)> = input
-            .iter()
-            .map(|(s, e)| {
-                let start = *s as u32;
-                let end_excl = (*e as u32) + 1; // convert inclusive -> exclusive
-                (start, end_excl)
-            })
-            .collect();
+    /// For example, the range `1000-2500` will be normalized to `0-1500`
+    /// before going through the algorithm.
+    pub fn new(start: u32, end: u32) -> Self {
+        let normalized_end = end - start + 1;
+        let step = pick_random_coprime(normalized_end);

-        ranges.sort_unstable_by_key(|&(s, _)| s);
-
-        let mut merged: Vec<(u32, u32)> = Vec::with_capacity(ranges.len());
-        if !ranges.is_empty() {
-            let mut iter = ranges.into_iter();
-            let (mut cur_s, mut cur_end) = iter.next().unwrap(); // cur_end exclusive
-            for (s, end_excl) in iter {
-                if s <= cur_end {
-                    // overlap/adjacent -> extend
-                    if end_excl > cur_end {
-                        cur_end = end_excl;
-                    }
-                } else {
-                    // push disjoint segment as (start, len)
-                    merged.push((cur_s, cur_end - cur_s)); // len = excl - start
-                    cur_s = s;
-                    cur_end = end_excl;
-                }
-            }
-            merged.push((cur_s, cur_end - cur_s));
-        }
-        // build prefix sums (prefix[0] = 0; prefix.len() == merged.len() + 1)
-        let prefix = merged.iter().fold(vec![0u32], |mut acc, (_, len)| {
-            let last = acc.last().unwrap();
-            acc.push(last.saturating_add(*len));
-            acc
-        });
-
-        // total is guaranteed > 0 by precondition (input.len() >= 1)
-        let total = *prefix.last().unwrap();
-
-        // pick step and seed
-        let step = pick_random_coprime(total);
+        // Randomly choose a number within the range to be the first
+        // and assign it as a pick.
        let mut rng = rand::rng();
-        let first = rng.random_range(0..total);
+        let normalized_first_pick = rng.random_range(0..normalized_end);

        Self {
            active: true,
-            total,
-            normalized_first_pick: first,
-            normalized_pick: first,
+            normalized_end,
            step,
-            ranges: merged,
-            prefix,
-            serial_itr: None,
-            serial_seen: None,
-        }
-    }
-
-    /// Construct a serial iterator that yields ports in original input order,
-    /// skipping duplicates. The deduplication is done on the fly with a seen-table.
-    ///
-    /// Preconditions:
-    /// - `input` must contain at least one `(u16,u16)` and each pair must satisfy `start <= end`.
-    pub fn new_serial(input: &[(u16, u16)]) -> Self {
-        // Build a serial iterator that yields ports in *input order* (start..=end).
-        // We keep the merged ranges/prefix empty here (they are not needed for serial mode).
-        let input = input.to_vec();
-        let serial_itr = input.into_iter().flat_map(|(start, end)| start..=end);
-
-        let serial_itr_boxed: Box<dyn Iterator<Item = u16>> = Box::new(serial_itr);
-        // One entry per possible port (0..=65535).
-        let seen = vec![false; usize::from(u16::MAX) + 1];
-
-        Self {
-            active: true,
-            total: 0,
-            normalized_first_pick: 0,
-            normalized_pick: 0,
-            step: 0,
-            ranges: Vec::new(),
-            prefix: Vec::new(),
-            serial_itr: Some(serial_itr_boxed),
-            serial_seen: Some(seen),
+            normalized_first_pick,
+            normalized_pick: normalized_first_pick,
+            actual_start: start,
        }
    }
 }
+
 impl Iterator for RangeIterator {
    type Item = u16;

-    /// Advance the iterator by one port.
-    ///
-    /// 1. Read the current normalized index `cur`.
-    /// 2. Compute `next = (cur + step) % total` and update `normalized_pick`.
-    /// 3. If `next == normalized_first_pick` mark `active = false` (we completed the cycle).
-    /// 4. Map the returned index `cur` into the merged ranges via the prefix array:
-    ///    - find the range index `idx` where `prefix[idx] <= cur < prefix[idx+1]`,
-    ///    - offset = `cur - prefix[idx]`,
-    ///    - port = `ranges[idx].0 + offset`.
-    /// 5. Return `port as u16`.
-    ///
+    // The next step is always bound by the formula: N+1 = (N + STEP) % TOP_OF_THE_RANGE
+    // It will only stop once we generate a number equal to the first generated number.
    fn next(&mut self) -> Option<Self::Item> {
        if !self.active {
            return None;
        }

-        // SERIAL iterator fast-path: preserve original input order but skip duplicates.
-        if let (Some(it), Some(seen)) = (self.serial_itr.as_mut(), self.serial_seen.as_mut()) {
-            for p in it.by_ref() {
-                // Yield each port only the first time it is seen.
-                if !std::mem::replace(&mut seen[usize::from(p)], true) {
-                    return Some(p);
-                }
-                // otherwise skip duplicate and continue
-            }
-            // serial iterator exhausted: drop it and mark inactive
-            self.serial_itr = None;
-            self.serial_seen = None;
-            self.active = false;
-            return None;
-        }
+        let current_pick = self.normalized_pick;
+        let next_pick = (current_pick + self.step) % self.normalized_end;

-        // RANDOMIZED (LCG) path
-        let cur = self.normalized_pick;
-        let next = (cur + self.step) % self.total;
-
-        // if next equals the original seed we finished the cycle after returning cur
-        if next == self.normalized_first_pick {
+        // If the next pick is equal to the first pick this means that
+        // we have iterated through the entire range.
+        if next_pick == self.normalized_first_pick {
            self.active = false;
        }

-        self.normalized_pick = next;
-
-        // Map cur -> port using prefix + ranges (binary search)
-        let mut lo: usize = 0;
-        let mut hi: usize = self.ranges.len();
-        while lo < hi {
-            let mid = (lo + hi) / 2;
-            if self.prefix[mid + 1] > cur {
-                hi = mid;
-            } else {
-                lo = mid + 1;
-            }
-        }
-        let idx = lo;
-        let offset = cur - self.prefix[idx];
-        let (start, _len) = self.ranges[idx];
-        let port = (start + offset)
-            .try_into()
-            .expect("Could not convert u32 to u16");
-        Some(port)
+        self.normalized_pick = next_pick;
+        Some(
+            (self.actual_start + current_pick)
+                .try_into()
+                .expect("Could not convert u32 to u16"),
+        )
    }
 }

@@ -223,105 +98,36 @@ fn pick_random_coprime(end: u32) -> u32 {

 #[cfg(test)]
 mod tests {
-    use super::*;
-    use std::collections::HashSet;
-
-    // Helper: collect, sort and return ports produced by randomized RangeIterator
-    fn generate_sorted_from_ranges_random(input: &[(u16, u16)]) -> Vec<u16> {
-        let mut it = RangeIterator::new_random(input);
-        let mut v: Vec<u16> = it.by_ref().collect();
-        v.sort_unstable();
-        v
-    }
-
-    // Helper: collect, sort and return ports produced by serial RangeIterator
-    fn generate_sorted_from_ranges_serial(input: &[(u16, u16)]) -> Vec<u16> {
-        let mut it = RangeIterator::new_serial(input);
-        let mut v: Vec<u16> = it.by_ref().collect();
-        v.sort_unstable();
-        v
-    }
-
-    // Build expected sorted unique ports from input ranges (inclusive)
-    fn expected_ports_from_ranges(input: &[(u16, u16)]) -> Vec<u16> {
-        let mut s = HashSet::new();
-        for &(start, end) in input {
-            for p in start..=end {
-                s.insert(p);
-            }
-        }
-        let mut v: Vec<u16> = s.into_iter().collect();
-        v.sort_unstable();
-        v
-    }
+    use super::RangeIterator;

    #[test]
-    fn random_range_iterator_test() {
-        // small disjoint ranges
-        let input = &[(1u16, 10u16), (20u16, 30u16), (100u16, 110u16)];
-        let result = generate_sorted_from_ranges_random(input);
-        let expected = expected_ports_from_ranges(input);
-        assert_eq!(expected, result);
+    fn range_iterator_iterates_through_the_entire_range() {
+        let result = generate_sorted_range(1, 10);
+        let expected_range = (1..=10).collect::<Vec<u16>>();
+        assert_eq!(expected_range, result);

-        // larger disjoint ranges
-        let input = &[(1u16, 100u16), (200u16, 500u16)];
-        let result = generate_sorted_from_ranges_random(input);
-        let expected = expected_ports_from_ranges(input);
-        assert_eq!(expected, result);
+        let result = generate_sorted_range(1, 100);
+        let expected_range = (1..=100).collect::<Vec<u16>>();
+        assert_eq!(expected_range, result);

-        // overlapping and adjacent
-        let input = &[(10u16, 20u16), (15u16, 25u16), (26u16, 30u16)];
-        let result = generate_sorted_from_ranges_random(input);
-        let expected = expected_ports_from_ranges(input);
-        assert_eq!(expected, result);
+        let result = generate_sorted_range(1, 1000);
+        let expected_range = (1..=1000).collect::<Vec<u16>>();
+        assert_eq!(expected_range, result);

-        // near-full domain (heavy): we only assert lengths & equality
-        let input = &[(1u16, 65_535u16)];
-        let result = generate_sorted_from_ranges_random(input);
-        let expected = expected_ports_from_ranges(input);
-        assert_eq!(expected.len(), result.len());
-        assert_eq!(expected, result);
+        let result = generate_sorted_range(1, 65_535);
+        let expected_range = (1..=65_535).collect::<Vec<u16>>();
+        assert_eq!(expected_range, result);

-        // multiple disjoint ranges - check dedupe & coverage
-        let input = &[(50u16, 100u16), (1000u16, 2000u16), (30000u16, 30010u16)];
-        let result = generate_sorted_from_ranges_random(input);
-        let set_len = result.iter().copied().collect::<HashSet<u16>>().len();
-        assert_eq!(set_len, result.len());
-        let expected = expected_ports_from_ranges(input);
-        assert_eq!(expected, result);
+        let result = generate_sorted_range(1000, 2000);
+        let expected_range = (1000..=2000).collect::<Vec<u16>>();
+        assert_eq!(expected_range, result);
    }

-    #[test]
-    fn serial_range_iterator_test() {
-        // serial should preserve input-order semantics but here we only assert
-        // coverage (no duplicates) by sorting results and comparing expected set.
+    fn generate_sorted_range(start: u32, end: u32) -> Vec<u16> {
+        let range = RangeIterator::new(start, end);
+        let mut result = range.into_iter().collect::<Vec<u16>>();
+        result.sort_unstable();

-        // small disjoint ranges
-        let input = &[(1u16, 10u16), (20u16, 30u16), (100u16, 110u16)];
-        let result = generate_sorted_from_ranges_serial(input);
-        let expected = expected_ports_from_ranges(input);
-        assert_eq!(expected, result);
-
-        // overlapping and adjacent
-        let input = &[(10u16, 20u16), (15u16, 25u16), (26u16, 30u16)];
-        let result = generate_sorted_from_ranges_serial(input);
-        let expected = expected_ports_from_ranges(input);
-        assert_eq!(expected, result);
-
-        // multiple disjoint ranges
-        let input = &[(50u16, 100u16), (1000u16, 2000u16), (30000u16, 30010u16)];
-        let result = generate_sorted_from_ranges_serial(input);
-        let set_len = result.iter().copied().collect::<HashSet<u16>>().len();
-        assert_eq!(set_len, result.len());
-        let expected = expected_ports_from_ranges(input);
-        assert_eq!(expected, result);
-
-        // all possible inputs
-        let input = &[(u16::MIN, u16::MAX)];
-        let result = generate_sorted_from_ranges_serial(input);
-        let set_len = result.iter().copied().collect::<HashSet<u16>>().len();
-        assert_eq!(set_len, result.len());
-        let expected = expected_ports_from_ranges(input);
-        assert_eq!(expected, result);
+        result
    }
 }
@@ -1,7 +1,6 @@
 //! Core functionality for actual scanning behaviour.
 use crate::generated::get_parsed_data;
 use crate::port_strategy::PortStrategy;
-use crate::tui::println_safe;
 use log::debug;

 mod socket_iterator;
@@ -9,41 +8,17 @@ use socket_iterator::SocketIterator;

 use async_std::net::TcpStream;
 use async_std::prelude::*;
-use async_std::task::sleep;
 use async_std::{io, net::UdpSocket};
 use colored::Colorize;
 use futures::stream::FuturesUnordered;
 use std::collections::BTreeMap;
 use std::{
-    collections::{HashMap, HashSet},
+    collections::HashSet,
    net::{IpAddr, Shutdown, SocketAddr},
    num::NonZeroU8,
-    sync::Arc,
    time::Duration,
 };

-/// UDP payload lookup: port -> payload bytes
-///
-/// `get_parsed_data()` returns a `&'static BTreeMap<...>`, so we can store
-/// references to the payload bytes without cloning them.
-#[doc(hidden)]
-pub type UdpPayloadLookup = HashMap<u16, &'static [u8]>;
-
-#[doc(hidden)]
-pub fn build_udp_payload_lookup(udp_map: &'static BTreeMap<Vec<u16>, Vec<u8>>) -> UdpPayloadLookup {
-    let mut lookup: UdpPayloadLookup = HashMap::new();
-
-    for (ports, payload_vec) in udp_map.iter() {
-        let payload: &'static [u8] = payload_vec.as_slice();
-        for &port in ports.iter() {
-            // Preserve existing behavior: if duplicates exist, last insert wins.
-            lookup.insert(port, payload);
-        }
-    }
-
-    lookup
-}
-
 /// The class for the scanner
 /// IP is data type IpAddr and is the IP address
 /// start & end is where the port scan starts and ends
@@ -62,19 +37,6 @@ pub struct Scanner {
    accessible: bool,
    exclude_ports: Vec<u16>,
    udp: bool,
-    print_open_ports: bool,
-    report_closed: bool,
-    interval: Duration,
-}
-
-/// The outcome for a single socket, as returned by [`Scanner::run_with_status`].
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum PortStatus {
-    /// The TCP connection succeeded, or the UDP target answered.
-    Open(SocketAddr),
-    /// The target actively refused the TCP connection (for example with a
-    /// RST). Only reported when [`Scanner::with_closed_ports`] is enabled.
-    Closed(SocketAddr),
 }

 // Allowing too many arguments for clippy.
@@ -101,62 +63,13 @@ impl Scanner {
            accessible,
            exclude_ports,
            udp,
-            print_open_ports: false,
-            report_closed: false,
-            interval: Duration::ZERO,
        }
    }

-    /// Enables the CLI's incremental open-port output.
-    ///
-    /// Library callers are quiet by default and can inspect the sockets returned by [`Self::run`].
-    #[must_use]
-    pub fn with_open_port_output(mut self) -> Self {
-        self.print_open_ports = true;
-        self
-    }
-
-    /// Also reports TCP ports that actively refuse the connection, as
-    /// [`PortStatus::Closed`] from [`Self::run_with_status`].
-    ///
-    /// Ports that time out are still treated as filtered and are not reported.
-    /// UDP scans never report closed ports.
-    #[must_use]
-    pub fn with_closed_ports(mut self) -> Self {
-        self.report_closed = true;
-        self
-    }
-
-    /// Waits `interval` after scanning one port (on every address) before
-    /// scanning the next port, for slow, low-noise scans.
-    ///
-    /// Within a port, up to `batch_size` addresses are still scanned
-    /// concurrently. A zero interval (the default) scans all sockets in
-    /// batches without any delay.
-    #[must_use]
-    pub fn with_interval(mut self, interval: Duration) -> Self {
-        self.interval = interval;
-        self
-    }
-
    /// Runs scan_range with chunk sizes
    /// If you want to run RustScan normally, this is the entry point used
-    /// Returns all open sockets.
+    /// Returns all open ports as `Vec<u16>`
    pub async fn run(&self) -> Vec<SocketAddr> {
-        self.run_with_status()
-            .await
-            .into_iter()
-            .filter_map(|status| match status {
-                PortStatus::Open(socket) => Some(socket),
-                PortStatus::Closed(_) => None,
-            })
-            .collect()
-    }
-
-    /// Like [`Self::run`], but returns the status of every socket that gave a
-    /// definitive answer: open sockets, plus closed sockets when
-    /// [`Self::with_closed_ports`] is enabled.
-    pub async fn run_with_status(&self) -> Vec<PortStatus> {
        let ports: Vec<u16> = self
            .port_strategy
            .order()
@@ -164,73 +77,33 @@ impl Scanner {
            .filter(|&port| !self.exclude_ports.contains(port))
            .copied()
            .collect();
-        let mut found_sockets: Vec<PortStatus> = Vec::new();
-        let mut errors: HashSet<String> = HashSet::new();
-
-        // Build UDP payload lookup once (only if we are scanning UDP).
-        // This avoids cloning a big map into every spawned future and turns
-        // payload selection from O(n) to O(1).
-        let udp_payloads: Option<Arc<UdpPayloadLookup>> = if self.udp {
-            Some(Arc::new(build_udp_payload_lookup(get_parsed_data())))
-        } else {
-            None
-        };
-
-        debug!("Start scanning sockets. \nBatch size {}\nNumber of ip-s {}\nNumber of ports {}\nTargets all together {}\nInterval between ports {:?}",
-            self.batch_size,
-            self.ips.len(),
-            ports.len(),
-            (self.ips.len() * ports.len()),
-            self.interval);
-
-        if self.interval.is_zero() {
-            let sockets = SocketIterator::new(&self.ips, &ports);
-            self.scan_sockets(sockets, &udp_payloads, &mut found_sockets, &mut errors)
-                .await;
-        } else {
-            // Scan one port (on every address) at a time and wait `interval`
-            // before moving on to the next port.
-            for (i, port) in ports.iter().enumerate() {
-                if i > 0 {
-                    sleep(self.interval).await;
-                }
-                let sockets = SocketIterator::new(&self.ips, std::slice::from_ref(port));
-                self.scan_sockets(sockets, &udp_payloads, &mut found_sockets, &mut errors)
-                    .await;
-            }
-        }
-
-        debug!("Typical socket connection errors {errors:?}");
-        debug!("Sockets found: {:?}", found_sockets);
-        found_sockets
-    }
-
-    /// Scans every socket yielded by `sockets`, keeping at most `batch_size`
-    /// connection attempts in flight.
-    async fn scan_sockets(
-        &self,
-        mut sockets: SocketIterator<'_>,
-        udp_payloads: &Option<Arc<UdpPayloadLookup>>,
-        found_sockets: &mut Vec<PortStatus>,
-        errors: &mut HashSet<String>,
-    ) {
+        let mut socket_iterator: SocketIterator = SocketIterator::new(&self.ips, &ports);
+        let mut open_sockets: Vec<SocketAddr> = Vec::new();
        let mut ftrs = FuturesUnordered::new();
+        let mut errors: HashSet<String> = HashSet::new();
+        let udp_map = get_parsed_data();

        for _ in 0..self.batch_size {
-            if let Some(socket) = sockets.next() {
-                ftrs.push(self.scan_socket(socket, udp_payloads.clone()));
+            if let Some(socket) = socket_iterator.next() {
+                ftrs.push(self.scan_socket(socket, udp_map.clone()));
            } else {
                break;
            }
        }

+        debug!("Start scanning sockets. \nBatch size {}\nNumber of ip-s {}\nNumber of ports {}\nTargets all together {} ",
+            self.batch_size,
+            self.ips.len(),
+            ports.len(),
+            (self.ips.len() * ports.len()));
+
        while let Some(result) = ftrs.next().await {
-            if let Some(socket) = sockets.next() {
-                ftrs.push(self.scan_socket(socket, udp_payloads.clone()));
+            if let Some(socket) = socket_iterator.next() {
+                ftrs.push(self.scan_socket(socket, udp_map.clone()));
            }

            match result {
-                Ok(status) => found_sockets.push(status),
+                Ok(socket) => open_sockets.push(socket),
                Err(e) => {
                    let error_string = e.to_string();
                    if errors.len() < self.ips.len() * 1000 {
@@ -239,6 +112,9 @@ impl Scanner {
                }
            }
        }
+        debug!("Typical socket connection errors {errors:?}");
+        debug!("Open Sockets found: {:?}", open_sockets);
+        open_sockets
    }

    /// Given a socket, scan it self.tries times.
@@ -258,10 +134,10 @@ impl Scanner {
    async fn scan_socket(
        &self,
        socket: SocketAddr,
-        udp_payloads: Option<Arc<UdpPayloadLookup>>,
-    ) -> io::Result<PortStatus> {
+        udp_map: BTreeMap<Vec<u16>, Vec<u8>>,
+    ) -> io::Result<SocketAddr> {
        if self.udp {
-            return self.scan_udp_socket(socket, udp_payloads).await;
+            return self.scan_udp_socket(socket, udp_map).await;
        }

        let tries = self.tries.get();
@@ -275,16 +151,9 @@ impl Scanner {
                    self.fmt_ports(socket);

                    debug!("Return Ok after {nr_try} tries");
-                    return Ok(PortStatus::Open(socket));
+                    return Ok(socket);
                }
                Err(e) => {
-                    // A refused connection is a definitive answer, so there is
-                    // no point in retrying it.
-                    if self.report_closed && e.kind() == io::ErrorKind::ConnectionRefused {
-                        self.fmt_closed_port(socket);
-                        return Ok(PortStatus::Closed(socket));
-                    }
-
                    let mut error_string = e.to_string();

                    assert!(!error_string.to_lowercase().contains("too many open files"), "Too many open files. Please reduce batch size. The default is 5000. Try -b 2500.");
@@ -303,17 +172,19 @@ impl Scanner {
    async fn scan_udp_socket(
        &self,
        socket: SocketAddr,
-        udp_payloads: Option<Arc<UdpPayloadLookup>>,
-    ) -> io::Result<PortStatus> {
-        let payload: &[u8] = udp_payloads
-            .as_ref()
-            .and_then(|m| m.get(&socket.port()).copied())
-            .unwrap_or(b"");
+        udp_map: BTreeMap<Vec<u16>, Vec<u8>>,
+    ) -> io::Result<SocketAddr> {
+        let mut payload: Vec<u8> = Vec::new();
+        for (key, value) in udp_map {
+            if key.contains(&socket.port()) {
+                payload = value;
+            }
+        }

        let tries = self.tries.get();
        for _ in 1..=tries {
-            match self.udp_scan(socket, payload, self.timeout).await {
-                Ok(true) => return Ok(PortStatus::Open(socket)),
+            match self.udp_scan(socket, &payload, self.timeout).await {
+                Ok(true) => return Ok(socket),
                Ok(false) => continue,
                Err(e) => return Err(e),
            }
@@ -414,7 +285,7 @@ impl Scanner {
                }
            }
            Err(e) => {
-                debug!("Error binding UDP socket: {e:?}");
+                println!("Err E binding sock {e:?}");
                Err(e)
            }
        }
@@ -422,120 +293,12 @@ impl Scanner {

    /// Formats and prints the port status
    fn fmt_ports(&self, socket: SocketAddr) {
-        if self.print_open_ports && !self.greppable {
+        if !self.greppable {
            if self.accessible {
-                println_safe(format_args!("Open {socket}"));
+                println!("Open {socket}");
            } else {
-                println_safe(format_args!("Open {}", socket.to_string().purple()));
-            }
-        }
-    }
-
-    /// Prints a closed port (CLI output only, never in greppable mode).
-    fn fmt_closed_port(&self, socket: SocketAddr) {
-        if self.print_open_ports && !self.greppable {
-            if self.accessible {
-                println_safe(format_args!("Closed {socket}"));
-            } else {
-                println_safe(format_args!("Closed {}", socket.to_string().red()));
+                println!("Open {}", socket.to_string().purple());
            }
        }
    }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    use crate::input::{PortRanges, ScanOrder};
-
-    // These tests never open sockets: they only build a `Scanner` or inspect
-    // the payload table generated by build.rs.
-
-    fn test_scanner() -> Scanner {
-        let addrs = vec!["127.0.0.1".parse::<IpAddr>().unwrap()];
-        let strategy = PortStrategy::pick(&Some(PortRanges(vec![(1, 1)])), None, ScanOrder::Serial);
-        Scanner::new(
-            &addrs,
-            1,
-            Duration::from_millis(100),
-            1,
-            false,
-            strategy,
-            false,
-            Vec::new(),
-            false,
-        )
-    }
-
-    #[test]
-    fn library_scanner_is_quiet_by_default() {
-        let scanner = test_scanner();
-
-        assert!(!scanner.print_open_ports);
-    }
-
-    #[test]
-    fn cli_can_enable_open_port_output() {
-        let scanner = test_scanner().with_open_port_output();
-
-        assert!(scanner.print_open_ports);
-    }
-
-    #[test]
-    fn closed_ports_are_not_reported_by_default() {
-        assert!(!test_scanner().report_closed);
-    }
-
-    #[test]
-    fn closed_port_reporting_is_opt_in() {
-        assert!(test_scanner().with_closed_ports().report_closed);
-    }
-
-    #[test]
-    fn no_interval_by_default() {
-        assert!(test_scanner().interval.is_zero());
-    }
-
-    #[test]
-    fn with_interval_sets_the_delay_between_ports() {
-        let scanner = test_scanner().with_interval(Duration::from_millis(250));
-
-        assert_eq!(scanner.interval, Duration::from_millis(250));
-    }
-
-    /// Regression test for https://github.com/bee-san/RustScan/issues/933:
-    /// the SNMP public-walk probe must be the exact 33-byte BER packet, with
-    /// the literal `public` community string intact. The old hexdigits-only
-    /// decoding mangled it into a 28-byte probe that agents never answered.
-    #[test]
-    fn udp_snmp_probe_bytes_match_nmap() {
-        let payload = get_parsed_data()
-            .iter()
-            .find(|(ports, _)| ports.contains(&161))
-            .map(|(_, payload)| payload)
-            .expect("no UDP payload registered for port 161");
-        let expected: Vec<u8> = vec![
-            0x30, 0x1f, 0x02, 0x01, 0x00, 0x04, 0x06, b'p', b'u', b'b', b'l', b'i', b'c', 0xa1,
-            0x12, 0x02, 0x01, 0x00, 0x02, 0x01, 0x00, 0x02, 0x01, 0x00, 0x30, 0x07, 0x30, 0x05,
-            0x06, 0x01, 0x00, 0x05, 0x00,
-        ];
-        assert_eq!(*payload, expected);
-    }
-
-    /// The SSDP probe mixes `\xNN` escapes, `\"` escapes and literal text
-    /// across two quoted segments: segments must decode and concatenate
-    /// with no separators.
-    #[test]
-    fn udp_ssdp_probe_decodes_escapes_and_literal_text() {
-        let payload = get_parsed_data()
-            .iter()
-            .find(|(ports, _)| ports.contains(&1900))
-            .map(|(_, payload)| payload)
-            .expect("no UDP payload registered for port 1900");
-        let expected =
-            b"M-SEARCH * HTTP/1.1\r\nHost: 239.255.255.250:1900\r\nMan: \"ssdp:discover\"\r\nMX: 5\r\nST: ssdp:all\r\n\r\n"
-                .to_vec();
-        assert_eq!(*payload, expected);
-    }
-}
@@ -1,78 +1,55 @@
 use itertools::{iproduct, Product};
-use std::iter::FusedIterator;
 use std::net::{IpAddr, SocketAddr};
-use std::slice;

-/// An iterator that receives a slice of IPs and ports and returns a
-/// [`SocketAddr`] for each IP/port pair until all combinations are exhausted.
-///
-/// The goal of this iterator is to walk every IP and port combination
-/// *without* allocating a big intermediate buffer — the alternative would be
-/// materialising a `Vec<SocketAddr>` of every pair up front.
-///
-/// # Ordering
-///
-/// The IP/port order is intentionally reversed inside `product_it`: we want
-/// `iproduct!` to iterate *all IPs for one port* before advancing to the next
-/// port ("hold the port, go through all the IPs, then advance the port").
-///
-/// # Example
-///
-/// `SocketIterator` lives in a private module, so this example is not run as
-/// a doctest; `goes_through_every_ip_port_combination` checks the same order.
-///
-/// ```ignore
-/// # use std::net::IpAddr;
-/// let ips = [
-///     "127.0.0.1".parse::<IpAddr>().unwrap(),
-///     "192.168.0.1".parse::<IpAddr>().unwrap(),
-/// ];
-/// let ports = [80u16, 443];
-///
-/// let mut it = SocketIterator::new(&ips, &ports);
-/// assert_eq!(it.next(), Some("127.0.0.1:80".parse().unwrap()));
-/// assert_eq!(it.next(), Some("192.168.0.1:80".parse().unwrap()));
-/// assert_eq!(it.next(), Some("127.0.0.1:443".parse().unwrap()));
-/// assert_eq!(it.next(), Some("192.168.0.1:443".parse().unwrap()));
-/// assert_eq!(it.next(), None);
-/// ```
-#[derive(Clone)]
 pub struct SocketIterator<'s> {
-    // No boxing: the iterator owns the concrete slice iterators directly.
-    // This keeps `SocketIterator` allocation-free and makes `Clone` free too.
-    product_it: Product<slice::Iter<'s, u16>, slice::Iter<'s, IpAddr>>,
+    // product_it is a cartesian product iterator over
+    // the slices of ports and IP addresses.
+    //
+    // The IP/port order is intentionally reversed here since we want
+    // the itertools::iproduct! macro below to generate the pairs with
+    // all the IPs for one port before moving on to the next one
+    // ("hold the port, go through all the IPs, then advance the port...").
+    // See also the comments in the iterator implementation for an example.
+    product_it:
+        Product<Box<std::slice::Iter<'s, u16>>, Box<std::slice::Iter<'s, std::net::IpAddr>>>,
 }

+/// An iterator that receives a slice of IPs and ports and returns a Socket
+/// for each IP and port pair until all of these combinations are exhausted.
+/// The goal of this iterator is to go over every IP and port combination
+/// without generating a big memory footprint. The alternative would be
+/// generating a vector containing all these combinations.
 impl<'s> SocketIterator<'s> {
    pub fn new(ips: &'s [IpAddr], ports: &'s [u16]) -> Self {
+        let ports_it = Box::new(ports.iter());
+        let ips_it = Box::new(ips.iter());
        Self {
-            // `iproduct!` calls `.into_iter()` on each argument; `slice::Iter`
-            // is already an iterator, so this is a no-op (no allocation).
-            product_it: iproduct!(ports.iter(), ips.iter()),
+            product_it: iproduct!(ports_it, ips_it),
        }
    }
 }

+#[allow(clippy::doc_link_with_quotes)]
 impl Iterator for SocketIterator<'_> {
    type Item = SocketAddr;

-    /// Returns the next socket, or `None` when all combinations are exhausted.
-    /// Every IP is paired with the same port until the port advances.
+    /// Returns a socket based on the combination of one of the provided
+    /// IPs and ports or None when these combinations are exhausted. Every
+    /// IP will have the same port until a port is incremented.
+    ///
+    /// let it = SocketIterator::new(&["127.0.0.1", "192.168.0.1"], &[80, 443]);
+    /// it.next(); // 127.0.0.1:80
+    /// it.next(); // 192.168.0.1:80
+    /// it.next(); // 127.0.0.1:443
+    /// it.next(); // 192.168.0.1:443
+    /// it.next(); // None
    fn next(&mut self) -> Option<Self::Item> {
        self.product_it
            .next()
            .map(|(port, ip)| SocketAddr::new(*ip, *port))
    }
-
-    // Delegate the size hint so callers like `collect()` can pre-size buffers.
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.product_it.size_hint()
-    }
 }

-// `Product` and `slice::Iter` are both fused, so we are too.
-impl FusedIterator for SocketIterator<'_> {}
-
 #[cfg(test)]
 mod tests {
    use super::SocketIterator;
@@ -95,53 +72,4 @@ mod tests {
        assert_eq!(Some(SocketAddr::new(addrs[1], ports[2])), it.next());
        assert_eq!(None, it.next());
    }
-
-    #[test]
-    fn size_hint_is_exact() {
-        let addrs = ["127.0.0.1".parse::<IpAddr>().unwrap()];
-        let ports: Vec<u16> = vec![22, 80, 443];
-        let mut it = SocketIterator::new(&addrs, &ports);
-
-        assert_eq!(it.size_hint(), (3, Some(3)));
-        it.next();
-        assert_eq!(it.size_hint(), (2, Some(2)));
-    }
-
-    #[test]
-    fn clone_resumes_independently() {
-        let addrs = [
-            "127.0.0.1".parse::<IpAddr>().unwrap(),
-            "192.168.0.1".parse::<IpAddr>().unwrap(),
-        ];
-        let ports: Vec<u16> = vec![22, 80];
-
-        let mut a = SocketIterator::new(&addrs, &ports);
-        assert_eq!(a.next(), Some(SocketAddr::new(addrs[0], ports[0])));
-        let b = a.clone(); // b starts where a is now
-
-        // 2 IPs x 2 ports = 4 sockets, one of which was consumed before cloning.
-        let rest = [
-            SocketAddr::new(addrs[1], ports[0]),
-            SocketAddr::new(addrs[0], ports[1]),
-            SocketAddr::new(addrs[1], ports[1]),
-        ];
-        assert_eq!(a.collect::<Vec<_>>(), rest);
-        assert_eq!(b.collect::<Vec<_>>(), rest);
-    }
-
-    #[test]
-    fn empty_inputs_yield_nothing() {
-        let addrs = ["127.0.0.1".parse::<IpAddr>().unwrap()];
-        let ports = [22u16];
-
-        for mut it in [
-            SocketIterator::new(&[], &ports),
-            SocketIterator::new(&addrs, &[]),
-        ] {
-            assert_eq!(it.size_hint(), (0, Some(0)));
-            assert_eq!(it.next(), None);
-            // Stays exhausted, as promised by the `FusedIterator` impl.
-            assert_eq!(it.next(), None);
-        }
-    }
 }
@@ -46,9 +46,12 @@
 //!
 //! - `fixtures/test_rustscan_scripts.toml`
 //!
-//! Metadata-only test fixture:
+//! Script file examples:
 //!
-//! - `fixtures/.rustscan_scripts/test_script.txt`
+//! - `fixtures/test_script.py`
+//! - `fixtures/test_script.pl`
+//! - `fixtures/test_script.sh`
+//! - `fixtures/test_script.txt`
 //!
 //! `call_format` in script files can be of 2 variants:
 //!
@@ -407,7 +410,7 @@ mod tests {
    fn find_and_parse_scripts() {
        let scripts = find_scripts("fixtures/.rustscan_scripts".into()).unwrap();
        let scripts = parse_scripts(scripts);
-        assert_eq!(scripts.len(), 1);
+        assert_eq!(scripts.len(), 4);
    }

    #[test]
@@ -447,7 +450,7 @@ mod tests {
        assert_eq!(script_f.ports_separator, Some(",".to_string()));
        assert_eq!(
            script_f.call_format,
-            Some("fixture {{ip}} {{port}}".to_string())
+            Some("nmap -vvv -p {{port}} {{ip}}".to_string())
        );
    }

@@ -1,55 +1,20 @@
 //! Utilities for terminal output during scanning.

-use std::io::Write;
-
-/// Prints a single line to stdout without ever panicking.
-///
-/// `println!` panics when writing to stdout fails, which is fatal under the
-/// `panic = "abort"` release profile. That includes the `BrokenPipe` error
-/// produced when a downstream consumer (e.g. `rustscan -g ... | head`)
-/// closes the pipe, so instead the process exits quietly when that happens.
-/// Other output errors are reported on stderr before exiting.
-///
-/// All user-facing output should go through this function (the `warning!`,
-/// `detail!`, `output!` and `funny_opening!` macros already do) instead of
-/// `println!`.
-pub fn println_safe(args: std::fmt::Arguments<'_>) {
-    match writeln!(std::io::stdout().lock(), "{args}") {
-        Ok(()) => {}
-        Err(e) if e.kind() == std::io::ErrorKind::BrokenPipe => {
-            // the reader end of the pipe is gone; nothing left to print to
-            std::process::exit(0);
-        }
-        Err(e) => {
-            let _ = writeln!(std::io::stderr(), "rustscan: failed writing to stdout: {e}");
-            std::process::exit(1);
-        }
-    }
-}
-
 /// Terminal User Interface Module for RustScan
 /// Defines macros to use
 #[macro_export]
 macro_rules! warning {
    ($name:expr) => {
-        $crate::tui::println_safe(format_args!(
-            "{} {}",
-            ansi_term::Colour::Red.bold().paint("[!]"),
-            $name
-        ));
+        println!("{} {}", ansi_term::Colour::Red.bold().paint("[!]"), $name);
    };
    ($name:expr, $greppable:expr, $accessible:expr) => {
        // if not greppable then print, otherwise no else statement so do not print.
        if !$greppable {
            if $accessible {
                // Don't print the ascii art
-                $crate::tui::println_safe(format_args!("{}", $name));
+                println!("{}", $name);
            } else {
-                $crate::tui::println_safe(format_args!(
-                    "{} {}",
-                    ansi_term::Colour::Red.bold().paint("[!]"),
-                    $name
-                ));
+                println!("{} {}", ansi_term::Colour::Red.bold().paint("[!]"), $name);
            }
        }
    };
@@ -58,24 +23,16 @@ macro_rules! warning {
 #[macro_export]
 macro_rules! detail {
    ($name:expr) => {
-        $crate::tui::println_safe(format_args!(
-            "{} {}",
-            ansi_term::Colour::Blue.bold().paint("[~]"),
-            $name
-        ));
+        println!("{} {}", ansi_term::Colour::Blue.bold().paint("[~]"), $name);
    };
    ($name:expr, $greppable:expr, $accessible:expr) => {
        // if not greppable then print, otherwise no else statement so do not print.
        if !$greppable {
            if $accessible {
                // Don't print the ascii art
-                $crate::tui::println_safe(format_args!("{}", $name));
+                println!("{}", $name);
            } else {
-                $crate::tui::println_safe(format_args!(
-                    "{} {}",
-                    ansi_term::Colour::Blue.bold().paint("[~]"),
-                    $name
-                ));
+                println!("{} {}", ansi_term::Colour::Blue.bold().paint("[~]"), $name);
            }
        }
    };
@@ -84,24 +41,24 @@ macro_rules! detail {
 #[macro_export]
 macro_rules! output {
    ($name:expr) => {
-        $crate::tui::println_safe(format_args!(
+        println!(
            "{} {}",
            ansi_term::Colour::RGB(0, 255, 9).bold().paint("[>]"),
            $name
-        ));
+        );
    };
    ($name:expr, $greppable:expr, $accessible:expr) => {
        // if not greppable then print, otherwise no else statement so do not print.
        if !$greppable {
            if $accessible {
                // Don't print the ascii art
-                $crate::tui::println_safe(format_args!("{}", $name));
+                println!("{}", $name);
            } else {
-                $crate::tui::println_safe(format_args!(
+                println!(
                    "{} {}",
                    ansi_term::Colour::RGB(0, 255, 9).bold().paint("[>]"),
                    $name
-                ));
+                );
            }
        }
    };
@@ -144,6 +101,6 @@ macro_rules! funny_opening {
        ];
        let random_quote = quotes.choose(&mut rand::rng()).unwrap();

-        $crate::tui::println_safe(format_args!("{}\n", random_quote));
+        println!("{}\n", random_quote);
    };
 }
@@ -1,32 +0,0 @@
-use rustscan::generated::get_parsed_data;
-use rustscan::scanner::build_udp_payload_lookup;
-
-#[test]
-fn udp_payload_lookup_contains_common_udp_ports() {
-    let udp_map = get_parsed_data();
-    let lookup = build_udp_payload_lookup(udp_map);
-
-    // These are common UDP services; the payload database should include them.
-    assert!(
-        lookup.contains_key(&53),
-        "expected UDP payload for DNS (53)"
-    );
-    assert!(
-        lookup.contains_key(&123),
-        "expected UDP payload for NTP (123)"
-    );
-}
-
-#[test]
-fn udp_payload_lookup_payloads_are_non_empty_for_known_ports() {
-    let udp_map = get_parsed_data();
-    let lookup = build_udp_payload_lookup(udp_map);
-
-    // Don't assert exact bytes (the generated payload set may evolve),
-    // but it should not be empty for these well-known protocols.
-    let dns = lookup.get(&53).expect("missing DNS payload");
-    assert!(!dns.is_empty(), "DNS payload should not be empty");
-
-    let ntp = lookup.get(&123).expect("missing NTP payload");
-    assert!(!ntp.is_empty(), "NTP payload should not be empty");
-}