test PR

Fix markdown-link-checker workflow (#542 )
* Fix markdown-link-checker workflow Added a configuration file that tells MLC to ignore the URLs in .github\workflows\mlc_config.json as MLC is falsely reporting these as dead * Update markdown.yml
2026-11-07 09:46:04 -10:00 · 2024-04-06 21:56:49 +01:00 · 2024-04-06 21:28:53 +01:00 · 2024-03-16 01:56:02 +00:00 · 2024-03-16 00:31:38 +00:00 · 2024-03-16 00:11:55 +00:00
33 changed files with 1504 additions and 1592 deletions
@@ -0,0 +1,21 @@
+version: 2
+updates:
+- package-ecosystem: cargo
+  directory: "/"
+  schedule:
+    interval: daily
+  open-pull-requests-limit: 10
+  ignore:
+  - dependency-name: anyhow
+    versions:
+    - 1.0.38
+    - 1.0.39
+  - dependency-name: serde
+    versions:
+    - 1.0.123
+  - dependency-name: futures
+    versions:
+    - 0.3.12
+  - dependency-name: rlimit
+    versions:
+    - 0.5.3
@@ -1,10 +0,0 @@
-name: Check Markdown links
-
-on: push
-
-jobs:
-  markdown-link-check:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@master
-    - uses: gaurav-nelson/github-action-markdown-link-check@v1
@@ -1,70 +0,0 @@
-on: [push, pull_request]
-
-name: Continuous integration
-
-jobs:
-  check:
-    name: Check
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: stable
-          override: true
-      - uses: actions-rs/cargo@v1
-        with:
-          command: check
-
-  test:
-    name: Test Suite
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: stable
-          override: true
-      - uses: actions-rs/cargo@v1
-        with:
-          command: test
-
-  fmt:
-    name: Rustfmt
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: stable
-          override: true
-      - run: rustup component add rustfmt
-      - uses: actions-rs/cargo@v1
-        with:
-          command: fmt
-          args: --all -- --check
-
-  clippy:
-    name: Clippy linting
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions-rs/toolchain@v1
-        with:
-            toolchain: stable
-            components: clippy
-            override: true
-      - uses: actions-rs/clippy-check@v1
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          args: --all-features
-
-  links:
-        name: markdown-link-check
-        runs-on: ubuntu-latest
-        steps:
-        - uses: actions/checkout@master
-        - uses: gaurav-nelson/github-action-markdown-link-check@v1
@@ -0,0 +1,92 @@
+name: Build
+on:
+  pull_request:
+  push:
+    branches:
+      - master
+  schedule:
+    - cron: '00 01 * * *'
+
+jobs:
+  check:
+    name: Check
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v2
+
+      - name: Install stable toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+          override: true
+
+      - uses: Swatinem/rust-cache@v1
+
+      - name: Run cargo check
+        uses: actions-rs/cargo@v1
+        with:
+          command: check
+
+  test:
+    name: Test Suite
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        rust: [stable]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v2
+
+      - name: Install stable toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: ${{ matrix.rust }}
+          override: true
+
+      - uses: Swatinem/rust-cache@v1
+
+      - name: Run cargo test
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+
+  lints:
+    name: Lints
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v2
+        with:
+          submodules: true
+
+      - name: Install stable toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+          override: true
+          components: rustfmt, clippy
+
+      - uses: Swatinem/rust-cache@v1
+
+      - name: Run cargo fmt
+        uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --all -- --check
+
+      - name: Run cargo clippy
+        uses: actions-rs/cargo@v1
+        with:
+          command: clippy
+          args: -- -D warnings
+
+      - name: Run rustdoc lints
+        uses: actions-rs/cargo@v1
+        with:
+          command: doc
+          args: --workspace --all-features --no-deps --document-private-items
@@ -1,15 +0,0 @@
-on:
-  push:
-    tags: '*'
-
-jobs:
-  homebrew:
-    name: Bump Homebrew formula
-    runs-on: ubuntu-latest
-    steps:
-      - uses: mislav/bump-homebrew-formula-action@v1
-        with:
-          # A PR will be sent to github.com/Homebrew/homebrew-core to update this formula:
-          formula-name: rustscan
-        env:
-          COMMITTER_TOKEN: ${{secrets.brew}}
@@ -0,0 +1,46 @@
+name: Publish Docker image
+
+on:
+  push:
+    tags:
+      - 'v[0-9]+.[0-9]+.[0-9]+'
+  release:
+    types: [published]
+  pull_request:
+    branches:
+      - master
+    paths:
+      - 'Dockerfile'
+      - 'Cargo.toml'
+      - 'Cargo.lock'
+      - 'contributing.Dockerfile'
+      - '.github/workflows/docker.yml'
+
+jobs:
+  push_to_registry:
+    name: Push Docker image to Docker Hub
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out the repo
+        uses: actions/checkout@v3
+
+      - name: Log in to Docker Hub
+        uses: docker/login-action@v2
+        with:
+          password: ${{ secrets.DOCKER_PASSWORD }}
+          username: ${{ secrets.DOCKER_USERNAME }}
+
+      - name: Extract metadata (tags, labels) for Docker
+        id: meta
+        uses: docker/metadata-action@v4
+        with:
+          images: rustscan/rustscan
+          flavor: latest=true
+
+      - name: Build and push Docker image
+        uses: docker/build-push-action@v3
+        with:
+          context: .
+          push: ${{ contains(fromJson('["push", "release"]'), github.event_name) }} # Publish to docker registry only on push event or new release.
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
@@ -16,3 +16,4 @@ jobs:
    - uses: gaurav-nelson/github-action-markdown-link-check@v1
      with:
        use-quiet-mode: 'yes'
+        config-file: './.github/workflows/mlc_config.json'
@@ -0,0 +1,14 @@
+{
+    "_comment": "Config for markdown-link-check. Resolves issue #540.",
+    "ignorePatterns": [
+      {
+        "pattern": "^https://github.com/RustScan/RustScan/workflows/Continuous%20integration/badge.svg"
+      },
+      {
+        "pattern": "^https://crates.io/crates/rustscan/"
+      },
+      {
+        "pattern": "^https://bees.substack.com/p/making-hacking-accessible"
+      }
+    ]
+  }
@@ -0,0 +1,230 @@
+name: Release
+on:
+  push:
+    tags:
+      - 'v[0-9]+.[0-9]+.[0-9]+'
+  pull_request:
+    branches:
+      - master
+    paths:
+      - 'Cargo.toml'
+      - 'Cargo.lock'
+      - '.github/workflows/release.yml'
+
+env:
+  BIN_NAME: rustscan
+  PROJECT_NAME: rustscan
+  REPO_NAME: RustScan/RustScan
+  # BREW_TAP: RustScan/homebrew-tap
+
+jobs:
+  dist:
+    name: Dist
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false # don't fail other jobs if one fails
+      matrix:
+        build: [x86_64-linux, x86_64-macos, x86_64-windows] #, x86_64-win-gnu, win32-msvc
+        include:
+          - build: x86_64-linux
+            os: ubuntu-20.04
+            rust: stable
+            target: x86_64-unknown-linux-gnu
+            cross: false
+          - build: x86_64-macos
+            os: macos-latest
+            rust: stable
+            target: x86_64-apple-darwin
+            cross: false
+          - build: x86_64-windows
+            os: windows-2019
+            rust: stable
+            target: x86_64-pc-windows-msvc
+            cross: false
+        # - build: aarch64-linux
+        #   os: ubuntu-20.04
+        #   rust: stable
+        #   target: aarch64-unknown-linux-gnu
+        # - build: aarch64-macos
+        #   os: macos-latest
+        #   rust: stable
+        #   target: aarch64-apple-darwin
+        # - build: x86_64-win-gnu
+        #   os: windows-2019
+        #   rust: stable-x86_64-gnu
+        #   target: x86_64-pc-windows-gnu
+        # - build: win32-msvc
+        #   os: windows-2019
+        #   rust: stable
+        #   target: i686-pc-windows-msvc
+
+    steps:
+      - name: Strip release binary (linux and macos)
+        if: matrix.build == 'x86_64-windows' # Windows is missing some dependencies
+        run: |
+          git config --global pack.windowMemory "100m"
+          git config --global pack.packSizeLimit "100m"
+          git config --global pack.threads "1" 
+          git config --global pack.deltaCacheSize "512m"
+
+      - name: Install python 3.10 for windows
+        if: matrix.build == 'x86_64-windows' # Windows is missing some dependencies
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.10'
+
+      - name: Checkout sources
+        uses: actions/checkout@v2
+        with:
+          submodules: true
+
+      - name: Install ${{ matrix.rust }} toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: ${{ matrix.rust }}
+          target: ${{ matrix.target }}
+          override: true
+
+      - name: Run cargo test
+        uses: actions-rs/cargo@v1
+        with:
+          use-cross: ${{ matrix.cross }}
+          command: test
+          args: --release --locked --target ${{ matrix.target }}
+
+      - name: Build release binary
+        uses: actions-rs/cargo@v1
+        with:
+          use-cross: ${{ matrix.cross }}
+          command: build
+          args: --release --locked --target ${{ matrix.target }}
+
+      - name: Strip release binary (linux and macos)
+        if: matrix.build == 'x86_64-linux' || matrix.build == 'x86_64-macos'
+        run: strip "target/${{ matrix.target }}/release/$BIN_NAME"
+
+      - name: Strip release binary (arm)
+        if: matrix.build == 'aarch64-linux'
+        run: |
+          docker run --rm -v \
+            "$PWD/target:/target:Z" \
+            rustembedded/cross:${{ matrix.target }} \
+            aarch64-linux-gnu-strip \
+            /target/${{ matrix.target }}/release/$BIN_NAME
+      - name: Build archive
+        shell: bash
+        run: |
+          mkdir dist
+          if [ "${{ matrix.os }}" = "windows-2019" ]; then
+            cp "target/${{ matrix.target }}/release/$BIN_NAME.exe" "dist/"
+          else
+            cp "target/${{ matrix.target }}/release/$BIN_NAME" "dist/"
+          fi
+      - uses: actions/[email protected]
+        with:
+          name: bins-${{ matrix.build }}
+          path: dist
+
+  publish:
+    name: Publish
+    needs: [dist]
+    if: contains(fromJson('["push", "schedule"]'), github.event_name) && startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v2
+        with:
+          submodules: false
+
+      - uses: actions/download-artifact@v2
+        # with:
+        #   path: dist
+      # - run: ls -al ./dist
+      - run: ls -al bins-*
+
+      - name: Calculate tag name
+        run: |
+          name=dev
+          if [[ $GITHUB_REF == refs/tags/v* ]]; then
+            name=${GITHUB_REF:10}
+          fi
+          echo ::set-output name=val::$name
+          echo TAG=$name >> $GITHUB_ENV
+        id: tagname
+
+      - name: Build archive
+        shell: bash
+        run: |
+          set -ex
+          rm -rf tmp
+          mkdir tmp
+          mkdir dist
+          for dir in bins-* ; do
+              platform=${dir#"bins-"}
+              unset exe
+              if [[ $platform =~ "windows" ]]; then
+                  exe=".exe"
+              fi
+              pkgname=$PROJECT_NAME-$TAG-$platform
+              mkdir tmp/$pkgname
+              # cp LICENSE README.md tmp/$pkgname
+              mv bins-$platform/$BIN_NAME$exe tmp/$pkgname
+              chmod +x tmp/$pkgname/$BIN_NAME$exe
+              if [ "$exe" = "" ]; then
+                  tar cJf dist/$pkgname.tar.xz -C tmp $pkgname
+              else
+                  (cd tmp && 7z a -r ../dist/$pkgname.zip $pkgname)
+              fi
+          done
+      - name: Upload binaries to release
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: dist/*
+          file_glob: true
+          tag: ${{ steps.tagname.outputs.val }}
+          overwrite: true
+
+      - name: Extract version
+        id: extract-version
+        run: |
+          printf "::set-output name=%s::%s\n" tag-name "${GITHUB_REF#refs/tags/}"
+      - uses: mislav/bump-homebrew-formula-action@v1
+        with:
+          formula-path: ${{env.PROJECT_NAME}}.rb
+          homebrew-tap: ${{ env.BREW_TAP }}
+          download-url: 'https://github.com/${{ env.REPO_NAME }}/releases/download/${{ steps.extract-version.outputs.tag-name }}/${{env.PROJECT_NAME}}-${{ steps.extract-version.outputs.tag-name }}-x86_64-macos.tar.xz'
+          commit-message: updating formula for ${{ env.PROJECT_NAME }}
+        env:
+          COMMITTER_TOKEN: ${{ secrets.COMMITTER_TOKEN }}
+        #
+        # you can use this initial file in your homebrew-tap if you don't have an initial formula:
+        # <projectname>.rb
+        #
+        # class <Projectname capitalized> < Formula
+        #   desc "A test formula"
+        #   homepage "http://www.example.com"
+        #   url "-----"
+        #   version "-----"
+        #   sha256 "-----"
+
+        #   def install
+        #     bin.install "<bin-name>"
+        #   end
+        # end
+
+      # Uncomment this section if you want to release your package to crates.io
+      # Before publishing, make sure you have filled out the following fields:
+      # license or license-file, description, homepage, documentation, repository, readme.
+      # Read more: https://doc.rust-lang.org/cargo/reference/publishing.html
+
+      - name: Install ${{ matrix.rust }} toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: ${{ matrix.rust }}
+          target: ${{ matrix.target }}
+      - run: cargo publish --token ${CRATES_TOKEN}
+        env:
+          CRATES_TOKEN: ${{ secrets.CRATES_TOKEN }}
@@ -1,7 +1,7 @@
 [package]
 name = "rustscan"
-version = "1.10.0"
-authors = ["Bee <brando[email protected]>"]
+version = "2.1.1"
+authors = ["Autumn <autum[email protected]>"]
 edition = "2018"
 description = "Faster Nmap Scanning with Rust"
 homepage = "https://github.com/rustscan/rustscan"
@@ -19,24 +19,24 @@ exclude = [
 [dependencies]
 colored = "2.0.0"
 structopt = "0.3.20"
-async-std = "1.6.4"
+async-std = "1.7.0"
 futures = "0.3"
-rlimit = "0.5.2"
+rlimit = "0.8.3"
 shell-words = "1.0.0"
 log = "0.4.0"
-env_logger = "0.7.1"
+env_logger = "0.8.2"
 dirs = "3.0.1"
 gcd = "2.0.1"
 rand = "0.7.3"
 colorful = "0.2.1"
 ansi_term = "0.12.1"
 toml = "0.5.7"
-serde = "1.0.117"
+serde = "1.0.124"
 serde_derive = "1.0.116"
-cidr-utils = "0.5.0"
+cidr-utils = "0.5.1"
 itertools = "0.9.0"
-trust-dns-resolver = { version = "0.19.5", features = ["dns-over-rustls"] }
-anyhow = "1.0.33"
+trust-dns-resolver = { version = "0.21.1", features = ["dns-over-rustls"] }
+anyhow = "1.0.40"
 subprocess = "0.2.6"
 text_placeholder = { version = "0.4", features = ["struct_context"] }

@@ -50,3 +50,8 @@ section = "rust"
 [profile.release]
 lto = true
 panic = 'abort'
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[[bin]]
+name = "rustscan"
+path = "src/main.rs"
@@ -3,17 +3,18 @@ LABEL maintainer="RustScan <https://github.com/RustScan>"
 RUN apk add --no-cache build-base

 # Encourage some layer caching here rather then copying entire directory that includes docs to builder container ~CMN
-WORKDIR /usr/src/rustscan
+WORKDIR /app/rustscan
 COPY Cargo.toml Cargo.lock ./
 COPY src/ src/
-RUN cargo install --path .
+RUN cargo build --release

-FROM alpine:3.12
+FROM alpine:3.17
 LABEL author="Hydragyrum <https://github.com/Hydragyrum>"
+LABEL author="LeoFVO <https://github.com/LeoFVO>"
 RUN addgroup -S rustscan && \
    adduser -S -G rustscan rustscan && \
    ulimit -n 100000 && \
    apk add --no-cache nmap nmap-scripts wget
-COPY --from=builder /usr/local/cargo/bin/rustscan /usr/local/bin/rustscan
 USER rustscan
+COPY --from=builder /app/rustscan/target/release/rustscan /usr/local/bin/rustscan
 ENTRYPOINT [ "/usr/local/bin/rustscan" ]
@@ -1,438 +1,141 @@
-<p align="center">
-➡️
-<a href="https://discord.gg/GFrQsGy">Discord</a> |
- <a href="https://github.com/RustScan/RustScan#-full-installation-guide">Installation Guide</a> |
- <a href="https://github.com/RustScan/RustScan#-usage">Usage Guide</a>
- ⬅️
-<br>
+<div align="center" markdown="1">
+
+➡️ [Discord][discord] | [Installation Guide][toc-install] | [Usage Guide][usage-guide] ⬅️
+
 <img src="pictures/rustscan.png" height=400px width=400px>
-</p>
-<p align="center">
-<u><b> Turns a 17 minutes Nmap scan into 19 seconds. </b></u><br> Find all open ports <b>fast</b> with RustScan, automatically pipe them into Nmap.
-</p>
-<p align="center">
-<img alt="AUR version" src="https://img.shields.io/aur/version/rustscan">
-<img src="https://img.shields.io/badge/Built%20with-Rust-Purple">
-<img alt="GitHub commit activity" src="https://img.shields.io/github/commit-activity/w/Rustscan/Rustscan">
-<img alt="GitHub All Releases" src="https://img.shields.io/github/downloads/rustscan/rustscan/total?label=GitHub%20Downloads">
-<img alt="Crates.io" src="https://img.shields.io/crates/d/rustscan?label=Cargo%20Downloads">
-<img alt="Discord" src="https://img.shields.io/discord/736614461313515576">
-<img alt="Actions" src="https://github.com/RustScan/RustScan/workflows/Continuous%20integration/badge.svg?branch=master">
-</p>
-<hr>

-| <p align="center"><a href="https://hub.docker.com/r/cmnatic/rustscan">🐋 Docker (Recommended) </a></p>            | <p align="center"><a href="https://github.com/RustScan/RustScan/releases">👩‍💻 Kali / Debian </p>                 | <p align="center"><a href="https://aur.archlinux.org/packages/rustscan/">🏗️ Arch </a></p>                       | <p align="center"><a href="https://crates.io/crates/rustscan">🔧 Cargo (Universal) </a></p>                     |
-| ----------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
-| <p align="center"><img src="https://github.com/RustScan/RustScan/blob/master/pictures/docker.png?raw=true" /></p> | <p align="center"><img src="https://github.com/RustScan/RustScan/blob/master/pictures/kali.png?raw=true" /></p> | <p align="center"><img src="https://github.com/RustScan/RustScan/blob/master/pictures/arch.png?raw=true" /></p> | <p align="center"><img src="https://github.com/RustScan/RustScan/blob/master/pictures/rust.png?raw=true" /></p> |
-| `docker pull rustscan/rustscan:1.10.0` <p>[Usage](https://github.com/RustScan/RustScan#docker-whale)              | [Read the install guide](https://github.com/Rustscan/RustScan/blob/master/README.md#%EF%B8%8F-debian--kali)     | `yay -S rustscan`                                                                                               | `cargo install rustscan`                                                                                        |
+<!--<u>**The Modern Port Scanner.**</u>-->
+**Fast, smart, effective.**

-<hr>
+![Arch Linux package][badge-1] ![Built with Rust][badge-2] ![GitHub All Releases][badge-3] ![Crates.io][badge-4] ![Discord][badge-5] ![Actions][badge-6]
+
+
+---
+
+|                     🐋 `(Recommended)`                      |              👩‍💻               |             🏗️              |             🔧              |
+| :---------------------------------------------------------: | :---------------------------: | :-------------------------: | :-------------------------: |
+|               [![Docker][DockerPic]][Docker]                | [![Kali][Kali1]][Kali/Debian] | [![Arch][Arch]][Arch-Linux] | [![apple][apple]][Homebrew] |
+| `docker pull rustscan/rustscan:2.1.1`</br>[Docker][usage-0] | [Link to Documentation][kali] |      `yay -S rustscan`      |   `brew install rustscan`   |
+
+---
+
+</div>

 # 🤔 What is this?

-1. Find ports quickly using Rustscan (**3 seconds at its fastest**).
-2. Automatically runs `nmap` on those ports.
-3. ???
-4. Profit!
+![fast][speed-1]

-<table>
-  <tr>
-  <th>Name</th>
-    <th>⚡ Nmap <b>with RustScan</b> ⚡ </th>
-    <th>🐢 Nmap 🐢</th>
-  </tr>
-  <tr>
-  <th>Gif</th>
-    <td><img src="https://github.com/RustScan/RustScan/blob/master/pictures/with_rustscan.gif?raw=true" alt="The guy she tells you not to worry about"></td>
-    <td><img src="https://github.com/RustScan/RustScan/blob/master/pictures/without_rustscan.gif?raw=true" alt="You"></td>
-  </tr>
-  <tr>
-  <th>Time</th>
-    <td><b>39 seconds</b></td>
-    <td><b>17 minutes and 41 seconds</b></td>
-  </tr>
-</table>
-
-<sub><b>Note</b> This is an older gif. RustScan's current top speed is 3 seconds for all 65k ports. This gif is 26 seconds.</sub><br>
-
-RustScans **only** job is to reduce the friction between finding open ports and inputting them into nmap.
+The Modern Port Scanner. **Find ports quickly (3 seconds at its fastest)**. Run scripts through our scripting engine (Python, Lua, Shell supported).

 # ✨ Features

- Scans all 65k ports in **8 seconds** (on 10k batch size).
- Saves you time by automatically piping it into Nmap. No more manual copying and pasting!
- Does one thing and does it well. **Only** purpose is to improve Nmap, not replace it!
- Let's you choose what Nmap commands to run, or uses the default.
- IPv6 Support
+- Scans all 65k ports in **3 seconds**.
+- Full scripting engine support. Automatically pipe results into Nmap, or use our scripts (or write your own) to do whatever you want.
+- Adaptive learning. RustScan improves the more you use it. No bloated machine learning here, just basic maths.
+- The usuals you would expect. IPv6, CIDR, file input and more.
+- Automatically pipes ports into Nmap.

 ## ‼️ Important Links

-| Installation Guide                                                                     | Documentation                                            | Discord                                  |
-| -------------------------------------------------------------------------------------- | -------------------------------------------------------- | ---------------------------------------- |
-| 📖 [Installation Guide](https://github.com/RustScan/RustScan#-full-installation-guide) | 📚 [Documentation](https://rustscan.github.io/RustScan/) | 🦜 [Discord](https://discord.gg/GFrQsGy) |
+|         <!--Installation Guide-->          |          <!--Documentation-->          |       <!--Discord-->        |
+| :----------------------------------------: | :------------------------------------: | :-------------------------: |
+| :book: [Installation Guide][links-table-1] | :books: [Documentation][links-table-2] | :parrot: [Discord][discord] |

 ## 🙋 Table of Contents

- 📖 [Installation Guide](https://github.com/RustScan/RustScan#-full-installation-guide)
- 🐋 [Docker Usage](https://github.com/RustScan/RustScan#docker-whale)
- 🦜 [Discord](https://discord.gg/GFrQsGy)
- 🤸 [Usage](https://github.com/RustScan/RustScan#-usage)
- 🎪 [Community](https://github.com/RustScan/RustScan#-community)
+- 📖 [Installation Guide][toc-install]
+- 🐋 [Docker Usage][toc-docker-usage]
+- 🦜 [Discord][discord]
+- 🤸 [Usage][usage-1]
+- 🎪 [Community][toc-community]

 # 🔭 Why RustScan?

-Why spend time running fast scans and manually copying the ports, or waiting for a 20 minute scan to finish when you can just do all 65k ports in less than a minute?
+RustScan is a modern take on the port scanner. Sleek & fast. All while providing extensive extendability to you.

-![gif](https://github.com/RustScan/RustScan/blob/master/pictures/8seconds.gif?raw=true)
+Not to mention RustScan uses Adaptive Learning to improve itself over time, making it the best port scanner for **you**.

-**RustScan running in 8 seconds and finding all open ports out of 65k.**
+## 🧋 Speed

-## 📊 RustScan vs Nmap vs MassScan
+![fast][speed-1]

-| **Name**                                                                                   | RustScan | Nmap | Masscan |
-| ------------------------------------------------------------------------------------------ | -------- | ---- | ------- |
-| Fast                                                                                       | ✅       | ❌   | ✅      |
-| Actually useful                                                                            | ❌       | ✅   | ❌      |
-| Realises it's not useful, and pipes the only useful data into the only useful port scanner | ✅       | ❌   | ❌      |
+Speed is guaranteed via RustScan. However, if you want to run a slow scan due to stealth, that is possible too.
+
+Firstly, let's talk code.
+
+We have tests that check to see if RustScan is significantly slower than the previous version. If it is, the continuous integration fails, and we can't commit code to master unless we make it faster.
+
+[HyperFine][speed-2] is used to monitor RustScan's performance over time to answer the question, "Are we getting faster? Are we getting slower?".
+
+Every pull request is reviewed by **one** person, but more often than not, **two** people review it. We test it manually and ensure the code doesn't negatively affect performance.
+
+[Read more here][speed-3].
+
+## ⚙️ Extensible
+
+![scripts][extensible-1]
+
+### _RustScan piping results into the custom Python script_
+
+RustScan has a new scripting engine that allows anyone to write scripts in most languages. Python, Lua, and Shell are all supported.
+
+Want to take your found ports and pipe them into Nmap for further analysis? That's possible. Want to run `smb-enum` if SMB is found open? Possible.
+
+The possibilities are endless -- and you can write scripts in whatever language you feel comfortable with.
+
+[Read more here][extensible-2].
+
+## 🌊 Adaptive
+
+![adaptive][adaptive-1]
+
+### _RustScan automatically fine-tunes itself to match the host OS_
+
+RustScan has a cool set of features called "Adaptive Learning". These features "learn" about the environment you are scanning and how _you_ use RustScan to **improve itself over time**.
+
+We use this umbrella term for any feature that fits this criterion. The list constantly changes, so [check out our wiki for more information][adaptive-learning].
+
+## 👩‍🦯 Accessible
+
+![fast][accessible-1]
+
+RustScan is one of the first penetration testing tools that aims to be entirely accessible.
+
+[Most penetration testing tools are not accessible][accessible-2], which negatively affects the whole industry.
+
+RustScan has continuous integration testing that aims to ensure it is accessible, and we are constantly working on ways to improve our accessibility and ensure _everyone_ can use RustScan.

 # 📖 Full Installation Guide

-**You need Nmap**. If you have Kali Linux or Parrot OS installed, you already have Nmap. If not, [follow the nmap install guide](https://nmap.org/download.html).
-
-The easiest way to install RustScan is to use one of the packages provided for your system, such as HomeBrew or Yay for Arch Linux.
-
-The most universal way is to use `cargo`, Rust's built in package manager (think Pip but for Rust). [Follow this guide to installing Rust & Cargo](https://doc.rust-lang.org/cargo/getting-started/installation.html).
-
-If you face any issues at all, please leave a GitHub issue. We have only tested this on Linux, so there may be issues for Mac OS or Windows.
-
-Note: sometimes Rust doesn't add Cargo to the path. Please see [this issue](https://github.com/rust-lang/rustup/issues/2436) for how to fix that.
-
-## 🖥️ Debian / Kali
-
-Download the .deb file from the releases page:
-
-[https://github.com/RustScan/RustScan/releases](https://github.com/RustScan/RustScan/releases)
-
-Run the command `dpkg -i` on the file.
-
-Note: sometimes you can double click the file to achieve the same result.
-
-## Docker :whale:
-
-Docker is the recommended way of installing RustScan. This is because:
-
- It has a high open file descriptor limit, which is one of the [main problems](https://github.com/RustScan/RustScan/issues/40) with RustScan. Now you don't have to fiddle around trying to understand your OS.
- It works on all systems, regardless of OS. Even Windows, which we don't officially support.
- The Docker image uses the latest build from Cargo, our main source-of-truth package. This means that you will always be using the latest version.
- No need to install Rust, Cargo, or Nmap.
-
-To install Docker, [follow their guide](https://docs.docker.com/engine/install/).
-
-**Once Docker is installed, you can either build your own image using the `Dockerfile` (alpine) provided in the repo, or alternatively, use the published Docker image like below (most convenient)**
-
-Please see our [DockerHub](https://hub.docker.com/repository/docker/rustscan/rustscan) for further our published versions. However, we recommend using our latest **major** release [1.10.0](https://github.com/RustScan/RustScan/releases/tag/1.10.0)
-
-```
-Stable and supported: rustscan/rustscan:1.10.0
-
-Bleeding edge (run at your own risk!): rustscan/rustscan:latest
-```
-
-We strongly recommend using the `1.10.0` tag, as this is the latest major - stable - release of RustScan. This README uses the `1.10.0` image by default, however, note that the `latest` image is considered experimental. You can use all releases of Docker by visiting the [DockerHub Tags](https://hub.docker.com/r/rustscan/rustscan/tags) and replacing the command with the tag you desire. i.e. `docker pull rustscan/rustscan:1.10.0` can be `docker pull rustscan/rustscan:1.6.0`
-
-#### To get started:
-
-Simply run this command against the IP you want to target:
-
-```bash
-docker run -it --rm --name rustscan rustscan/rustscan:1.10.0 <rustscan arguments here> <ip address to scan>
-```
-
-Note: this will scan the Docker's localhost, not your own.
-
-Once done, you will no longer need to re-download the image (except when RustScan updates) and can use RustScan like a normal application.
-
-You will have to run this command every time, so we suggest aliasing it to something memorable.
-
-```bash
-alias rustscan='docker run -it --rm --name rustscan rustscan/rustscan:1.10.0'
-```
-
-Then we can scan:
-
-```bash
-rustscan 192.168.1.0/24 -t 500 -b 1500 -- -A
-```
-
-#### To build your own image:
-
-Download the repo:
-
-```bash
-git clone https://github.com/RustScan/RustScan.git
-```
-
-Ensure you navigate to the download location of the repo:
-
-```bash
-cd /path/to/download/RustScan
-```
-
-Build away!
-
-```bash
-docker build -t <yourimagename> .
-```
-
-## 🍺 HomeBrew
-
-**Note for Mac users** Mac OS has a very, very small ulimit size. This will negatively impact RustScan by a significant amount. Please use the Docker container, or tell RustScan to up the ulimit size on every run.
-
-```
-brew install rustscan
-```
-
-## 🔧 Building it yourself
-
-1. Git clone the repo.
-2. Install Rust. You can do this with `curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh` which we took from the Rust website https://www.rust-lang.org/tools/install
-3. cd into the Git repo, and run `cargo build --release`
-4. The binary is located at `target/release/rustscan`
-5. Symlink to the binary or something. Whatever you want!
+You can find our guide [here][install-1].

 ## 🦊 Community Distributions

 Here are all of RustScan's community distributions.

-If you maintain a community distribution and want it listed here, leave an issue / pull request / Discord message or however you want to let us know.
+If you maintain a community distribution and want it listed here, leave an issue / pull request / Discord message or however, you want to let us know.

- [OpenSuse](https://software.opensuse.org/package/rustscan?search_term=rustscan)
- [Fedora/CentOS](https://copr.fedorainfracloud.org/coprs/atim/rustscan/)
+- [Open Suse][distributions-1]
+- [Fedora/CentOS][distributions-2]

-[![Packaging status](https://repology.org/badge/vertical-allrepos/rustscan.svg)](https://repology.org/project/rustscan/versions)
+[![Packaging status][rustscan-svg]][repology-1]

 # 🤸 Usage

-```console
-$ rustscan -h
+We have 2 usage guides. [Basic Usage][usage-1] and [Things you may want to do][usage-2].

-Fast Port Scanner built in Rust. WARNING Do not use this program against sensitive infrastructure since the specified
-server may not be able to handle this many socket connections at once. - Discord https://discord.gg/GFrQsGy - GitHub
-https://github.com/RustScan/RustScan
-
-USAGE:
-    rustscan [FLAGS] [OPTIONS] [addresses]... [-- <command>...]
-
-FLAGS:
-        --accessible    Accessible mode. Turns off features which negatively affect screen readers
-    -g, --greppable     Greppable mode. Only output the ports. No Nmap. Useful for grep or outputting to a file
-    -h, --help          Prints help information
-    -n, --no-config     Whether to ignore the configuration file or not
-        --no-nmap       Turns off Nmap
-        --top           Use the top 1000 ports
-    -V, --version       Prints version information
-
-OPTIONS:
-    -b, --batch-size <batch-size>    The batch size for port scanning, it increases or decreases the speed of scanning.
-                                     Depends on the open file limit of your OS.  If you use 65535 it will scan every port
-                                     at the same time. Although, your OS may not support this [default: 4500]
-    -p, --ports <ports>...           A list of comma separed ports to be scanned. Example: 80,443,8080
-    -r, --range <range>              A range of ports with format start-end. Example: 1-1000
-        --scan-order <scan-order>    The order of scanning to be performed. The "serial" option will scan ports in
-                                     ascending order while the "random" option will scan ports randomly [default:
-                                     serial]  [possible values: Serial, Random]
-    -t, --timeout <timeout>          The timeout in milliseconds before a port is assumed to be closed [default: 1500]
-        --tries <tries>              The number of tries before a port is assumed to be closed. If set to 0, rustscan
-                                     will correct it to 1 [default: 1]
-    -u, --ulimit <ulimit>            Automatically ups the ULIMIT with the value you provided
-
-ARGS:
-    <addresses>...    A list of comma separated CIDRs, IPs, or hosts to be scanned
-    <command>...      The Nmap arguments to run. To use the argument -A, end RustScan's args with '-- -A'. Example:
-                      'rustscan -T 1500 127.0.0.1 -- -A -sC'. This command adds -Pn -vvv -p $PORTS automatically to
-                      nmap. For things like --script '(safe and vuln)' enclose it in quotations marks \"'(safe and
-                      vuln)'\"")
-```
-
-The format is `rustscan -b 500 -t 1500 192.168.0.1` to scan 192.168.0.1 with 500 batch size with a timeout of 1500ms. The timeout is how long RustScan waits for a response until it assumes the port is closed.
-
-The batch size determines how fast RustScan is. Set it to 65k, and it will scan all 65k ports at the same time. This means at at 65k batch size, RustScan will take TIMEOUT long to scan all ports. Essentially, if timeout is 1000ms, **RustScan can scan in 1 second**.
-
-Your operating system may not support this, but it is worth it to play around and see where your open file limit is. Shortly we will be releasing a dockerised version with a much larger open file limit, so this will be possible.
-
-## Configuration file
-
-This binary accepts a configuration file, named `.rustscan.toml`, that is read from the home directory of the user. It follows the TOML format
-and accepts the following fields:
-
- `addresses`
- `ports`
- `range`
- `scan_order`
- `command`
- `accessible`
- `greppable`
- `batch-size`
- `timeout`
- `tries`
- `ulimit`
-
-### Format example
-
-```toml
-addresses = ["127.0.0.1", "192.168.0.0/30", "www.google.com"]
-command = ["-A"]
-ports = [80, 443, 8080]
-range = { start = 1, end = 10 }
-greppable = false
-accessible = true
-scan_order = "Serial"
-batch_size = 1000
-timeout = 1000
-tries = 3
-ulimit = 1000
-```
-
-## ⚠️ WARNING
-
-This program, by default, scans 5000 ports at a time (5000 per second).
-
-This may cause damage to a server, or may make it incredibly obvious you are scanning the server.
-
-Servers as well as individual services can block your IP completely after a huge amount of simultaneous connections/tries, Possibly causing you to see false positives. False positives are open ports at the initial scanning process later found closed when you want to do further scanning, or connect to it.
-
-There are 2 ways to deal with this;
-
-1. Decrease batch size
-   `rustscan -b 10` will run 10 port scans for 1 second, and then another 10 for 1 second and so on.
-2. Increase timeout
-   `rustscan -T 5000` will mean RustScan waits 5 seconds until it scans the next ports.
-
-You can also use both of these at the same time, to make it as slow or as fast as you want. A fun favourite is 65535 batch size with 1 second timeout. Theoretically, this scans all 65535 ports in 1 second.
-
-**Please** do not use this tool against sensitive servers. It is designed mainly for Capture the Flag events, not real world servers with sensitive data.
-
-## 🚨 Thread Panicked at Main: Too Many Open Files
-
-This is the most common error found in RustScan.
-
-The open file limit is how many open sockets you can have at any given time.
-
-This limit changes from OS to OS.
-
-RustScan does not automatically create defaults (other than 5000) like Nmap does with their -T1, -T2 system.
-
-By figuring out for yourself the optimal batch size, you will know that RustScan is the most optimised port scanner for your system.
-
-There are 2 things you can do:
-
-1. Decrease batch size
-2. Increase open file limit
-
-Decreasing batch size slows down the program, so as long as it isn't too drastic, this is a good option.
-
-Run these 3 commands:
-
-```bash
-ulimit -a
-ulimit -Hn
-ulimit -Sn
-```
-
-They will give you an idea on the open file limit of your OS.
-
-If it says "250", run `rustscan -b 240` for a batch size of 240.
-
-Increasing the open file limit increases speed, but poses danger. Although, **opening more file sockets on the specified IP address may damage it**.
-
-To open more, set the ulimit to a higher number:
-
-```bash
-ulimit -n 5000
-```
-
-**Mac OS**
-Mac OS has, from what we can tell, a naturally very low open file descriptor limit. The limit for Ubuntu is 8800. The limit for Mac OS is 255!
-
-In this case, we would say it is safe to increase the open file limit. As most Linux based OS' have limits in the thousands.
-
-Although, if this breaks anything, please don't blame us.
-
-**Windows Subsystem for Linux**
-Windows Subsystem for Linux does not support ulimit (see issue #39).
-
-The best way is to use it on a host computer, in Docker, or in a VM that isn't WSL.
-
-**Automatic Ulimit updating**
-We are currently working on automatic Ulimit updating. If it is too high, it will lower itself. If it is too low, it will suggest a higher Ulimit. Watch [this issue](https://github.com/RustScan/RustScan/issues/25) for more.
-
-## 🔌 Nmap Custom Flags
-
-To run your own nmap commands, end the RustScan command with `-- -A` where `--` indicates "end of RustScan flags, please do not parse anything further" and any flags after that will be entered into nmap.
-
-RustScan automatically runs `nmap -vvv -p $PORTS $IP`. To make it run `-A`, execute the command `rustscan 127.0.0.1 -- -A`.
-
-If you want to run commands such as `--script (vuln and safe)`, you will need to enclose it in quotations like so `--script '"(vuln and safe) or default"'`.
-
-## 🎯 Increasing speed / accuracy
-
- Batch size
-
-This increases speed, by allowing us to process more at once. Something experimental we are working on is changing the open file limit. You can do this manually with `ulimit -n 70000` and then running rustscan with `-b 65535`. This _should_ scan all 65535 ports at the exact same time. But this is extremely experimental.
-
-For non-experimental speed increases, slowly increase the batch size until it no longer gets open ports, or it breaks.
-
- Accuracy (and some speed)
-
-To increase accuracy, the easiest way is to increase the timeout. The default is 1.5 seconds, by setting it to 4 seconds (4000) we are telling RustScan "if we do not hear back from a port in 4 seconds, assume it is closed".
-
-Decreasing accuracy gives some speed bonus, but our testing found that batch size dramatically changed the speed whereas timeout did, but not so much.
+We also have documentation about our config file [here][config-file-here].

 # 🎪 Community

-Howdy Space Cow-Person 🤠🌌
-
-RustScan is always looking for contributors. Whether that's spelling mistakes or major changes, your help is **wanted** and welcomed here.
-
-Before contributing, read our [code of conduct](https://github.com/RustScan/RustScan/blob/master/CODE_OF_CONDUCT.md).
-
-TL;DR if you abuse members of our community you will be **perma-banned** 🤗
-
-RustScan has 2 major labels for GitHub issues you should look at:
-
- Good First issue
-  These are issues for newcomers to open source!
-  [https://github.com/RustScan/RustScan/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22](https://github.com/RustScan/RustScan/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22)
- Help wanted
-  These are issues that aren't really for newcomers, but we could still do wiht help!
-  [https://github.com/RustScan/RustScan/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22+label%3A%22help+wanted%22](https://github.com/RustScan/RustScan/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22+label%3A%22help+wanted%22)
-
-If you want to, solve the issue or comment on the issue for help.
-
-The flow for contributing to open source software is:
-
- Fork the repo
- Make changes
- Pull request to the repo
-
-And then comment on the issue that you've done.
-
-RustScan also has some `// TODO`'s in the codebase, which are meant more for the core team but we wouldn't say no to help with these issues.
-
-If you have any feature suggestions or bugs, leave a GitHub issue. We welcome any and all support :D
-
-We communicate over Discord. [Click here](https://discord.gg/GFrQsGy) to join our Discord community!
-
-## Rewarding you
-
-We cannot pay you :-( But, We can place your GitHub profile on the README under `#Contributors` as a thank you! :)
-
-Please read the [contributing.md file](contributing.md)
+[Contributing][community-1] Read this to learn how.

 ## Contributors ✨

 <!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section -->
+
 [![All Contributors](https://img.shields.io/badge/all_contributors-26-orange.svg?style=flat-square)](#contributors-)
+
 <!-- ALL-CONTRIBUTORS-BADGE:END -->

 Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):
@@ -452,7 +155,7 @@ Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/d
  </tr>
  <tr>
    <td align="center"><a href="https://github.com/Atul9"><img src="https://avatars1.githubusercontent.com/u/3390330?v=4" width="100px;" alt=""/><br /><sub><b>Atul Bhosale</b></sub></a><br /><a href="https://github.com/RustScan/RustScan/commits?author=Atul9" title="Code">💻</a></td>
-    <td align="center"><a href="https://tgotwig.me"><img src="https://avatars0.githubusercontent.com/u/30773779?v=4" width="100px;" alt=""/><br /><sub><b>Thomas Gotwig</b></sub></a><br /><a href="#platform-TGotwig" title="Packaging/porting to new platform">📦</a></td>
+    <td align="center"><a href="https://tgotwig.dev"><img src="https://avatars0.githubusercontent.com/u/30773779?v=4" width="100px;" alt=""/><br /><sub><b>Thomas Gotwig</b></sub></a><br /><a href="#platform-TGotwig" title="Packaging/porting to new platform">📦</a></td>
    <td align="center"><a href="https://github.com/remigourdon"><img src="https://avatars3.githubusercontent.com/u/2874133?v=4" width="100px;" alt=""/><br /><sub><b>Rémi Gourdon</b></sub></a><br /><a href="https://github.com/RustScan/RustScan/commits?author=remigourdon" title="Documentation">📖</a> <a href="https://github.com/RustScan/RustScan/commits?author=remigourdon" title="Code">💻</a></td>
    <td align="center"><a href="https://cmnatic.co.uk"><img src="https://avatars3.githubusercontent.com/u/4163116?v=4" width="100px;" alt=""/><br /><sub><b>Ben (CMNatic)</b></sub></a><br /><a href="https://github.com/RustScan/RustScan/commits?author=cmnatic" title="Code">💻</a> <a href="https://github.com/RustScan/RustScan/commits?author=cmnatic" title="Documentation">📖</a> <a href="#design-cmnatic" title="Design">🎨</a></td>
    <td align="center"><a href="https://github.com/Ferryistaken"><img src="https://avatars3.githubusercontent.com/u/47927670?v=4" width="100px;" alt=""/><br /><sub><b>Alessandro Ferrari</b></sub></a><br /><a href="#content-Ferryistaken" title="Content">🖋</a></td>
@@ -479,6 +182,54 @@ Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/d

 <!-- markdownlint-enable -->
 <!-- prettier-ignore-end -->
+
 <!-- ALL-CONTRIBUTORS-LIST:END -->

 This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!
+
+<!--Links-->
+
+[Docker]: https://hub.docker.com/r/cmnatic/rustscan "This is the recommended distribution of rustscan"
+[kali]: https://github.com/RustScan/RustScan/wiki/Installation-Guide#%EF%B8%8F-debian--kali "Read the install guide"
+[Kali/Debian]: https://github.com/RustScan/RustScan/releases "Kali Debian"
+[Arch-Linux]: https://archlinux.org/packages/extra/x86_64/rustscan/ "Arch Linux installation of Rustscan"
+[Homebrew]: https://crates.io/crates/rustscan/ "Homebrew install of Rustscan"
+[usage-1]: https://github.com/RustScan/RustScan/wiki/Usage "Basic Usage of Rustscan"
+[usage-0]: https://github.com/RustScan/RustScan/wiki/Installation-Guide#docker-whale "Use Docker Rustscan"
+[config-file-here]: https://github.com/RustScan/RustScan/wiki/Config-File "RustScan Configuration File"
+[usage-2]: https://github.com/RustScan/RustScan/wiki/Things-you-may-want-to-do-with-RustScan-but-don't-understand-how "Things you may want to do with rustscan but don't know how"
+[community-1]: https://github.com/RustScan/RustScan/wiki/Contributing "Learn how to contribute"
+[distributions-1]: https://software.opensuse.org/package/rustscan?search_term=rustscan "Open Suse rustscan distribution"
+[distributions-2]: https://copr.fedorainfracloud.org/coprs/atim/rustscan/ "Rustscan in Fedora"
+[repology-1]: https://repology.org/project/rustscan/versions "Packaging Status"
+[install-1]: https://github.com/RustScan/RustScan/wiki/Installation-Guide "Installation guide"
+[accessible-2]: https://bees.substack.com/p/making-hacking-accessible "Making Hacking Accessible"
+[extensible-2]: https://github.com/RustScan/RustScan/wiki/RustScan-Scripting-Engine "Scripting Engine"
+[speed-2]: https://github.com/sharkdp/hyperfine "Hyperfine"
+[speed-3]: https://github.com/RustScan/RustScan/wiki/Increasing-Speed-&-Accuracy "Increasing Speed & Accuracy"
+[toc-community]: https://github.com/RustScan/RustScan#-community "Community"
+[links-table-1]: https://github.com/RustScan/RustScan#-full-installation-guide "Full installation guide"
+[links-table-2]: https://rustscan.github.io/RustScan/ "Rustscan"
+[discord]: http://discord.skerritt.blog "Discord blog"
+[toc-install]: https://github.com/RustScan/RustScan/wiki/Installation-Guide "Installation Guide Wiki"
+[toc-docker-usage]: https://github.com/RustScan/RustScan/wiki/Installation-Guide#docker- "Docker Installation Guide Wiki"
+[usage-guide]: https://github.com/RustScan/RustScan#-usage
+[adaptive-learning]: https://github.com/RustScan/RustScan/wiki/Adaptive-Learning "Adaptive Learning"
+
+<!--Pictures-->
+
+[DockerPic]: https://github.com/RustScan/RustScan/blob/master/pictures/docker.png?raw=true "Docker install"
+[Kali1]: https://github.com/RustScan/RustScan/blob/master/pictures/kali.png?raw=true "Kali Picture"
+[Arch]: https://github.com/RustScan/RustScan/blob/master/pictures/arch.png?raw=true "Arch Linux"
+[Apple]: https://raw.githubusercontent.com/RustScan/RustScan/master/pictures/apple.png?size "Apple"
+[rustscan-svg]: https://repology.org/badge/vertical-allrepos/rustscan.svg "Picture of rustscan repology"
+[accessible-1]: pictures/accessible.gif "Fast"
+[adaptive-1]: pictures/adaptive.gif "Adaptive"
+[extensible-1]: pictures/scripts.gif "Scripts"
+[speed-1]: pictures/fast.gif "Speed"
+[badge-1]: https://img.shields.io/archlinux/v/extra/x86_64/rustscan?style=plastic&logo=archlinux&link=https%3A%2F%2Farchlinux.org%2Fpackages%2Fextra%2Fx86_64%2Frustscan%2F
+[badge-2]: https://img.shields.io/badge/Built%20with-Rust-Purple
+[badge-3]: https://img.shields.io/github/downloads/rustscan/rustscan/total?label=GitHub%20Downloads
+[badge-4]: https://img.shields.io/crates/d/rustscan?label=Cargo%20Downloads
+[badge-5]: https://img.shields.io/discord/754001738184392704
+[badge-6]: https://github.com/RustScan/RustScan/workflows/Continuous%20integration/badge.svg?branch=master
@@ -0,0 +1,5 @@
+FROM rust
+# Install nmap first.
+RUN apt-get update -qy && apt-get install -qy nmap
+# Then install rustfmt and clippy for cargo.
+RUN rustup component add rustfmt clippy
@@ -7,19 +7,21 @@ Before contributing, read our [code of conduct](https://github.com/RustScan/Rust
 TL;DR if you abuse members of our community you will be **perma-banned** with no chance to get unbanned. No warnings either. 🤗

 RustScan has 2 major labels for GitHub issues you should look at:
-* Good First issue
-These are issues for newcomers to open source!
-[https://github.com/RustScan/RustScan/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22](https://github.com/RustScan/RustScan/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22)
-* Help wanted
-These are issues that aren't really for newcomers, but we could still do with help!
-[https://github.com/RustScan/RustScan/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22+label%3A%22help+wanted%22](https://github.com/RustScan/RustScan/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22+label%3A%22help+wanted%22)
+
+- Good First issue
+  These are issues for newcomers to open source!
+  [https://github.com/RustScan/RustScan/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22](https://github.com/RustScan/RustScan/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22)
+- Help wanted
+  These are issues that aren't really for newcomers, but we could still do with help!
+  [https://github.com/RustScan/RustScan/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22+label%3A%22help+wanted%22](https://github.com/RustScan/RustScan/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22+label%3A%22help+wanted%22)

 If you want to, solve the issue or comment on the issue for help.

-The [flow for contributing](https://guides.github.com/introduction/flow/) to open source software is:
-* Fork the repo
-* Make changes
-* Pull request to the repo
+The flow for contributing to open source software is:
+
+- Fork the repo
+- Make changes
+- Pull request to the repo

 And then comment on the issue that you've done.

@@ -28,4 +30,40 @@ RustScan also has some `// TODO`'s in the codebase, which are meant more for the
 If you have any feature suggestions or bugs, leave a GitHub issue. We welcome any and all support :D

 ## Rewarding you
+
 I cannot pay you :-( But, I can place your GitHub profile on the README under `#Contributors` as a thank you! :)
+
+## Contributing development environment
+
+To ease contribution to RustScan, you can use the `contributing.Dockerfile` to create a Docker image ready to build and play with RustScan.
+To build it you just need to run:
+
+```bash
+you@home:~/RustScan$ docker build -t rustscan_contributing -f contributing.Dockerfile
+```
+
+Then you need to run the container with a volume so it can access, _with read and write permissions_, to RustScan files:
+
+```bash
+you@home:~/RustScan$ docker run -ti --rm -v "$PWD":/rustscan -w /rustscan rustscan_contributing bash
+```
+
+You can now modify RustScan files with your favorite editor, once you want to compile and test your modifications, type the following in the container prompt:
+
+```bash
+root@container:/rustscan# cargo build
+```
+
+You are now ready to use RustScan:
+
+```bash
+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:
+
+```bash
+root@container:/rustscan# cargo fmt
+root@container:/rustscan# cargo clippy
+root@container:/rustscan# cargo test
+```
@@ -0,0 +1,131 @@
+# The configurations that used for the recording, feel free to edit them
+config:
+
+  # Specify a command to be executed
+  # like `/bin/bash -l`, `ls`, or any other commands
+  # the default is bash for Linux
+  # or powershell.exe for Windows
+  command: zsh
+  
+  # Specify the current working directory path
+  # the default is the current working directory path
+  cwd: /home/bee/Documents/RustScan
+  
+  # Export additional ENV variables
+  env:
+    recording: true
+  
+  # Explicitly set the number of columns
+  # or use `auto` to take the current
+  # number of columns of your shell
+  cols: 107
+  
+  # Explicitly set the number of rows
+  # or use `auto` to take the current
+  # number of rows of your shell
+  rows: 43
+  
+  # Amount of times to repeat GIF
+  # If value is -1, play once
+  # If value is 0, loop indefinitely
+  # If value is a positive number, loop n times
+  repeat: 0
+  
+  # Quality
+  # 1 - 100
+  quality: 100
+  
+  # Delay between frames in ms
+  # If the value is `auto` use the actual recording delays
+  frameDelay: auto
+  
+  # Maximum delay between frames in ms
+  # Ignored if the `frameDelay` isn't set to `auto`
+  # Set to `auto` to prevent limiting the max idle time
+  maxIdleTime: 2000
+  
+  # The surrounding frame box
+  # The `type` can be null, window, floating, or solid`
+  # To hide the title use the value null
+  # Don't forget to add a backgroundColor style with a null as type
+  frameBox:
+    type: floating
+    title: Terminalizer
+    style:
+      border: 0px black solid
+      # boxShadow: none
+      # margin: 0px
+  
+  # Add a watermark image to the rendered gif
+  # You need to specify an absolute path for
+  # the image on your machine or a URL, and you can also
+  # add your own CSS styles
+  watermark:
+    imagePath: null
+    style:
+      position: absolute
+      right: 15px
+      bottom: 15px
+      width: 100px
+      opacity: 0.9
+  
+  # Cursor style can be one of
+  # `block`, `underline`, or `bar`
+  cursorStyle: block
+  
+  # Font family
+  # You can use any font that is installed on your machine
+  # in CSS-like syntax
+  fontFamily: "Monaco, Lucida Console, Ubuntu Mono, Monospace"
+  
+  # The size of the font
+  fontSize: 12
+  
+  # The height of lines
+  lineHeight: 1
+  
+  # The spacing between letters
+  letterSpacing: 0
+  
+  # Theme
+  theme:
+    background: "transparent"
+    foreground: "#afafaf"
+    cursor: "#c7c7c7"
+    black: "#232628"
+    red: "#fc4384"
+    green: "#b3e33b"
+    yellow: "#ffa727"
+    blue: "#75dff2"
+    magenta: "#ae89fe"
+    cyan: "#708387"
+    white: "#d5d5d0"
+    brightBlack: "#626566"
+    brightRed: "#ff7fac"
+    brightGreen: "#c8ed71"
+    brightYellow: "#ebdf86"
+    brightBlue: "#75dff2"
+    brightMagenta: "#ae89fe"
+    brightCyan: "#b1c6ca"
+    brightWhite: "#f9f9f4"
+  
+# Records, feel free to edit them
+records:
+  - delay: 436
+    content: "\e[1m\e[7m%\e[27m\e[1m\e[0m                                                                                                          \r \r\e]2;bee@beehive:~/Documents/RustScan\a\e]1;..ents/RustScan\a"
+  - delay: 162
+    content: "\r\e[0m\e[27m\e[24m\e[J\r\n\e[1m\e[0m\e[1m\e[36mRustScan\e[0m\e[36m\e[39m\e[1m \e[0m\e[1mon \e[0m\e[1m\e[37m\e[1m\e[37m\e[0m\e[37m\e[1m\e[37m\e[35m master\e[0m\e[35m\e[39m\e[1m\e[0m\e[1m\e[0m\e[1m\e[31m [?]\e[0m\e[31m\e[39m\e[1m\e[0m\e[0m\e[39m\e[1m \e[0m\e[1mis \e[0m\e[1m\e[31m\U0001F4E6 vrustscan:1.10.0\e[0m\e[31m\e[39m\e[1m \e[0m\e[1mvia \e[0m\e[1m\e[31m\U0001D5E5 v1.46.0\e[0m\e[31m\e[39m\e[1m \e[0m\r\n\e[1m\e[0m\e[1m\e[32m➜ \e[0m\e[32m\e[39m\e[1m\e[0m\e[K\e[?1h\e=\e[?2004h"
+  - delay: 471
+    content: "r\brustscan 127.0.0.1 --accessible --no-nmap --ulimit 5000\e[55D\e[7mr\e[7mu\e[7ms\e[7mt\e[7ms\e[7mc\e[7ma\e[7mn\e[7m \e[7m1\e[7m2\e[7m7\e[7m.\e[7m0\e[7m.\e[7m0\e[7m.\e[7m1\e[7m \e[7m-\e[7m-\e[7ma\e[7mc\e[7mc\e[7me\e[7ms\e[7ms\e[7mi\e[7mb\e[7ml\e[7me\e[7m \e[7m-\e[7m-\e[7mn\e[7mo\e[7m-\e[7mn\e[7mm\e[7ma\e[7mp\e[7m \e[7m-\e[7m-\e[7mu\e[7ml\e[7mi\e[7mm\e[7mi\e[7mt\e[7m \e[7m5\e[7m0\e[7m0\e[7m0\e[27m"
+  - delay: 269
+    content: "\e[55D\e[27mr\e[27mu\e[27ms\e[27mt\e[27ms\e[27mc\e[27ma\e[27mn\e[27m \e[27m1\e[27m2\e[27m7\e[27m.\e[27m0\e[27m.\e[27m0\e[27m.\e[27m1\e[27m \e[27m-\e[27m-\e[27ma\e[27mc\e[27mc\e[27me\e[27ms\e[27ms\e[27mi\e[27mb\e[27ml\e[27me\e[27m \e[27m-\e[27m-\e[27mn\e[27mo\e[27m-\e[27mn\e[27mm\e[27ma\e[27mp\e[27m \e[27m-\e[27m-\e[27mu\e[27ml\e[27mi\e[27mm\e[27mi\e[27mt\e[27m \e[27m5\e[27m0\e[27m0\e[27m0\e[?1l\e>\e[?2004l\r\r\n\e]2;rustscan 127.0.0.1 --accessible --no-nmap --ulimit 5000\a\e]1;rustscan\aAutomatically increasing ulimit value to 5000.\r\n"
+  - delay: 1536
+    content: "Open 127.0.0.1:38602\r\n"
+  - delay: 395
+    content: "Open 127.0.0.1:50078\r\n"
+  - delay: 450
+    content: "127.0.0.1 -> [38602,50078]\r\n\e[1m\e[7m%\e[27m\e[1m\e[0m                                                                                                          \r \r\e]2;bee@beehive:~/Documents/RustScan\a\e]1;..ents/RustScan\a"
+  - delay: 143
+    content: "\r\e[0m\e[27m\e[24m\e[J\r\n\e[1m\e[0m\e[1m\e[36mRustScan\e[0m\e[36m\e[39m\e[1m \e[0m\e[1mon \e[0m\e[1m\e[37m\e[1m\e[37m\e[0m\e[37m\e[1m\e[37m\e[35m master\e[0m\e[35m\e[39m\e[1m\e[0m\e[1m\e[0m\e[1m\e[31m [?]\e[0m\e[31m\e[39m\e[1m\e[0m\e[0m\e[39m\e[1m \e[0m\e[1mis \e[0m\e[1m\e[31m\U0001F4E6 vrustscan:1.10.0\e[0m\e[31m\e[39m\e[1m \e[0m\e[1mvia \e[0m\e[1m\e[31m\U0001D5E5 v1.46.0\e[0m\e[31m\e[39m\e[1m \e[0m\e[1mtook \e[0m\e[1m\e[33m2s\e[0m\e[33m\e[39m\e[1m \e[0m\r\n\e[1m\e[0m\e[1m\e[32m➜ \e[0m\e[32m\e[39m\e[1m\e[0m\e[K\e[?1h\e=\e[?2004h"
+  - delay: 563
+    content: "\e[?2004l\r\r\n"
@@ -0,0 +1 @@
+cargo publish && cargo build --release && git add Cargo.lock && git commit -m 'Updating lock file' && gpsup
@@ -43,7 +43,7 @@ impl Benchmark {
                    .unwrap()
                    .saturating_duration_since(timer.start.unwrap())
                    .as_secs_f32();
-                summary.push_str(&format!("\n{0: <10} | {1: <10}s", timer.name, runtime_secs))
+                summary.push_str(&format!("\n{0: <10} | {1: <10}s", timer.name, runtime_secs));
            }
        }
        summary
@@ -85,5 +85,5 @@ fn benchmark() {
    assert!(benchmarks
        .summary()
        .contains("\nRustScan Benchmark Summary\ntest       | 0."));
-    assert_ne!(benchmarks.summary().contains("only_start"), true);
+    assert!(!benchmarks.summary().contains("only_start"));
 }
@@ -1,352 +1 @@
-use serde_derive::Deserialize;
-use std::collections::HashMap;
-use std::fs;
-use structopt::{clap::arg_enum, StructOpt};

-const LOWEST_PORT_NUMBER: u16 = 1;
-const TOP_PORT_NUMBER: u16 = 65535;
-
-arg_enum! {
-    /// Represents the strategy in which the port scanning will run.
-    ///   - Serial will run from start to end, for example 1 to 1_000.
-    ///   - Random will randomize the order in which ports will be scanned.
-    #[derive(Deserialize, Debug, StructOpt, Clone, PartialEq)]
-    pub enum ScanOrder {
-        Serial,
-        Random,
-    }
-}
-
-arg_enum! {
-    /// Represents the scripts variant.
-    ///   - none will avoid running any script, only portscan results will be shown.
-    ///   - default will run the default embedded nmap script, that's part of RustScan since the beginning.
-    ///   - custom will read the ScriptConfig file and the available scripts in the predefined folders
-    #[derive(Deserialize, Debug, StructOpt, Clone, PartialEq, Copy)]
-    pub enum ScriptsRequired {
-        None,
-        Default,
-        Custom,
-    }
-}
-
-/// Represents the range of ports to be scanned.
-#[derive(Deserialize, Debug, Clone, PartialEq)]
-pub struct PortRange {
-    pub start: u16,
-    pub end: u16,
-}
-
-#[cfg(not(tarpaulin_include))]
-fn parse_range(input: &str) -> Result<PortRange, String> {
-    let range = input
-        .split('-')
-        .map(|x| x.parse::<u16>())
-        .collect::<Result<Vec<u16>, std::num::ParseIntError>>();
-
-    if range.is_err() {
-        return Err(String::from(
-            "the range format must be 'start-end'. Example: 1-1000.",
-        ));
-    }
-
-    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(StructOpt, Debug, Clone)]
-#[structopt(name = "rustscan", setting = structopt::clap::AppSettings::TrailingVarArg)]
-/// Fast Port Scanner built in Rust.
-/// WARNING Do not use this program against sensitive infrastructure since the
-/// specified server may not be able to handle this many socket connections at once.
-/// - Discord https://discord.gg/GFrQsGy
-/// - GitHub https://github.com/RustScan/RustScan
-pub struct Opts {
-    /// A list of comma separated CIDRs, IPs, or hosts to be scanned.
-    #[structopt(short, long, use_delimiter = true)]
-    pub addresses: Vec<String>,
-
-    /// A list of comma separed ports to be scanned. Example: 80,443,8080.
-    #[structopt(short, long, use_delimiter = true)]
-    pub ports: Option<Vec<u16>>,
-
-    /// A range of ports with format start-end. Example: 1-1000.
-    #[structopt(short, long, conflicts_with = "ports", parse(try_from_str = parse_range))]
-    pub range: Option<PortRange>,
-
-    /// Whether to ignore the configuration file or not.
-    #[structopt(short, long)]
-    pub no_config: bool,
-
-    /// Greppable mode. Only output the ports. No Nmap. Useful for grep or outputting to a file.
-    #[structopt(short, long)]
-    pub greppable: bool,
-
-    /// Accessible mode. Turns off features which negatively affect screen readers.
-    #[structopt(long)]
-    pub accessible: bool,
-
-    /// The batch size for port scanning, it increases or slows the speed of
-    /// scanning. Depends on the open file limit of your OS.  If you do 65535
-    /// it will do every port at the same time. Although, your OS may not
-    /// support this.
-    #[structopt(short, long, default_value = "4500")]
-    pub batch_size: u16,
-
-    /// The timeout in milliseconds before a port is assumed to be closed.
-    #[structopt(short, long, default_value = "1500")]
-    pub timeout: u32,
-
-    /// The number of tries before a port is assumed to be closed.
-    /// If set to 0, rustscan will correct it to 1.
-    #[structopt(long, default_value = "1")]
-    pub tries: u8,
-
-    /// Automatically ups the ULIMIT with the value you provided.
-    #[structopt(short, long)]
-    pub ulimit: Option<rlimit::RawRlim>,
-
-    /// The order of scanning to be performed. The "serial" option will
-    /// scan ports in ascending order while the "random" option will scan
-    /// ports randomly.
-    #[structopt(long, possible_values = &ScanOrder::variants(), case_insensitive = true, default_value = "serial")]
-    pub scan_order: ScanOrder,
-
-    /// Level of scripting required for the run.
-    #[structopt(long, possible_values = &ScriptsRequired::variants(), case_insensitive = true, default_value = "default")]
-    pub scripts: ScriptsRequired,
-
-    /// Use the top 1000 ports.
-    #[structopt(long)]
-    pub top: bool,
-
-    /// The Script arguments to run.
-    /// To use the argument -A, end RustScan's args with '-- -A'.
-    /// Example: 'rustscan -T 1500 127.0.0.1 -- -A -sC'.
-    /// This command adds -Pn -vvv -p $PORTS automatically to nmap.
-    /// For things like --script '(safe and vuln)' enclose it in quotations marks \"'(safe and vuln)'\"")
-    #[structopt(last = true)]
-    pub command: Vec<String>,
-}
-
-#[cfg(not(tarpaulin_include))]
-impl Opts {
-    pub fn read() -> Self {
-        let mut opts = Opts::from_args();
-
-        if opts.ports.is_none() && opts.range.is_none() {
-            opts.range = Some(PortRange {
-                start: LOWEST_PORT_NUMBER,
-                end: TOP_PORT_NUMBER,
-            });
-        }
-
-        opts
-    }
-
-    /// Reads the command line arguments into an Opts struct and merge
-    /// values found within the user configuration file.
-    pub fn merge(&mut self, config: &Config) {
-        if !self.no_config {
-            self.merge_required(&config);
-            self.merge_optional(&config);
-        }
-    }
-
-    fn merge_required(&mut self, config: &Config) {
-        macro_rules! merge_required {
-            ($($field: ident),+) => {
-                $(
-                    if let Some(e) = &config.$field {
-                        self.$field = e.clone();
-                    }
-                )+
-            }
-        }
-
-        merge_required!(
-            addresses, greppable, accessible, batch_size, timeout, tries, scan_order, scripts,
-            command
-        );
-    }
-
-    fn merge_optional(&mut self, config: &Config) {
-        macro_rules! merge_optional {
-            ($($field: ident),+) => {
-                $(
-                    if config.$field.is_some() {
-                        self.$field = config.$field.clone();
-                    }
-                )+
-            }
-        }
-
-        // Only use top ports when the user asks for them
-        if self.top && config.ports.is_some() {
-            let mut ports: Vec<u16> = Vec::with_capacity(config.ports.clone().unwrap().len());
-            for entry in config.ports.clone().unwrap().keys() {
-                ports.push(entry.parse().unwrap())
-            }
-            self.ports = Some(ports);
-        }
-
-        merge_optional!(range, ulimit);
-    }
-}
-
-/// Struct used to deserialize the options specified within our config file.
-/// These will be further merged with our command line arguments in order to
-/// generate the final Opts struct.
-#[cfg(not(tarpaulin_include))]
-#[derive(Debug, Deserialize)]
-pub struct Config {
-    addresses: Option<Vec<String>>,
-    ports: Option<HashMap<String, u16>>,
-    range: Option<PortRange>,
-    greppable: Option<bool>,
-    accessible: Option<bool>,
-    batch_size: Option<u16>,
-    timeout: Option<u32>,
-    tries: Option<u8>,
-    ulimit: Option<rlimit::RawRlim>,
-    scan_order: Option<ScanOrder>,
-    command: Option<Vec<String>>,
-    scripts: Option<ScriptsRequired>,
-}
-
-#[cfg(not(tarpaulin_include))]
-impl Config {
-    /// Reads the configuration file with TOML format and parses it into a
-    /// Config struct.
-    ///
-    /// # Format
-    ///
-    /// addresses = ["127.0.0.1", "127.0.0.1"]
-    /// ports = [80, 443, 8080]
-    /// greppable = true
-    /// scan_order: "Serial"
-    ///
-    pub fn read() -> Self {
-        let mut home_dir = match dirs::home_dir() {
-            Some(dir) => dir,
-            None => panic!("Could not infer config file path."),
-        };
-        home_dir.push(".rustscan.toml");
-
-        let mut content = String::new();
-        if home_dir.exists() {
-            content = match fs::read_to_string(home_dir) {
-                Ok(content) => content,
-                Err(_) => String::new(),
-            }
-        }
-
-        let config: Config = match toml::from_str(&content) {
-            Ok(config) => config,
-            Err(e) => {
-                println!("Found {} in configuration file.\nAborting scan.\n", e);
-                std::process::exit(1);
-            }
-        };
-
-        config
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{Config, Opts, PortRange, ScanOrder, ScriptsRequired};
-    impl Config {
-        fn default() -> Self {
-            Self {
-                addresses: Some(vec!["127.0.0.1".to_owned()]),
-                ports: None,
-                range: None,
-                greppable: Some(true),
-                batch_size: Some(25_000),
-                timeout: Some(1_000),
-                tries: Some(1),
-                ulimit: None,
-                command: Some(vec!["-A".to_owned()]),
-                accessible: Some(true),
-                scan_order: Some(ScanOrder::Random),
-                scripts: None,
-            }
-        }
-    }
-
-    impl Opts {
-        pub fn default() -> Self {
-            Self {
-                addresses: vec![],
-                ports: None,
-                range: None,
-                greppable: true,
-                batch_size: 0,
-                timeout: 0,
-                tries: 0,
-                ulimit: None,
-                command: vec![],
-                accessible: false,
-                scan_order: ScanOrder::Serial,
-                no_config: true,
-                top: false,
-                scripts: ScriptsRequired::Default,
-            }
-        }
-    }
-
-    #[test]
-    fn opts_no_merge_when_config_is_ignored() {
-        let mut opts = Opts::default();
-        let config = Config::default();
-
-        opts.merge(&config);
-
-        assert_eq!(opts.addresses, vec![] as Vec<String>);
-        assert_eq!(opts.greppable, true);
-        assert_eq!(opts.accessible, false);
-        assert_eq!(opts.timeout, 0);
-        assert_eq!(opts.command, vec![] as Vec<String>);
-        assert_eq!(opts.scan_order, ScanOrder::Serial);
-    }
-
-    #[test]
-    fn opts_merge_required_arguments() {
-        let mut opts = Opts::default();
-        let config = Config::default();
-
-        opts.merge_required(&config);
-
-        assert_eq!(opts.addresses, config.addresses.unwrap());
-        assert_eq!(opts.greppable, config.greppable.unwrap());
-        assert_eq!(opts.timeout, config.timeout.unwrap());
-        assert_eq!(opts.command, config.command.unwrap());
-        assert_eq!(opts.accessible, config.accessible.unwrap());
-        assert_eq!(opts.scan_order, config.scan_order.unwrap());
-        assert_eq!(opts.scripts, ScriptsRequired::Default)
-    }
-
-    #[test]
-    fn opts_merge_optional_arguments() {
-        let mut opts = Opts::default();
-        let mut config = Config::default();
-        config.range = Some(PortRange {
-            start: 1,
-            end: 1_000,
-        });
-        config.ulimit = Some(1_000);
-
-        opts.merge_optional(&config);
-
-        assert_eq!(opts.range, config.range);
-        assert_eq!(opts.ulimit, config.ulimit);
-    }
-}
@@ -1,3 +1,7 @@
+#![deny(clippy::all)]
+#![warn(clippy::pedantic)]
+#![allow(clippy::doc_markdown, clippy::if_not_else, clippy::non_ascii_literal)]
+
 extern crate shell_words;

 mod tui;
@@ -20,27 +24,32 @@ use scripts::{init_scripts, Script, ScriptFile};
 use cidr_utils::cidr::IpCidr;
 use colorful::{Color, Colorful};
 use futures::executor::block_on;
-use rlimit::{getrlimit, setrlimit, RawRlim, Resource, Rlim};
 use std::collections::HashMap;
 use std::fs::File;
 use std::io::{prelude::*, BufReader};
 use std::net::{IpAddr, ToSocketAddrs};
 use std::path::Path;
+use std::string::ToString;
 use std::time::Duration;
-use trust_dns_resolver::{config::*, Resolver};
+use trust_dns_resolver::{
+    config::{ResolverConfig, ResolverOpts},
+    Resolver,
+};

 extern crate colorful;
 extern crate dirs;

 // Average value for Ubuntu
-const DEFAULT_FILE_DESCRIPTORS_LIMIT: RawRlim = 8000;
+#[cfg(unix)]
+const DEFAULT_FILE_DESCRIPTORS_LIMIT: u64 = 8000;
 // Safest batch size based on experimentation
-const AVERAGE_BATCH_SIZE: RawRlim = 3000;
+const AVERAGE_BATCH_SIZE: u16 = 3000;

 #[macro_use]
 extern crate log;

 #[cfg(not(tarpaulin_include))]
+#[allow(clippy::too_many_lines)]
 /// Faster Nmap scanning with Rust
 /// If you're looking for the actual scanning, check out the module Scanner
 fn main() {
@@ -49,13 +58,23 @@ fn main() {
    let mut rustscan_bench = NamedTimer::start("RustScan");

    let mut opts: Opts = Opts::read();
-    let config = Config::read();
+    let config = Config::read(opts.config_path.clone());
    opts.merge(&config);

    debug!("Main() `opts` arguments are {:?}", opts);

-    let scripts_to_run: Vec<ScriptFile> =
-        init_scripts(opts.scripts).expect("could not initiate scripting part.");
+    let scripts_to_run: Vec<ScriptFile> = match init_scripts(opts.scripts) {
+        Ok(scripts_to_run) => scripts_to_run,
+        Err(e) => {
+            warning!(
+                format!("Initiating scripts failed!\n{e}"),
+                opts.greppable,
+                opts.accessible
+            );
+            std::process::exit(1);
+        }
+    };
+
    debug!("Scripts initialized {:?}", &scripts_to_run);

    if !opts.greppable && !opts.accessible {
@@ -73,8 +92,11 @@ fn main() {
        std::process::exit(1);
    }

-    let ulimit: RawRlim = adjust_ulimit_size(&opts);
-    let batch_size: u16 = infer_batch_size(&opts, ulimit);
+    #[cfg(unix)]
+    let batch_size: u16 = infer_batch_size(&opts, adjust_ulimit_size(&opts));
+
+    #[cfg(not(unix))]
+    let batch_size: u16 = AVERAGE_BATCH_SIZE;

    let scanner = Scanner::new(
        &ips,
@@ -82,7 +104,7 @@ fn main() {
        Duration::from_millis(opts.timeout.into()),
        opts.tries,
        opts.greppable,
-        PortStrategy::pick(opts.range, opts.ports, opts.scan_order),
+        PortStrategy::pick(&opts.range, opts.ports, opts.scan_order),
        opts.accessible,
    );
    debug!("Scanner finished building: {:?}", scanner);
@@ -114,13 +136,13 @@ fn main() {
        \n Alternatively, increase the timeout if your ping is high. Rustscan -t 2000 for 2000 milliseconds (2s) timeout.\n",
        ip,
        opts.batch_size,
-        "'rustscan -b <batch_size> <ip address>'");
+        "'rustscan -b <batch_size> -a <ip address>'");
        warning!(x, opts.greppable, opts.accessible);
    }

    let mut script_bench = NamedTimer::start("Scripts");
-    for (ip, ports) in ports_per_ip.iter_mut() {
-        let vec_str_ports: Vec<String> = ports.iter().map(|port| port.to_string()).collect();
+    for (ip, ports) in &ports_per_ip {
+        let vec_str_ports: Vec<String> = ports.iter().map(ToString::to_string).collect();

        // nmap port style is 80,443. Comma separated with no spaces.
        let ports_str = vec_str_ports.join(",");
@@ -134,19 +156,20 @@ fn main() {

        // Run all the scripts we found and parsed based on the script config file tags field.
        for mut script_f in scripts_to_run.clone() {
-            output!(
-                format!("Script to be run {:?}\n", script_f.call_format,),
-                opts.greppable,
-                opts.accessible
-            );
-
            // 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: Vec<String> = shell_words::split(&opts.command.join(" "))
-                    .expect("Failed to parse extra user commandline arguments");
+                let user_extra_args = &opts.command.join(" ");
+                debug!("Extra args vec {:?}", user_extra_args);
                if script_f.call_format.is_some() {
                    let mut call_f = script_f.call_format.unwrap();
-                    call_f.push_str(&format!(" {}", &user_extra_args.join(" ")));
+                    call_f.push(' ');
+                    call_f.push_str(user_extra_args);
+                    output!(
+                        format!("Running script {:?} on ip {}\nDepending on the complexity of the script, results may take some time to appear.", call_f, &ip),
+                        opts.greppable,
+                        opts.accessible
+                    );
+                    debug!("Call format {}", call_f);
                    script_f.call_format = Some(call_f);
                }
            }
@@ -155,7 +178,7 @@ fn main() {
            let script = Script::build(
                script_f.path,
                *ip,
-                ports.to_vec(),
+                ports.clone(),
                script_f.port,
                script_f.ports_separator,
                script_f.tags,
@@ -166,11 +189,7 @@ fn main() {
                    detail!(script_result.to_string(), opts.greppable, opts.accessible);
                }
                Err(e) => {
-                    warning!(
-                        &format!("Error {}", e.to_string()),
-                        opts.greppable,
-                        opts.accessible
-                    );
+                    warning!(&format!("Error {e}"), opts.greppable, opts.accessible);
                }
            }
        }
@@ -186,27 +205,35 @@ fn main() {
 }

 /// Prints the opening title of RustScan
+#[allow(clippy::items_after_statements, clippy::needless_raw_string_hashes)]
 fn print_opening(opts: &Opts) {
    debug!("Printing opening");
-    let s = r#".----. .-. .-. .----..---.  .----. .---.   .--.  .-. .-.
-| {}  }| { } |{ {__ {_   _}{ {__  /  ___} / {} \ |  `| |
-| .-. \| {_} |.-._} } | |  .-._} }\     }/  /\  \| |\  |
-`-' `-'`-----'`----'  `-'  `----'  `---' `-'  `-'`-' `-'
-The Modern Day Port Scanner."#;
+    let s = format!(
+        "{}\n{}\n{}\n{}\n{}",
+        r#".----. .-. .-. .----..---.  .----. .---.   .--.  .-. .-."#,
+        r#"| {}  }| { } |{ {__ {_   _}{ {__  /  ___} / {} \ |  `| |"#,
+        r#"| .-. \| {_} |.-._} } | |  .-._} }\     }/  /\  \| |\  |"#,
+        r#"`-' `-'`-----'`----'  `-'  `----'  `---' `-'  `-'`-' `-'"#,
+        r#"The Modern Day Port Scanner."#
+    );
    println!("{}", s.gradient(Color::Green).bold());
-    let info = r#"________________________________________
-: https://discord.gg/GFrQsGy           :
-: https://github.com/RustScan/RustScan :
- --------------------------------------"#;
+    let info = format!(
+        "{}\n{}\n{}\n{}",
+        r#"________________________________________"#,
+        r#": http://discord.skerritt.blog         :"#,
+        r#": https://github.com/RustScan/RustScan :"#,
+        r#" --------------------------------------"#
+    );
    println!("{}", info.gradient(Color::Yellow).bold());
    funny_opening!();

-    let config_path = dirs::home_dir()
-        .expect("Could not infer config file path.")
-        .join(".rustscan.toml");
+    let config_path = opts
+        .config_path
+        .clone()
+        .unwrap_or_else(input::default_config_path);

    detail!(
-        format!("The config file is expected to be at {:?}", config_path),
+        format!("The config file is expected to be at {config_path:?}"),
        opts.greppable,
        opts.accessible
    );
@@ -217,11 +244,11 @@ The Modern Day Port Scanner."#;
 fn parse_addresses(input: &Opts) -> Vec<IpAddr> {
    let mut ips: Vec<IpAddr> = Vec::new();
    let mut unresolved_addresses: Vec<&str> = Vec::new();
-    let resolver =
-        &Resolver::new(ResolverConfig::cloudflare_tls(), ResolverOpts::default()).unwrap();
+    let backup_resolver =
+        Resolver::new(ResolverConfig::cloudflare_tls(), ResolverOpts::default()).unwrap();

    for address in &input.addresses {
-        let parsed_ips = parse_address(address, resolver);
+        let parsed_ips = parse_address(address, &backup_resolver);
        if !parsed_ips.is_empty() {
            ips.extend(parsed_ips);
        } else {
@@ -235,7 +262,7 @@ fn parse_addresses(input: &Opts) -> Vec<IpAddr> {

        if !file_path.is_file() {
            warning!(
-                format!("Host {:?} could not be resolved.", file_path),
+                format!("Host {file_path:?} could not be resolved."),
                input.greppable,
                input.accessible
            );
@@ -243,11 +270,11 @@ fn parse_addresses(input: &Opts) -> Vec<IpAddr> {
            continue;
        }

-        if let Ok(x) = read_ips_from_file(file_path, &resolver) {
+        if let Ok(x) = read_ips_from_file(file_path, &backup_resolver) {
            ips.extend(x);
        } else {
            warning!(
-                format!("Host {:?} could not be resolved.", file_path),
+                format!("Host {file_path:?} could not be resolved."),
                input.greppable,
                input.accessible
            );
@@ -259,9 +286,9 @@ fn parse_addresses(input: &Opts) -> Vec<IpAddr> {

 /// Given a string, parse it as an host, IP address, or CIDR.
 /// This allows us to pass files as hosts or cidr or IPs easily
-/// Call this everytime you have a possible IP_or_host
+/// Call this every time you have a possible IP_or_host
 fn parse_address(address: &str, resolver: &Resolver) -> Vec<IpAddr> {
-    IpCidr::from_str(&address)
+    IpCidr::from_str(address)
        .map(|cidr| cidr.iter().collect())
        .ok()
        .or_else(|| {
@@ -273,19 +300,26 @@ fn parse_address(address: &str, resolver: &Resolver) -> Vec<IpAddr> {
        .unwrap_or_else(|| resolve_ips_from_host(address, resolver))
 }

-/// Uses DNS to get the IPS assiocated with host
-fn resolve_ips_from_host(source: &str, resolver: &Resolver) -> Vec<IpAddr> {
-    resolver
-        .lookup_ip(source)
-        .map(|x| x.iter().collect())
-        .unwrap_or_default()
+/// Uses DNS to get the IPS associated with host
+fn resolve_ips_from_host(source: &str, backup_resolver: &Resolver) -> Vec<IpAddr> {
+    let mut ips: Vec<std::net::IpAddr> = Vec::new();
+
+    if let Ok(addrs) = source.to_socket_addrs() {
+        for ip in addrs {
+            ips.push(ip.ip());
+        }
+    } else if let Ok(addrs) = backup_resolver.lookup_ip(source) {
+        ips.extend(addrs.iter());
+    }
+
+    ips
 }

 #[cfg(not(tarpaulin_include))]
 /// Parses an input file of IPs and uses those
 fn read_ips_from_file(
    ips: &std::path::Path,
-    resolver: &Resolver,
+    backup_resolver: &Resolver,
 ) -> Result<Vec<std::net::IpAddr>, std::io::Error> {
    let file = File::open(ips)?;
    let reader = BufReader::new(file);
@@ -294,7 +328,7 @@ fn read_ips_from_file(

    for address_line in reader.lines() {
        if let Ok(address) = address_line {
-            ips.extend(parse_address(&address, resolver));
+            ips.extend(parse_address(&address, backup_resolver));
        } else {
            debug!("Line in file is not valid");
        }
@@ -303,35 +337,35 @@ fn read_ips_from_file(
    Ok(ips)
 }

-fn adjust_ulimit_size(opts: &Opts) -> RawRlim {
-    if opts.ulimit.is_some() {
-        let limit: Rlim = Rlim::from_raw(opts.ulimit.unwrap());
+#[cfg(unix)]
+fn adjust_ulimit_size(opts: &Opts) -> u64 {
+    use rlimit::Resource;

-        match setrlimit(Resource::NOFILE, limit, limit) {
-            Ok(_) => {
-                detail!(
-                    format!("Automatically increasing ulimit value to {}.", limit),
-                    opts.greppable,
-                    opts.accessible
-                );
-            }
-            Err(_) => {
-                warning!(
-                    "ERROR. Failed to set ulimit value.",
-                    opts.greppable,
-                    opts.accessible
-                );
-            }
+    if let Some(limit) = opts.ulimit {
+        if Resource::NOFILE.set(limit, limit).is_ok() {
+            detail!(
+                format!("Automatically increasing ulimit value to {limit}."),
+                opts.greppable,
+                opts.accessible
+            );
+        } else {
+            warning!(
+                "ERROR. Failed to set ulimit value.",
+                opts.greppable,
+                opts.accessible
+            );
        }
    }

-    let (rlim, _) = getrlimit(Resource::NOFILE).unwrap();
-
-    rlim.as_raw()
+    let (soft, _) = Resource::NOFILE.get().unwrap();
+    soft
 }

-fn infer_batch_size(opts: &Opts, ulimit: RawRlim) -> u16 {
-    let mut batch_size: RawRlim = opts.batch_size.into();
+#[cfg(unix)]
+fn infer_batch_size(opts: &Opts, ulimit: u64) -> u16 {
+    use std::convert::TryInto;
+
+    let mut batch_size: u64 = opts.batch_size.into();

    // Adjust the batch size when the ulimit value is lower than the desired batch size
    if ulimit < batch_size {
@@ -342,18 +376,18 @@ fn infer_batch_size(opts: &Opts, ulimit: RawRlim) -> u16 {
        // When the OS supports high file limits like 8000, but the user
        // selected a batch size higher than this we should reduce it to
        // a lower number.
-        if ulimit < AVERAGE_BATCH_SIZE {
+        if ulimit < AVERAGE_BATCH_SIZE.into() {
            // 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);
            info!("Halving batch_size because ulimit is smaller than average batch size");
-            batch_size = ulimit / 2
+            batch_size = ulimit / 2;
        } else if ulimit > DEFAULT_FILE_DESCRIPTORS_LIMIT {
            info!("Batch size is now average batch size");
-            batch_size = AVERAGE_BATCH_SIZE
+            batch_size = AVERAGE_BATCH_SIZE.into();
        } else {
-            batch_size = ulimit - 100
+            batch_size = ulimit - 100;
        }
    }
    // When the ulimit is higher than the batch size let the user know that the
@@ -363,15 +397,21 @@ fn infer_batch_size(opts: &Opts, ulimit: RawRlim) -> u16 {
        opts.greppable, opts.accessible);
    }

-    batch_size as u16
+    batch_size
+        .try_into()
+        .expect("Couldn't fit the batch size into a u16.")
 }

 #[cfg(test)]
 mod tests {
-    use crate::{adjust_ulimit_size, infer_batch_size, parse_addresses, print_opening, Opts};
+    #[cfg(unix)]
+    use crate::{adjust_ulimit_size, infer_batch_size};
+
+    use crate::{parse_addresses, print_opening, Opts};
    use std::net::Ipv4Addr;

    #[test]
+    #[cfg(unix)]
    fn batch_size_lowered() {
        let mut opts = Opts::default();
        opts.batch_size = 50_000;
@@ -381,6 +421,7 @@ mod tests {
    }

    #[test]
+    #[cfg(unix)]
    fn batch_size_lowered_average_size() {
        let mut opts = Opts::default();
        opts.batch_size = 50_000;
@@ -389,6 +430,7 @@ mod tests {
        assert!(batch_size == 3_000);
    }
    #[test]
+    #[cfg(unix)]
    fn batch_size_equals_ulimit_lowered() {
        // because ulimit and batch size are same size, batch size is lowered
        // to ULIMIT - 100
@@ -399,6 +441,7 @@ mod tests {
        assert!(batch_size == 4_900);
    }
    #[test]
+    #[cfg(unix)]
    fn batch_size_adjusted_2000() {
        // ulimit == batch_size
        let mut opts = Opts::default();
@@ -414,9 +457,10 @@ mod tests {
        opts.ulimit = Some(2_000);
        // print opening should not panic
        print_opening(&opts);
-        assert!(1 == 1);
    }
+
    #[test]
+    #[cfg(unix)]
    fn test_high_ulimit_no_greppable_mode() {
        let mut opts = Opts::default();
        opts.batch_size = 10;
@@ -469,7 +513,7 @@ mod tests {
        opts.addresses = vec!["im_wrong".to_owned(), "300.10.1.1".to_owned()];
        let ips = parse_addresses(&opts);

-        assert_eq!(ips.is_empty(), true);
+        assert!(ips.is_empty());
    }
    #[test]
    fn parse_hosts_file_and_incorrect_hosts() {
@@ -16,7 +16,7 @@ pub enum PortStrategy {
 }

 impl PortStrategy {
-    pub fn pick(range: Option<PortRange>, 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 range = range.as_ref().unwrap();
@@ -44,7 +44,7 @@ impl PortStrategy {

    pub fn order(&self) -> Vec<u16> {
        match self {
-            PortStrategy::Manual(ports) => ports.to_vec(),
+            PortStrategy::Manual(ports) => ports.clone(),
            PortStrategy::Serial(range) => range.generate(),
            PortStrategy::Random(range) => range.generate(),
        }
@@ -102,7 +102,7 @@ mod tests {
    #[test]
    fn serial_strategy_with_range() {
        let range = PortRange { start: 1, end: 100 };
-        let strategy = PortStrategy::pick(Some(range), None, ScanOrder::Serial);
+        let strategy = PortStrategy::pick(&Some(range), None, ScanOrder::Serial);
        let result = strategy.order();
        let expected_range = (1..100).into_iter().collect::<Vec<u16>>();
        assert_eq!(expected_range, result);
@@ -110,30 +110,30 @@ mod tests {
    #[test]
    fn random_strategy_with_range() {
        let range = PortRange { start: 1, end: 100 };
-        let strategy = PortStrategy::pick(Some(range), None, ScanOrder::Random);
+        let strategy = PortStrategy::pick(&Some(range), None, ScanOrder::Random);
        let mut result = strategy.order();
        let expected_range = (1..100).into_iter().collect::<Vec<u16>>();
        assert_ne!(expected_range, result);

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

    #[test]
    fn serial_strategy_with_ports() {
-        let strategy = PortStrategy::pick(None, Some(vec![80, 443]), ScanOrder::Serial);
+        let strategy = PortStrategy::pick(&None, Some(vec![80, 443]), ScanOrder::Serial);
        let result = strategy.order();
        assert_eq!(vec![80, 443], result);
    }

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

-        result.sort();
+        result.sort_unstable();
        assert_eq!(expected_range, result);
    }
 }
@@ -1,5 +1,6 @@
 use gcd::Gcd;
 use rand::Rng;
+use std::convert::TryInto;

 pub struct RangeIterator {
    active: bool,
@@ -12,7 +13,7 @@ pub struct RangeIterator {

 /// An iterator that follows the `Linear Congruential Generator` algorithm.
 ///
-/// For more information: https://en.wikipedia.org/wiki/Linear_congruential_generator
+/// For more information: <https://en.wikipedia.org/wiki/Linear_congruential_generator>
 impl RangeIterator {
    /// Receives the the start and end of a range and normalize
    /// these values before selecting a coprime for the end of the range
@@ -60,7 +61,11 @@ impl Iterator for RangeIterator {
        }

        self.normalized_pick = next_pick;
-        Some((self.actual_start + current_pick) as u16)
+        Some(
+            (self.actual_start + current_pick)
+                .try_into()
+                .expect("Could not convert u32 to u16"),
+        )
    }
 }

@@ -84,9 +89,8 @@ fn pick_random_coprime(end: u32) -> u32 {
    for _ in 0..10 {
        if end.gcd(candidate) == 1 {
            return candidate;
-        } else {
-            candidate = rng.gen_range(lower_range, upper_range);
        }
+        candidate = rng.gen_range(lower_range, upper_range);
    }

    end - 1
@@ -122,7 +126,7 @@ mod tests {
    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();
+        result.sort_unstable();

        result
    }
@@ -6,10 +6,10 @@ use socket_iterator::SocketIterator;
 use async_std::io;
 use async_std::net::TcpStream;
 use async_std::prelude::*;
-use colored::*;
+use colored::Colorize;
 use futures::stream::FuturesUnordered;
 use std::{
-    io::ErrorKind,
+    collections::HashSet,
    net::{IpAddr, Shutdown, SocketAddr},
    num::NonZeroU8,
    time::Duration,
@@ -49,7 +49,7 @@ impl Scanner {
            tries: NonZeroU8::new(std::cmp::max(tries, 1)).unwrap(),
            greppable,
            port_strategy,
-            ips: ips.iter().map(|ip| ip.to_owned()).collect(),
+            ips: ips.iter().map(ToOwned::to_owned).collect(),
            accessible,
        }
    }
@@ -62,6 +62,7 @@ impl Scanner {
        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::with_capacity(self.ips.len() * 1000);

        for _ in 0..self.batch_size {
            if let Some(socket) = socket_iterator.next() {
@@ -82,10 +83,17 @@ impl Scanner {
                ftrs.push(self.scan_socket(socket));
            }

-            if let Ok(socket) = result {
-                open_sockets.push(socket);
+            match result {
+                Ok(socket) => open_sockets.push(socket),
+                Err(e) => {
+                    let error_string = e.to_string();
+                    if errors.len() < self.ips.len() * 1000 {
+                        errors.insert(error_string);
+                    }
+                }
            }
        }
+        debug!("Typical socket connection errors {:?}", errors);
        debug!("Open Sockets found: {:?}", &open_sockets);
        open_sockets
    }
@@ -117,7 +125,7 @@ impl Scanner {
                    }
                    if !self.greppable {
                        if self.accessible {
-                            println!("Open {}", socket.to_string());
+                            println!("Open {socket}");
                        } else {
                            println!("Open {}", socket.to_string().purple());
                        }
@@ -127,19 +135,13 @@ impl Scanner {
                    return Ok(socket);
                }
                Err(e) => {
-                    let error_string = e.to_string();
+                    let mut error_string = e.to_string();

-                    if e.kind() == ErrorKind::Other {
-                        debug!("Socket connect error: {} {}", &error_string, &socket);
-
-                        if !error_string.contains("No route to host")
-                            && !error_string.contains("Network is unreachable")
-                        {
-                            panic!("Too many open files. Please reduce batch size. The default is 5000. Try -b 2500.");
-                        }
-                    }
+                    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.");

                    if nr_try == tries {
+                        error_string.push(' ');
+                        error_string.push_str(&socket.ip().to_string());
                        return Err(io::Error::new(io::ErrorKind::Other, error_string));
                    }
                }
@@ -184,7 +186,7 @@ mod tests {
            start: 1,
            end: 1_000,
        };
-        let strategy = PortStrategy::pick(Some(range), None, ScanOrder::Random);
+        let strategy = PortStrategy::pick(&Some(range), None, ScanOrder::Random);
        let scanner = Scanner::new(
            &addrs,
            10,
@@ -206,7 +208,7 @@ mod tests {
            start: 1,
            end: 1_000,
        };
-        let strategy = PortStrategy::pick(Some(range), None, ScanOrder::Random);
+        let strategy = PortStrategy::pick(&Some(range), None, ScanOrder::Random);
        let scanner = Scanner::new(
            &addrs,
            10,
@@ -227,7 +229,7 @@ mod tests {
            start: 1,
            end: 1_000,
        };
-        let strategy = PortStrategy::pick(Some(range), None, ScanOrder::Random);
+        let strategy = PortStrategy::pick(&Some(range), None, ScanOrder::Random);
        let scanner = Scanner::new(
            &addrs,
            10,
@@ -247,7 +249,7 @@ mod tests {
            start: 400,
            end: 445,
        };
-        let strategy = PortStrategy::pick(Some(range), None, ScanOrder::Random);
+        let strategy = PortStrategy::pick(&Some(range), None, ScanOrder::Random);
        let scanner = Scanner::new(
            &addrs,
            10,
@@ -270,7 +272,7 @@ mod tests {
            start: 400,
            end: 600,
        };
-        let strategy = PortStrategy::pick(Some(range), None, ScanOrder::Random);
+        let strategy = PortStrategy::pick(&Some(range), None, ScanOrder::Random);
        let scanner = Scanner::new(
            &addrs,
            10,
@@ -17,7 +17,7 @@ pub struct SocketIterator<'s> {
 /// 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
-/// wihout generating a big memory footprint. The alternative would be
+/// 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 {
@@ -29,6 +29,7 @@ impl<'s> SocketIterator<'s> {
    }
 }

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

@@ -43,10 +44,9 @@ impl<'s> Iterator for SocketIterator<'s> {
    /// it.next(); // 192.168.0.1:443
    /// it.next(); // None
    fn next(&mut self) -> Option<Self::Item> {
-        match self.product_it.next() {
-            None => None,
-            Some((port, ip)) => Some(SocketAddr::new(*ip, *port)),
-        }
+        self.product_it
+            .next()
+            .map(|(port, ip)| SocketAddr::new(*ip, *port))
    }
 }

@@ -38,19 +38,23 @@
 //!     The {{ip}} part will be replaced with the ip we got from the scan.
 //!     The {{port}} part will be reaplced with the ports separated with the ports_separator found in the script file
 //!
-//! And when there is only {{ip}} and {{port}} is in the format, ony those will be replaced with the arguments from the scan.
+//! And when there is only {{ip}} and {{port}} is in the format, only those will be replaced with the arguments from the scan.
 //! This makes it easy to run a system installed command like nmap, and give any kind of arguments to it.
 //!
 //! If the format is different, the script will be silently discarded and will not run. With the Debug option it's possible to see where it goes wrong.

+#![allow(clippy::module_name_repetitions)]
+
 use crate::input::ScriptsRequired;
 use anyhow::{anyhow, Result};
 use serde_derive::{Deserialize, Serialize};
 use std::collections::HashSet;
+use std::convert::TryInto;
 use std::fs::{self, File};
 use std::io::{self, prelude::*};
 use std::net::IpAddr;
 use std::path::PathBuf;
+use std::string::ToString;
 use subprocess::{Exec, ExitStatus};
 use text_placeholder::Template;

@@ -68,14 +72,13 @@ pub fn init_scripts(scripts: ScriptsRequired) -> Result<Vec<ScriptFile>> {
        ScriptsRequired::None => Ok(scripts_to_run),
        ScriptsRequired::Default => {
            let default_script =
-                toml::from_str::<ScriptFile>(&DEFAULT).expect("Failed to parse Script file.");
+                toml::from_str::<ScriptFile>(DEFAULT).expect("Failed to parse Script file.");
            scripts_to_run.push(default_script);
            Ok(scripts_to_run)
        }
        ScriptsRequired::Custom => {
-            let scripts_dir_base = match dirs::home_dir() {
-                Some(dir) => dir,
-                None => return Err(anyhow!("Could not infer scripts path.")),
+            let Some(scripts_dir_base) = dirs::home_dir() else {
+                return Err(anyhow!("Could not infer scripts path."));
            };
            let script_paths = match find_scripts(scripts_dir_base) {
                Ok(script_paths) => script_paths,
@@ -101,7 +104,7 @@ pub fn init_scripts(scripts: ScriptsRequired) -> Result<Vec<ScriptFile>> {
                        let script_hashset: HashSet<String> =
                            script.tags.clone().unwrap().into_iter().collect();
                        if config_hashset.is_subset(&script_hashset) {
-                            scripts_to_run.push(script.to_owned());
+                            scripts_to_run.push(script.clone());
                        } else {
                            debug!(
                                "\nScript tags does not match config tags {:?} {}",
@@ -130,6 +133,7 @@ pub fn parse_scripts(scripts: Vec<PathBuf>) -> Vec<ScriptFile> {
 }

 #[derive(Clone, Debug)]
+#[allow(dead_code)]
 pub struct Script {
    // Path to the script itself.
    path: Option<PathBuf>,
@@ -197,7 +201,7 @@ impl Script {
        let mut ports_str = self
            .open_ports
            .iter()
-            .map(|port| port.to_string())
+            .map(ToString::to_string)
            .collect::<Vec<String>>()
            .join(&separator);
        if let Some(port) = self.trigger_port {
@@ -227,17 +231,9 @@ impl Script {
            };
            to_run = default_template.fill_with_struct(&exec_parts)?;
        }
+        debug!("\nScript format to run {}", to_run);

-        debug!("\nTo run {}", to_run);
-
-        let arguments = shell_words::split(
-            &to_run
-                .split(' ')
-                .map(|arg| arg.to_string())
-                .collect::<Vec<String>>()
-                .join(" "),
-        )
-        .expect("Failed to parse script arguments");
+        let arguments = shell_words::split(&to_run).expect("Failed to parse script arguments");

        execute_script(arguments)
    }
@@ -245,15 +241,15 @@ impl Script {

 #[cfg(not(tarpaulin_include))]
 fn execute_script(mut arguments: Vec<String>) -> Result<String> {
-    debug!("\nArguments vec: {:?}", &arguments);
-    let process = Exec::cmd(&arguments.remove(0)).args(&arguments);
+    debug!("\nScript arguments vec: {:?}", &arguments);
+    let process = Exec::cmd(arguments.remove(0)).args(&arguments);
    match process.capture() {
        Ok(c) => {
            let es = match c.exit_status {
-                ExitStatus::Exited(c) => c as i32,
-                ExitStatus::Signaled(c) => c as i32,
+                ExitStatus::Exited(c) => c.try_into().unwrap(),
+                ExitStatus::Signaled(c) => c.into(),
                ExitStatus::Other(c) => c,
-                _ => -1,
+                ExitStatus::Undetermined => -1,
            };
            if es != 0 {
                return Err(anyhow!("Exit code = {}", es));
@@ -278,7 +274,7 @@ pub fn find_scripts(mut path: PathBuf) -> Result<Vec<PathBuf>> {
        }
        Ok(files_vec)
    } else {
-        Err(anyhow!("Can't find scripts folder"))
+        Err(anyhow!("Can't find scripts folder {}", path.display()))
    }
 }

@@ -297,16 +293,14 @@ impl ScriptFile {
        let real_path = script.clone();
        let mut lines_buf = String::new();
        if let Ok(file) = File::open(script) {
-            for line in io::BufReader::new(file).lines().skip(1) {
-                if let Ok(mut line) = line {
-                    if line.starts_with('#') {
-                        line.retain(|c| c != '#');
-                        line = line.trim().to_string();
-                        line.push_str("\n");
-                        lines_buf.push_str(&line);
-                    } else {
-                        break;
-                    }
+            for mut line in io::BufReader::new(file).lines().skip(1).flatten() {
+                if line.starts_with('#') {
+                    line.retain(|c| c != '#');
+                    line = line.trim().to_string();
+                    line.push('\n');
+                    lines_buf.push_str(&line);
+                } else {
+                    break;
                }
            }
        } else {
@@ -340,9 +334,8 @@ pub struct ScriptConfig {
 #[cfg(not(tarpaulin_include))]
 impl ScriptConfig {
    pub fn read_config() -> Result<ScriptConfig> {
-        let mut home_dir = match dirs::home_dir() {
-            Some(dir) => dir,
-            None => return Err(anyhow!("Could not infer ScriptConfig path.")),
+        let Some(mut home_dir) = dirs::home_dir() else {
+            return Err(anyhow!("Could not infer ScriptConfig path."));
        };
        home_dir.push(".rustscan_scripts.toml");

@@ -380,7 +373,7 @@ mod tests {
    #[test]
    #[should_panic]
    fn find_invalid_folder() {
-        let scripts = find_scripts("Cargo.toml".into()).unwrap();
+        let _scripts = find_scripts("Cargo.toml".into()).unwrap();
    }

    #[test]
@@ -397,7 +390,7 @@ mod tests {
            ScriptFile::new("fixtures/.rustscan_scripts/test_script.txt".into()).unwrap();
        script_f.call_format = Some("qwertyuiop".to_string());
        let script: Script = into_script(script_f);
-        let output = script.run().unwrap();
+        let _output = script.run().unwrap();
    }

    #[test]
@@ -407,7 +400,7 @@ mod tests {
            ScriptFile::new("fixtures/.rustscan_scripts/test_script.txt".into()).unwrap();
        script_f.call_format = None;
        let script: Script = into_script(script_f);
-        let output = script.run().unwrap();
+        let _output = script.run().unwrap();
    }

    #[test]
@@ -439,6 +432,7 @@ mod tests {
    }

    #[test]
+    #[cfg(unix)]
    fn run_bash_script() {
        let script_f = ScriptFile::new("fixtures/.rustscan_scripts/test_script.sh".into()).unwrap();
        let script: Script = into_script(script_f);
@@ -460,6 +454,7 @@ mod tests {
    }

    #[test]
+    #[cfg(unix)]
    fn run_perl_script() {
        let script_f = ScriptFile::new("fixtures/.rustscan_scripts/test_script.pl".into()).unwrap();
        let script: Script = into_script(script_f);
@@ -4,18 +4,16 @@
 #[macro_export]
 macro_rules! warning {
    ($name:expr) => {
-        use ansi_term::Colour::Red;
-        println!("{} {}", Red.bold().paint("[!]"), $name);
+        println!("{} {}", ansi_term::Colour::Red.bold().paint("[!]"), $name);
    };
    ($name:expr, $greppable:expr, $accessible:expr) => {
-        use ansi_term::Colour::Red;
        // if not greppable then print, otherwise no else statement so do not print.
        if !$greppable {
            if $accessible {
                // Don't print the ascii art
                println!("{}", $name);
            } else {
-                println!("{} {}", Red.bold().paint("[!]"), $name);
+                println!("{} {}", ansi_term::Colour::Red.bold().paint("[!]"), $name);
            }
        }
    };
@@ -24,18 +22,16 @@ macro_rules! warning {
 #[macro_export]
 macro_rules! detail {
    ($name:expr) => {
-        use ansi_term::Colour::Blue;
-        println!("{} {}", Blue.bold().paint("[~]"), $name);
+        println!("{} {}", ansi_term::Colour::Blue.bold().paint("[~]"), $name);
    };
    ($name:expr, $greppable:expr, $accessible:expr) => {
-        use ansi_term::Colour::Blue;
        // if not greppable then print, otherwise no else statement so do not print.
        if !$greppable {
            if $accessible {
                // Don't print the ascii art
                println!("{}", $name);
            } else {
-                println!("{} {}", Blue.bold().paint("[~]"), $name);
+                println!("{} {}", ansi_term::Colour::Blue.bold().paint("[~]"), $name);
            }
        }
    };
@@ -44,18 +40,24 @@ macro_rules! detail {
 #[macro_export]
 macro_rules! output {
    ($name:expr) => {
-        use ansi_term::Colour::RGB;
-        println!("{} {}", RGB(0, 255, 9).bold().paint("[>]"), $name);
+        println!(
+            "{} {}",
+            RGansi_term::Colour::RGB(0, 255, 9).bold().paint("[>]"),
+            $name
+        );
    };
    ($name:expr, $greppable:expr, $accessible:expr) => {
-        use ansi_term::Colour::RGB;
        // if not greppable then print, otherwise no else statement so do not print.
        if !$greppable {
            if $accessible {
                // Don't print the ascii art
                println!("{}", $name);
            } else {
-                println!("{} {}", RGB(0, 255, 9).bold().paint("[>]"), $name);
+                println!(
+                    "{} {}",
+                    ansi_term::Colour::RGB(0, 255, 9).bold().paint("[>]"),
+                    $name
+                );
            }
        }
    };
@@ -72,10 +74,10 @@ macro_rules! funny_opening {
            "Real hackers hack time ⌛",
            "Please contribute more quotes to our GitHub https://github.com/rustscan/rustscan",
            "😵 https://admin.tryhackme.com",
+            "0day was here ♥",
        ];
        let random_quote = quotes.choose(&mut rand::thread_rng()).unwrap();

        println!("{}\n", random_quote);
-        // println!("{} {}", RGB(0, 255, 9).bold().paint("[>]"), $name);
    };
 }
@@ -35,7 +35,7 @@ fn run_rustscan_with_timeout(args: &[&str], timeout: Duration) {
                if tries == 0 {
                    // child hasn't exited yet
                    child.kill().unwrap();
-                    child.wait().unwrap().code();
+                    child.wait().unwrap().code().unwrap();
                    panic!("Timeout while running command");
                }
            }
Author	SHA1	Message	Date
Autumn	2288e2c29f	test PR	2024-04-06 21:56:49 +01:00
Ben (CMNatic)	0e582fdd16	Fix markdown-link-checker workflow (#542 ) * Fix markdown-link-checker workflow Added a configuration file that tells MLC to ignore the URLs in .github\workflows\mlc_config.json as MLC is falsely reporting these as dead * Update markdown.yml	2024-04-06 21:28:53 +01:00
Ben (CMNatic)	4c933b39a1	Merge pull request #538 from bergabman/master Fix clippy lint issues for CI/CD pipeline	2024-03-16 01:56:02 +00:00
Ben (CMNatic)	a3495b305b	Merge branch 'master' into master	2024-03-16 00:31:38 +00:00
Ben (CMNatic)	4bec0a8ea8	Merge pull request #525 from R-Rothrock/master Fixed #524 - banner formatting	2024-03-16 00:11:55 +00:00
bergabman	e86b86d0e0	clippy lint issues	2024-02-13 17:35:35 +01:00
Roan Rothrock	43d3a1ed5a	Fixed #524	2023-08-25 16:18:51 -05:00
Thaddeus Thomas	0f65753dcb	Update README.md (#520 ) * Update README.md Fixed the issue with the links closes #516 * Update README.md 1. Fixed the arch Linux link. Closes #519 2. Fixed Arch badge so it's linked to the correct version 3. Cleaned up missing links throughout the document 4. Moved all links other than the contributor's section to the end of the document for easier maintenance 5. Fixed language so it was grammatically correct	2023-08-12 08:30:30 +01:00
LePirlouit	2ab7191a65	🚨 Fix linter warning (#521 )	2023-07-10 20:02:23 +01:00
♠️ Thomas Gotwig ♣️andThomas Gotwig	d7c07c4c84	📝 Change broken link to tgotwig.dev (#398 ) Co-authored-by: Thomas Gotwig <[email protected]>	2023-06-18 19:08:16 +01:00
LePirlouitandAutumn	478851ac4c	🚨 fix linter warnings (#511 ) Co-authored-by: Autumn <[email protected]>	2023-06-18 19:07:35 +01:00
Thaddeus Thomas	1c7b080d6f	Update README.md (#517 ) Fixed the issue with the links closes #516	2023-06-18 19:06:21 +01:00
Ben (CMNatic)	7dd9352bae	Update recommended Docker image version Version 2.1.1 of RustScan has been uploaded to the DockerHub repo: https://hub.docker.com/layers/rustscan/rustscan/2.1.1/images/sha256-1ef645b90001c560923c2150d20e5509ced243122225dbb9daf7c1c0ac3d21b2?context=repo	2023-04-06 13:27:06 +01:00
Kian-Meng Ang	d3fdc0d796	Fix typos (#505 ) Found via `typos --format brief`	2023-03-04 18:19:36 +00:00
Laurent Erignoux	77853ad122	Minor documentation table fix for github.io (#491 ) * Adding missing paragraph closing in Readme * Using markdown :-: to center Readme packages table content	2023-02-02 07:40:33 +00:00
Peter Dave Hello	71f21aa259	Update Docker base image from alpine 3.12 to 3.17 (#484 ) Alpine Linux v3.12 is end of life about months, the builder base image is alreayd Alpine v3.17, and Alpine v3.17 is the latest stable release with about 2 more years support, should be good to ugprade to it. Signed-off-by: Peter Dave Hello <[email protected]> Signed-off-by: Peter Dave Hello <[email protected]>	2022-12-30 09:18:49 +00:00
dependabot-preview[bot]andBee	bcdb0df1d9	Upgrade to GitHub-native Dependabot (#382 ) Co-authored-by: dependabot-preview[bot] <27856297+dependabot-preview[bot]@users.noreply.github.com> Co-authored-by: Bee <[email protected]>	2022-12-23 11:42:04 +00:00
LeoFVO	5b00fa1727	build and publish docker image in ci (#472 ) * feat(docker): build and publish docker image in ci Signed-off-by: leofvo <[email protected]> * refactor(docker): updated dockerfile to build release version of rustscan Signed-off-by: leofvo <[email protected]>	2022-12-20 20:17:08 +00:00
LeoFVO	dde7d96256	fix(doc): minor lint fixes (#470 ) Signed-off-by: leofvo <[email protected]> Signed-off-by: leofvo <[email protected]>	2022-12-08 08:01:58 +00:00
LeoFVO	405f05d42c	Build CI to auto-distribute releases (#468 ) * refactor(ci): update build ci and add cross-compilation * cron check * remove fmt * cross-compile for tests * lint code * remove duplicate Signed-off-by: leofvo <[email protected]> * fix(code): code lint + fix bad practices Signed-off-by: leofvo <[email protected]> * test(windows): remove windows incompatible function for test when running on windows Signed-off-by: leofvo <[email protected]> * build(release): add release ci/cd * github workflow * cargo.toml improvment Signed-off-by: leofvo <[email protected]> Signed-off-by: leofvo <[email protected]>	2022-12-06 08:45:57 +00:00
Bee	9e1cb60a05	Update for ARM; (#464 )	2022-11-13 18:54:56 +00:00
autumn skerritt	8045af8cd2	Add release automation file	2022-11-12 16:41:14 +00:00
autumn skerritt	221cf8694f	Updating lock file	2022-11-12 16:36:44 +00:00
Bee	bd32f4ead4	2.1.1	2022-11-07 10:21:47 +00:00
Artem IvanovandBee	8625f939bf	Minor cosmetic changes (#453 ) * Minor cosmetic changes * Minor cosmetic changes * Update discord link Co-authored-by: Bee <[email protected]>	2022-11-07 10:16:14 +00:00
Thijs0x57andBee	8f608eaf99	fix links to Docker & Kali wiki (#433 ) In the readme there are 2 links to docker & kali, 'Usage' and 'Read the install guide'. These links weren't working. Co-authored-by: Bee <[email protected]>	2022-11-03 10:08:03 +00:00
NugineandBee	f9f2bf6cf8	Upgrade rlimit (#449 ) Co-authored-by: Bee <[email protected]>	2022-11-03 09:56:54 +00:00
Callum Haughtey-WilkinsonandBee	6fb1196244	Improve doc for addresses (#457 ) Improve documentation for addresses CLI arg to make it clear that file parsing of addresses is already supported (#452) Co-authored-by: Bee <[email protected]>	2022-11-02 15:23:02 +00:00
Callum Haughtey-Wilkinson	61c43dd5d0	Allow CLI customisation of config file path (#456 ) Allow CLI customisation of config file path with new optional argument. (#437)	2022-11-02 15:17:07 +00:00
Bee	075025113d	2.1.0 release	2022-04-27 13:30:24 +01:00
Bee	e3645b5c81	Update Cargo.lock file to support latest version of Rust (#435 )	2022-04-26 08:40:56 +01:00
Ryan Montgomery	a444ab66e1	Update tui.rs (#396 ) added a quote	2021-07-03 23:27:06 +01:00
dependabot-preview[bot]andBrandon	30856350d3	Bump futures from 0.3.7 to 0.3.13 (#358 ) Bumps [futures](https://github.com/rust-lang/futures-rs) from 0.3.7 to 0.3.13. - [Release notes](https://github.com/rust-lang/futures-rs/releases) - [Changelog](https://github.com/rust-lang/futures-rs/blob/master/CHANGELOG.md) - [Commits](https://github.com/rust-lang/futures-rs/compare/0.3.7...0.3.13) Signed-off-by: dependabot-preview[bot] <[email protected]> Co-authored-by: dependabot-preview[bot] <27856297+dependabot-preview[bot]@users.noreply.github.com> Co-authored-by: Brandon <[email protected]>	2021-03-29 08:17:19 +01:00
dependabot-preview[bot]andBrandon	7bff40a526	Bump rlimit from 0.5.2 to 0.5.4 (#360 ) Bumps [rlimit](https://github.com/Nugine/rlimit) from 0.5.2 to 0.5.4. - [Release notes](https://github.com/Nugine/rlimit/releases) - [Commits](https://github.com/Nugine/rlimit/compare/v0.5.2...v0.5.4) Signed-off-by: dependabot-preview[bot] <[email protected]> Co-authored-by: dependabot-preview[bot] <27856297+dependabot-preview[bot]@users.noreply.github.com> Co-authored-by: Brandon <[email protected]>	2021-03-29 08:16:43 +01:00
dependabot-preview[bot]andBrandon	a38c6aa13b	Bump cidr-utils from 0.5.0 to 0.5.1 (#367 ) Bumps [cidr-utils](https://github.com/magiclen/cidr-utils) from 0.5.0 to 0.5.1. - [Release notes](https://github.com/magiclen/cidr-utils/releases) - [Commits](https://github.com/magiclen/cidr-utils/compare/v0.5.0...v0.5.1) Signed-off-by: dependabot-preview[bot] <[email protected]> Co-authored-by: dependabot-preview[bot] <27856297+dependabot-preview[bot]@users.noreply.github.com> Co-authored-by: Brandon <[email protected]>	2021-03-29 08:16:03 +01:00
dependabot-preview[bot]	9b2c58fee5	Bump anyhow from 1.0.34 to 1.0.40 (#368 ) Bumps [anyhow](https://github.com/dtolnay/anyhow) from 1.0.34 to 1.0.40. - [Release notes](https://github.com/dtolnay/anyhow/releases) - [Commits](https://github.com/dtolnay/anyhow/compare/1.0.34...1.0.40) Signed-off-by: dependabot-preview[bot] <[email protected]> Co-authored-by: dependabot-preview[bot] <27856297+dependabot-preview[bot]@users.noreply.github.com>	2021-03-29 08:15:46 +01:00
dependabot-preview[bot]	198225a8da	Bump serde from 1.0.117 to 1.0.124 (#361 ) Bumps [serde](https://github.com/serde-rs/serde) from 1.0.117 to 1.0.124. - [Release notes](https://github.com/serde-rs/serde/releases) - [Commits](https://github.com/serde-rs/serde/compare/v1.0.117...v1.0.124) Signed-off-by: dependabot-preview[bot] <[email protected]> Co-authored-by: dependabot-preview[bot] <27856297+dependabot-preview[bot]@users.noreply.github.com>	2021-03-20 18:29:16 +00:00
Thomas de Queiroz Barros	9a9dff422e	Partially fix #362 : Fix examples (#363 ) Include -a to specify addresses	2021-03-20 18:28:59 +00:00
Brandon	227703a57e	Update README.md	2021-03-08 19:39:44 +00:00
bergabman	90bbed2a17	Scripting engine extra user argument interpretation error fixed. Scanner engine errors and error handling clarified. (#325 )	2020-12-07 12:28:16 +00:00
dependabot-preview[bot]	311cafcdbc	Bump env_logger from 0.8.1 to 0.8.2 (#317 ) Bumps [env_logger](https://github.com/env-logger-rs/env_logger) from 0.8.1 to 0.8.2. - [Release notes](https://github.com/env-logger-rs/env_logger/releases) - [Changelog](https://github.com/env-logger-rs/env_logger/blob/master/CHANGELOG.md) - [Commits](https://github.com/env-logger-rs/env_logger/compare/v0.8.1...v0.8.2) Signed-off-by: dependabot-preview[bot] <[email protected]> Co-authored-by: dependabot-preview[bot] <27856297+dependabot-preview[bot]@users.noreply.github.com>	2020-11-23 22:41:41 +00:00
bee	02f1f6c7d1	fixing cargo lock	2020-11-06 12:32:13 +00:00
bee	2182a1bd01	Merge branch 'master' of github.com:RustScan/RustScan	2020-11-06 01:44:04 +00:00
bee	0a42331dab	update logo	2020-11-06 01:43:56 +00:00
Bee	a5e5797f9e	Delete bump.yml	2020-11-06 00:07:23 +00:00
bee	9f2a752fb4	2.0	2020-11-05 22:26:16 +00:00
bee	57de97bdc4	cargo.lock	2020-11-05 22:25:53 +00:00
dependabot-preview[bot]andBee	846afbdd5a	Bump anyhow from 1.0.33 to 1.0.34 (#304 ) Bumps [anyhow](https://github.com/dtolnay/anyhow) from 1.0.33 to 1.0.34. - [Release notes](https://github.com/dtolnay/anyhow/releases) - [Commits](https://github.com/dtolnay/anyhow/compare/1.0.33...1.0.34) Signed-off-by: dependabot-preview[bot] <[email protected]> Co-authored-by: dependabot-preview[bot] <27856297+dependabot-preview[bot]@users.noreply.github.com> Co-authored-by: Bee <[email protected]>	2020-11-05 12:17:12 +00:00
dependabot-preview[bot]andBee	52bf521a5d	Bump async-std from 1.6.5 to 1.7.0 (#306 ) Bumps [async-std](https://github.com/async-rs/async-std) from 1.6.5 to 1.7.0. - [Release notes](https://github.com/async-rs/async-std/releases) - [Changelog](https://github.com/async-rs/async-std/blob/master/CHANGELOG.md) - [Commits](https://github.com/async-rs/async-std/compare/v1.6.5...v1.7.0) Signed-off-by: dependabot-preview[bot] <[email protected]> Co-authored-by: dependabot-preview[bot] <27856297+dependabot-preview[bot]@users.noreply.github.com> Co-authored-by: Bee <[email protected]>	2020-11-05 12:17:01 +00:00
Beeandbee	bef54d1496	Redesign of README (#293 ) Updated README Co-authored-by: bee <[email protected]>	2020-11-05 12:13:47 +00:00
dependabot-preview[bot]	76b3116b42	Bump futures from 0.3.6 to 0.3.7 (#302 ) Bumps [futures](https://github.com/rust-lang/futures-rs) from 0.3.6 to 0.3.7. - [Release notes](https://github.com/rust-lang/futures-rs/releases) - [Changelog](https://github.com/rust-lang/futures-rs/blob/master/CHANGELOG.md) - [Commits](https://github.com/rust-lang/futures-rs/compare/0.3.6...0.3.7) Signed-off-by: dependabot-preview[bot] <[email protected]> Co-authored-by: dependabot-preview[bot] <27856297+dependabot-preview[bot]@users.noreply.github.com>	2020-10-26 19:09:15 +00:00
shahar481andBee	73665ed16e	Changed the dns resolving to use std::net::ToSocketAddrs (#264 ) * Changed dns resolving library to to_socket_addrs and removed the usage of trust-dns * Reverted automatic IDE spacing * Ran cargo fmt on the code * Made trust-dns a fallback dns resolver and reverted cargo toml and lock * Reverted cargo.lock * Ran cargo fmt * Changed style of err checking * Fixed errors * Fixed merging errors * Changed for CR Co-authored-by: Bee <[email protected]>	2020-10-24 13:11:18 +01:00
bergabman	21b92a1d1b	Improve error handling in scripts init (#300 )	2020-10-24 13:06:31 +01:00
Niklas Mohrin	f9a7586857	Better enforce clippy lints (#294 ) * Clippy deny default lints and warn for clippy::pedantic * Fix all existing pedantic clippy lints on stable and nightly	2020-10-21 19:46:07 +01:00
eiffel-fl	6c05775394	Add some instructions to create contributing development environment. (#298 ) A new Dockerfile "contributing.Dockerfile" was added. This Dockerfile permits creating a "ready to develop" container image to ease contributing to RustScan. The instructions to use it are detailed in contributing.md.	2020-10-21 12:55:03 +01:00
dependabot-preview[bot]	043be7d6af	Bump env_logger from 0.7.1 to 0.8.1 (#295 ) Bumps [env_logger](https://github.com/env-logger-rs/env_logger) from 0.7.1 to 0.8.1. - [Release notes](https://github.com/env-logger-rs/env_logger/releases) - [Changelog](https://github.com/env-logger-rs/env_logger/blob/master/CHANGELOG.md) - [Commits](https://github.com/env-logger-rs/env_logger/compare/v0.7.1...v0.8.1) Signed-off-by: dependabot-preview[bot] <[email protected]> Co-authored-by: dependabot-preview[bot] <27856297+dependabot-preview[bot]@users.noreply.github.com>	2020-10-19 11:44:03 +01:00
				`@@ -0,0 +1 @@`
				`cargo publish && cargo build --release && git add Cargo.lock && git commit -m 'Updating lock file' && gpsup`