優選IP程序

優選IP程序，實測50W個IP ping 4次取平均值，獲取延遲最低前十只需要幾秒鐘，會動手的自己編譯

下載地址

遊客，如果您要查看本帖隱藏內容請回復

./ipopt.exe ipv4 ip.txt

ip.txt內容 示例 1.1.1.1/24  壹行壹個

1. use std::{
   
2.     result,
   
3.     env,
   
4.     net::IpAddr,
   
5.     time::Duration,
   
6.     io::BufRead,
   
7.     collections::HashMap,
   
8. };
   
9. use futures::future::join_all;
   
10. use rand::random;
    
11. use surge_ping::{Client, Config, IcmpPacket, PingIdentifier, PingSequence, ICMP};
    
12. use tokio::time;
    
13. use ipnet::{Ipv4Net, Ipv6Net};
    
14. 
    
15. #[tokio::main]
    
16. async fn main() -> Result<(), Box<dyn std::error::Error>> {
    
17.     let args: Vec<String> = env::args().collect();
    
18.     let ips = get_ip_from_file(&args[2]).await?;
    
19.     let ipaddrs = get_ip_range(&args[1], ips).await?;
    
20.     let client_v4 = Client::new(&Config::default())?;
    
21.     let client_v6 = Client::new(&Config::builder().kind(ICMP::V6).build())?;
    
22.     let mut tasks = Vec::new();
    
23. 
    
24.     for ip in &ipaddrs {
    
25.         match ip.parse() {
    
26.             Ok(IpAddr::V4(addr)) => {
    
27.                 tasks.push(tokio::spawn(ping(client_v4.clone(), IpAddr::V4(addr))))
    
28. 
    
29.             }
    
30.             Ok(IpAddr::V6(addr)) => {
    
31.                 tasks.push(tokio::spawn(ping(client_v6.clone(), IpAddr::V6(addr))))
    
32.             }
    
33.             Err(e) => println!("{} parse to ipaddr error: {}", ip, e),
    
34.         }
    
35.     }
    
36.     let results: Vec<_> = join_all(tasks).await.into_iter().filter_map(Result::ok).collect();
    
37.     let mut ip_map = HashMap::new();
    
38. 
    
39.     for result in results {
    
40.         match result {
    
41.             Ok((ip, delay)) => {
    
42.                 ip_map.insert(ip, delay);
    
43.             }
    
44.             Err(e) => {
    
45.                 eprintln!("Error occurred: {:?}", e);
    
46.             }
    
47.         }
    
48.     }
    
49.     let top_10: Vec<_> = ip_map.into_iter()
    
50.     .filter(|(_, delay)| delay.as_millis() > 0)
    
51.     .collect::<Vec<_>>()
    
52.     .into_iter()
    
53.     .sorted_by(|(_, delay1), (_, delay2)| delay1.cmp(delay2))
    
54.     .take(10)
    
55.     .collect();
    
56. 
    
57.     for (ip, delay) in top_10 {
    
58.         println!("{} {:?}", ip, delay.as_millis());
    
59.     }
    
60.     Ok(())
    
61. }
    
62. async fn ping(client: Client, addr: IpAddr) -> Result<(IpAddr, Duration), Box<dyn std::error::Error + Send + 'static>> {
    
63.     let payload = [0; 56];
    
64.     let mut pinger = client.pinger(addr, PingIdentifier(random())).await;
    
65.     let mut interval = time::interval(Duration::from_secs(1));
    
66.     let mut delays = Vec::new();
    
67. 
    
68.     for idx in 0..4 {
    
69.         interval.tick().await;
    
70.         match pinger.ping(PingSequence(idx), &payload).await {
    
71.             Ok((IcmpPacket::V4(_packet), dur)) => {
    
72.                 delays.push(dur);
    
73.             }
    
74.             Ok((IcmpPacket::V6(_packet), dur)) => {
    
75.                 delays.push(dur);
    
76.             }
    
77.             Err(_e) => {
    
78.             }
    
79.         };
    
80.     }
    
81.     let average_delay = if !delays.is_empty() {
    
82.         let total: Duration = delays.iter().sum();
    
83.         total / delays.len() as u32
    
84.     } else {
    
85.         Duration::new(0, 0)
    
86.     };
    
87.     Ok((addr, average_delay))
    
88. }
    
89. 
    
90. async fn get_ip_from_file(file_path: &str) -> Result<Vec<String>, Box<dyn std::error::Error>> {
    
91.     let mut ips = Vec::new();
    
92.     let file = std::fs::File::open(file_path)?;
    
93.     let mut buf_reader = std::io::BufReader::new(file);
    
94.     let mut line = String::new();
    
95.    
    
96.     while buf_reader.read_line(&mut line).unwrap() > 0 {
    
97.         let ip = line.trim();
    
98.         ips.push(ip.to_string());
    
99.         line.clear();
    
100.     }
     
101.     Ok(ips)
     
102. }
     
103. 
     
104. 
     
105. async fn get_ip_range(ip_type: &str, ips: Vec<String>) -> result::Result<Vec<String>, Box<dyn std::error::Error>> {
     
106.     let mut ip_subnets = Vec::new();
     
107. 
     
108.     match ip_type {
     
109.         "ipv4" => {
     
110.             for ip in ips {
     
111.                 let net: Ipv4Net = ip.parse().unwrap();
     
112.                 let subnets = net.subnets(32).expect("PrefixLenError: new prefix length cannot be shorter than existing");
     
113.                 for (_i, n) in subnets.enumerate() {
     
114.                     ip_subnets.push(n.to_string());
     
115.                 }
     
116.             }
     
117.         }
     
118.         "ipv6" => {
     
119.             for ip in ips {
     
120.                 let net: Ipv6Net = ip.parse().unwrap();
     
121.                 let subnets = net.subnets(128).expect("PrefixLenError: new prefix length cannot be shorter than existing");
     
122.                 for (_i, n) in subnets.enumerate() {
     
123.                     ip_subnets.push(n.to_string());
     
124.                 }
     
125.             }
     
126.         }
     
127.         _ => {
     
128.             return Err(Box::new(std::io::Error::new(std::io::ErrorKind::InvalidInput, "Invalid IP type")));
     
129.         }
     
130.     }
     
131.     let ip_range: Vec<String> =  ip_subnets.into_iter().map(|subnet: String| subnet.split('/').next().unwrap().to_string()).collect();
     
132.     Ok(ip_range)
     
133. }

複製代碼