setup the sniffer

Author: judeVector

.gitignore

@@ -0,0 +1 @@
+/target

Cargo.lock

@@ -0,0 +1,8 @@
+[package]
+name = "ip_sniffer"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

Cargo.toml

@@ -0,0 +1,54 @@
+use std::net::IpAddr;
+use std::str::FromStr;
+
+pub struct Arguments {
+    pub flag: String,
+    pub ipaddr: IpAddr,
+    pub threads: u16,
+}
+
+mod utils {}
+
+impl Arguments {
+    pub fn new(args: &[String]) -> std::result::Result<Arguments, &'static str> {
+        if args.len() < 2 {
+            return Err("Not enough arguments");
+        } else if args.len() > 4 {
+            return Err("Too many arguments");
+        }
+
+        let f = &args[1];
+        if let Ok(ipaddr) = IpAddr::from_str(&f) {
+            return Ok(Arguments {
+                flag: String::from(""),
+                ipaddr,
+                threads: 4,
+            });
+        } else {
+            let flag = &args[1];
+            if flag.contains("-h") || flag.contains("-help") && args.len() == 2 {
+                println!(
+                    "Usage: -j to select how many threads you want
+                \r\n -h or -help to show this help message"
+                );
+                return Err("too many arguments");
+            } else if flag.contains("-j") {
+                let ipaddr = match IpAddr::from_str(&args[3]) {
+                    Ok(s) => s,
+                    Err(_) => return Err("Not a valid ip address; must be IPV4 or IPV6"),
+                };
+                let threads = match args[2].parse::<u16>() {
+                    Ok(s) => s,
+                    Err(_) => return Err("failed to parse thread number"),
+                };
+                return Ok(Arguments {
+                    threads,
+                    flag: flag.to_string(), // Convert `&String` to `String`
+                    ipaddr,
+                });
+            } else {
+                return Err("invalid syntax");
+            }
+        }
+    }
+}

src/lib.rs

@@ -0,0 +1,66 @@
+use std::env;
+use std::io::{self, Write};
+use std::net::{IpAddr, TcpStream};
+use std::process;
+use std::sync::mpsc::{channel, Sender};
+use std::thread;
+
+mod lib;
+
+use lib::Arguments;
+
+const MAX: u16 = 65535;
+
+fn scan(tx: Sender<u16>, start_port: u16, addr: IpAddr, num_threads: u16) {
+    let mut port = start_port + 1;
+    loop {
+        match TcpStream::connect((addr, port)) {
+            Ok(_) => {
+                print!(".");
+                io::stdout().flush().unwrap();
+                tx.send(port).unwrap();
+            }
+            Err(_) => {}
+        }
+        if (MAX - port) <= num_threads {
+            break;
+        }
+        port += num_threads;
+    }
+}
+
+fn main() {
+    let args: Vec<String> = env::args().collect();
+    let program = &args[0];
+
+    let arguments = Arguments::new(&args).unwrap_or_else(|err| {
+        if err.contains("help") {
+            process::exit(0);
+        } else {
+            eprintln!("{} problem parsing arguments: {}", program, err);
+            process::exit(0);
+        }
+    });
+
+    let num_threads = arguments.threads;
+    let addr = arguments.ipaddr;
+    let (tx, rx) = channel();
+    for i in 0..num_threads {
+        let tx = tx.clone();
+
+        // thread::spawn(move || scan(tx, i, arguments.ipaddr, num_threads));
+        thread::spawn(move || scan(tx, i, addr, num_threads));
+    }
+
+    let mut out = vec![];
+    drop(tx);
+    for p in rx {
+        out.push(p);
+    }
+
+    println!("");
+    out.sort();
+    for v in out {
+        println!("{} is open", v);
+    }
+}