通过例子学rust(端口嗅探器)

use std::env;

fn main() {
    let args: Vec<String> = env::args().collect();
    println!("------");
    for i in &args {
        println!("{}",i)
    }
    println!("{:?}",args)
}

use std::net::IpAddr;

struct Arguments {
    flag: String,
    ipaddr: IpAddr,
    threads: u16,
}
impl Arguments {
    fn new(args: &[String]) -> Result<Arguments, &'static str> {
        //使用&'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].clone();
        if let Ok(ipaddr) = IpAddr::from_str(&f) {
            return Ok(Arguments { flag: String::from(""), ipaddr, threads: 4 })
        // scanner  $IP  使用默认值直接扫描的情况
            
            
        } else {
            let flag = args[1].clone();
            //判断flag类型
            if flag.contains("-h") || flag.contains("-help") && args.len() == 2 {
                println!("Usage: -j to select how many threads you want \
                \r\n       -h rot -help to show this help message");
                return Err("help");
            } else if flag.contains("-h") || flag.contains("-help") {
                //参数数量不对的情况
                
                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 pars thread number")
                };
                return Ok(Arguments { threads, flag, ipaddr })
            } else {
                return Err("invalid syntax")
            }
        }
    }
}

fn main() {
    let args: Vec<String> = env::args().collect();
    
    let program = args[0].clone();
    let arguments = Arguments::new(&args).unwrap_or_else(|err| {
    //使用闭包处理错误
        if err.contains("help") {
            process::exit(0);
        } else {
            println!("{} 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, 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);
   }

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
    }
}