v1.1

switch/src/nat/check.rs

@@ -2,8 +2,8 @@ use std::collections::HashSet;
 use std::net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket};
 use std::time::Duration;
 use std::{io, thread};
+use nat_traversal::punch::NatType;
 
-use crate::proto::message::NatType;
 
 // #[derive(Debug, Copy, Clone, PartialEq)]
 // pub enum NatType {
@@ -79,9 +79,6 @@ pub fn public_ip_list_(
     for addr in addrs {
         let _ = udp.send_to(b"NatTest", addr)?;
     }
-    // let _ = udp.send_to(b"NatTest", "nat1.wherewego.top:35062")?;
-    // let _ = udp.send_to(b"NatTest", "nat2.wherewego.top:35061")?;
-    // let _ = udp.send_to(b"NatTest", "nat2.wherewego.top:35062")?;
     let mut hash_set = HashSet::new();
     let mut count = 0;
     let mut min_port = 65535;
@@ -99,7 +96,6 @@ pub fn public_ip_list_(
                 max_port = port;
             }
             let ip = Ipv4Addr::new(buf[10], buf[11], buf[12], buf[13]);
-            // println!("pub  {:?}:{}", ip, port);
             hash_set.insert(ip);
             count += 1;
         }

switch/src/nat/mod.rs

@@ -1 +1,78 @@
+use std::net::{IpAddr, Ipv4Addr, SocketAddr};
+use std::sync::Arc;
+use parking_lot::Mutex;
+use nat_traversal::punch::{NatInfo, NatType};
+use crate::proto::message::PunchNatType;
+
 pub mod check;
+
+
+#[derive(Clone)]
+pub struct NatTest {
+    nat_test_server: Arc<Vec<SocketAddr>>,
+    info: Arc<Mutex<NatInfo>>,
+}
+
+impl From<NatType> for PunchNatType {
+    fn from(value: NatType) -> Self {
+        match value {
+            NatType::Symmetric => PunchNatType::Symmetric,
+            NatType::Cone => PunchNatType::Cone
+        }
+    }
+}
+
+impl Into<NatType> for PunchNatType {
+    fn into(self) -> NatType {
+        match self {
+            PunchNatType::Symmetric => NatType::Symmetric,
+            PunchNatType::Cone => NatType::Cone
+        }
+    }
+}
+
+impl NatTest {
+    pub fn new(nat_test_server: Vec<SocketAddr>, public_ip: Ipv4Addr, public_port: u16, local_ip: IpAddr, local_port: u16) -> NatTest {
+        let info = NatTest::re_test_(&nat_test_server, public_ip, public_port, local_ip, local_port);
+        NatTest {
+            nat_test_server: Arc::new(nat_test_server),
+            info: Arc::new(Mutex::new(info)),
+        }
+    }
+    pub fn nat_info(&self) -> NatInfo {
+        self.info.lock().clone()
+    }
+    pub fn re_test(&self, public_ip: Ipv4Addr, public_port: u16, local_ip: IpAddr, local_port: u16) -> NatInfo {
+        let info = NatTest::re_test_(&self.nat_test_server, public_ip, public_port, local_ip, local_port);
+        *self.info.lock() = info.clone();
+        info
+    }
+    fn re_test_(nat_test_server: &Vec<SocketAddr>, public_ip: Ipv4Addr, public_port: u16, local_ip: IpAddr, local_port: u16) -> NatInfo {
+        return match check::public_ip_list(nat_test_server) {
+            Ok((nat_type, ips, port_range)) => {
+                let mut public_ips = Vec::new();
+                public_ips.push(IpAddr::from(public_ip));
+                for ip in ips {
+                    if ip != public_ip {
+                        public_ips.push(IpAddr::from(ip));
+                    }
+                }
+                NatInfo::new(public_ips,
+                             public_port,
+                             port_range,
+                             local_ip, local_port,
+                             nat_type, )
+            }
+            Err(e) => {
+                log::warn!("{:?}",e);
+                NatInfo::new(
+                    vec![IpAddr::from(public_ip)],
+                    public_port,
+                    0,
+                    local_ip, local_port,
+                    NatType::Cone,
+                )
+            }
+        };
+    }
+}