added async calls to the backend to run nmap in parallel.

backend/api/info.py

@@ -2,6 +2,7 @@
 from fastapi import APIRouter
 import FindMyIP as ip
 from loguru import logger
+from scan.nmap import NmapScanner
 
 router = APIRouter()
 
@@ -14,6 +15,18 @@ def get_ip_info():
     return {"internet_connected": ip.internet(), "internal_ip": ip.internal(), "external_ip": ip.external()}
 
 
+@router.get("/info/nmap_info", tags=["info"])
+def which_nmap():
+    """
+    Returns the path to the nmap binary.
+    """
+    scanner = NmapScanner()
+    nmap_version = scanner.nmap_version()
+    which_nmap = scanner.which_nmap()
+
+    return {"nmap_version": nmap_version, "namp_path": which_nmap}
+
+
 @router.get("/info/is_root", tags=["info"])
 def is_root():
     """

backend/api/scan.py

@@ -24,6 +24,7 @@ async def scan_basic(ip_address: str):
     In NMap terms, it runs a basic no-port-scan (nmap -sn --traceroute).
     """
     nmap_scanner = NmapScanner()
+
     result = nmap_scanner.scan(ip_address, "ping")
     return {"result": result}
 

frontend/src/routes/home.tsx

@@ -8,7 +8,8 @@ import {
   Row,
   Toast,
 } from "react-bootstrap";
-import { scanPingType } from "../services/Client";
+import { fetchIPList, fetchPingData } from "../services/Client";
+import { IPListToRange } from "../utils/IPUtils";
 
 const Home = () => {
   const [scanFormData, setScanFormData] = useState({
@@ -49,13 +50,59 @@ const Home = () => {
       `Scan started for IP Address(es): ${scanFormData.ipAddress}`
     );
 
-    // Send the scan request to the backend
-    // scanListType(scanFormData.ipAddress).then((data) => {
-    //   console.log("Scan Response: ", data);
-    // });
+    // const result = doFullScan(scanFormData.ipAddress);
 
-    scanPingType(scanFormData.ipAddress).then((data) => {
-      console.log("Ping Response: ", data);
+    let ipList = fetchIPList(scanFormData.ipAddress);
+    ipList.then((data) => {
+      console.log("IP List: ", data);
+      if (data.length === 0) {
+        console.log("No IP Address found in the given range");
+        return;
+      }
+
+      // get host IP object
+      const hosts = data.result.nmaprun.host;
+
+      console.log("Hosts: ", hosts);
+
+      // divide hosts into chunks of 10 for parallel scanning
+      const chunkSize = 10;
+      const chunkedHosts = [];
+      for (let i = 0; i < hosts.length; i += chunkSize) {
+        chunkedHosts.push(hosts.slice(i, i + chunkSize));
+      }
+
+      console.log("Chunked Hosts: ", chunkedHosts);
+
+      // for each chunk, convert the IP list to IP range and scan in parallel
+      chunkedHosts.forEach((chunk: any) => {
+        const ipRange = IPListToRange(
+          chunk.map((host: any) => host.address["@addr"])
+        );
+        console.log("IP Range: ", ipRange);
+
+        fetchPingData(ipRange)
+          .then((data) => {
+            console.log("Ping Data: ", data);
+
+            // Sometimes host is missing, if all IPs are down.
+            if ("host" in data.result.nmaprun) {
+              const hosts = data.result.nmaprun.host;
+
+              // hosts can be an array, when multiple hosts are up. Otherwise, it's an object.
+              if (hosts.isArray) {
+                hosts.forEach((host: any) => {
+                  console.log("Host: ", host);
+                });
+              } else {
+                console.log("Host: ", hosts);
+              }
+            }
+          })
+          .finally(() => {
+            console.log("Ping scan completed");
+          });
+      });
     });
   };
 

frontend/src/services/Client.ts

@@ -1,13 +1,68 @@
+import { IPListToRange } from "../utils/IPUtils";
+
 export const BASE_URI = import.meta.env.VITE_API_URL;
 
-export const scanListType = async (ip_arg: string) => {
-  const response = await fetch(`${BASE_URI}/scan/list/${ip_arg}`);
+export const fetchPingData = async (ip_arg: string) => {
+  const response = await fetch(`${BASE_URI}/scan/ping/${ip_arg}`);
   const data = await response.json();
   return data;
 };
 
-export const scanPingType = async (ip_arg: string) => {
-  const response = await fetch(`${BASE_URI}/scan/ping/${ip_arg}`);
+export const fetchIPList = async (ip_arg: string) => {
+  const response = await fetch(`${BASE_URI}/scan/list/${ip_arg}`);
   const data = await response.json();
   return data;
 };
+
+const doFullScan = async (ip_arg: string) => {
+  let ipList = fetchIPList(ip_arg);
+  ipList.then((data) => {
+    console.log("IP List: ", data);
+    if (data.length === 0) {
+      console.log("No IP Address found in the given range");
+      return;
+    }
+
+    // get host IP object
+    const hosts = data.result.nmaprun.host;
+
+    console.log("Hosts: ", hosts);
+
+    // divide hosts into chunks of 10 for parallel scanning
+    const chunkSize = 10;
+    const chunkedHosts = [];
+    for (let i = 0; i < hosts.length; i += chunkSize) {
+      chunkedHosts.push(hosts.slice(i, i + chunkSize));
+    }
+
+    console.log("Chunked Hosts: ", chunkedHosts);
+
+    // for each chunk, convert the IP list to IP range and scan in parallel
+    chunkedHosts.forEach((chunk: any) => {
+      const ipRange = IPListToRange(
+        chunk.map((host: any) => host.address["@addr"])
+      );
+      console.log("IP Range: ", ipRange);
+
+      fetchPingData(ipRange).then((data) => {
+        console.log("Ping Data: ", data);
+
+        // Sometimes host is missing, if all IPs are down.
+        if ("host" in data.result.nmaprun) {
+          const hosts = data.result.nmaprun.host;
+
+          // hosts can be an array, when multiple hosts are up. Otherwise, it's an object.
+          if (hosts.isArray) {
+            hosts.forEach((host: any) => {
+              console.log("Host: ", host);
+            });
+          } else {
+            console.log("Host: ", hosts);
+          }
+        }
+      });
+    });
+  });
+};
+
+export default doFullScan;

frontend/src/utils/IPUtils.ts

@@ -0,0 +1,27 @@
+// Function to convert a range of IP addresses to a list of IP addresses
+// Abandon all hope, ye who enter here
+export const IPListToRange = (ipList: string[]): string => {
+  let ipRange: string;
+
+  if (ipList.length === 0) {
+    return "";
+  }
+
+  const sortedIPList = ipList
+    .map((ip) => {
+      return ip.split(".").map((octet) => {
+        return parseInt(octet);
+      });
+    })
+    .sort((a, b) => {
+      return a[0] - b[0] || a[1] - b[1] || a[2] - b[2] || a[3] - b[3];
+    });
+
+  const baseIP = sortedIPList[0].slice(0, 3).join("."); // get the base IP - first three octets
+  let startIP = sortedIPList[0][3]; // get the start IP - last octet
+  let endIP = sortedIPList[sortedIPList.length - 1][3]; // get the end IP - last octet
+
+  ipRange = `${baseIP}.${startIP}-${endIP}`;
+
+  return ipRange;
+};