修复连接tcp地址的问题

common/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "common"
-version = "1.2.7"
+version = "1.2.8"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

vnt-cli/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "vnt-cli"
-version = "1.2.7"
+version = "1.2.8"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

vnt-jni/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "vnt-jni"
-version = "1.2.7"
+version = "1.2.8"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

vnt/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "vnt"
-version = "1.2.7"
+version = "1.2.8"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

vnt/src/channel/channel.rs

@@ -1,8 +1,8 @@
 use std::collections::HashMap;
 use std::io::{Read, Write};
-use std::net::TcpStream;
 use std::net::UdpSocket as StdUdpSocket;
-use std::net::{Ipv4Addr, Ipv6Addr, Shutdown, SocketAddr};
+use std::net::{Ipv4Addr, Shutdown, SocketAddr};
+use std::net::{SocketAddrV6, TcpStream};
 use std::sync::Arc;
 use std::time::{Duration, Instant};
 use std::{io, thread};
@@ -13,7 +13,7 @@ use tokio::net::UdpSocket;
 use tokio::sync::watch::{channel, Receiver, Sender};
 
 use crate::channel::punch::NatType;
-use crate::channel::{Route, RouteKey, Status, TCP_ID, UDP_ID, UDP_V6_ID};
+use crate::channel::{Route, RouteKey, Status, TCP_ID, UDP_ID};
 use crate::core::status::VntWorker;
 use crate::handle::recv_handler::ChannelDataHandler;
 use crate::handle::CurrentDeviceInfo;
@@ -21,7 +21,6 @@ use crate::handle::CurrentDeviceInfo;
 pub struct ContextInner {
     //udp用于打洞、服务端通信(可选)
     pub(crate) main_channel: Arc<StdUdpSocket>,
-    pub(crate) main_channel_ipv6: Option<Arc<StdUdpSocket>>,
     //在udp的基础上，可以选择使用tcp和服务端通信
     pub(crate) main_tcp_channel: Option<std::sync::mpsc::SyncSender<Vec<u8>>>,
     pub(crate) route_table: RwLock<HashMap<Ipv4Addr, Vec<(Route, AtomicCell<Instant>)>>>,
@@ -41,7 +40,6 @@ pub struct Context {
 impl Context {
     pub fn new(
         main_channel: Arc<StdUdpSocket>,
-        main_channel_ipv6: Option<Arc<StdUdpSocket>>,
         main_tcp_channel: Option<std::sync::mpsc::SyncSender<Vec<u8>>>,
         current_device: Arc<AtomicCell<CurrentDeviceInfo>>,
         _channel_num: usize,
@@ -52,7 +50,6 @@ impl Context {
         let (status_sender, status_receiver) = channel(Status::Cone);
         let inner = Arc::new(ContextInner {
             main_channel,
-            main_channel_ipv6,
             main_tcp_channel,
             route_table: RwLock::new(HashMap::with_capacity(16)),
             status_receiver,
@@ -75,18 +72,12 @@ impl Context {
     }
     pub fn close(&self) -> io::Result<()> {
         let _ = self.inner.status_sender.send(Status::Close);
-        if let Ok(port) = self.main_local_ipv4_port() {
+        if let Ok(port) = self.main_local_udp_port() {
             let _ = StdUdpSocket::bind("127.0.0.1:0")?.send_to(
                 b"stop",
                 SocketAddr::V4(std::net::SocketAddrV4::new(Ipv4Addr::LOCALHOST, port)),
             );
         }
-        if let Ok(port) = self.main_local_ipv6_port() {
-            let _ = StdUdpSocket::bind("[::]:0")?.send_to(
-                b"stop",
-                SocketAddr::V6(std::net::SocketAddrV6::new(Ipv6Addr::LOCALHOST, port, 0, 0)),
-            );
-        }
         if let Some(tcp) = &self.inner.main_tcp_channel {
             let _ = tcp.send(vec![]);
         }
@@ -111,33 +102,27 @@ impl Context {
     pub fn switch_to_symmetric(&self) {
         let _ = self.inner.status_sender.send(Status::Symmetric);
     }
-    pub fn main_local_ipv4_port(&self) -> io::Result<u16> {
+    pub fn main_local_udp_port(&self) -> io::Result<u16> {
         self.inner.main_channel.local_addr().map(|k| k.port())
     }
-    pub fn main_local_ipv6_port(&self) -> io::Result<u16> {
-        if let Some(ipv6) = &self.inner.main_channel_ipv6 {
-            ipv6.local_addr().map(|k| k.port())
-        } else {
-            Err(io::Error::new(io::ErrorKind::Other, "not ipv6"))
-        }
-    }
     fn insert_udp(&self, id: usize, udp: Arc<UdpSocket>) {
         self.inner.udp_map.write().insert(id, udp);
     }
     fn remove_udp(&self, id: usize) {
         self.inner.udp_map.write().remove(&id);
     }
-    pub fn send_main_udp(&self, buf: &[u8], addr: SocketAddr) -> io::Result<usize> {
+    #[inline]
-        if addr.is_ipv6() {
+    pub fn send_main_udp(&self, buf: &[u8], mut addr: SocketAddr) -> io::Result<usize> {
-            if let Some(udp_ipv6) = &self.inner.main_channel_ipv6 {
+        if let SocketAddr::V4(ipv4) = addr {
-                udp_ipv6.send_to(buf, addr)
+            addr = SocketAddr::V6(SocketAddrV6::new(
-            } else {
+                ipv4.ip().to_ipv6_mapped(),
-                Err(io::Error::new(io::ErrorKind::Other, "not ipv6"))
+                ipv4.port(),
+                0,
+                0,
+            ));
         }
-        } else {
         self.inner.main_channel.send_to(buf, addr)
     }
-    }
 
     pub fn send_main(&self, buf: &[u8], addr: SocketAddr) -> io::Result<usize> {
         if let Some(sender) = &self.inner.main_tcp_channel {
@@ -208,14 +193,7 @@ impl Context {
                     Err(io::Error::new(io::ErrorKind::Other, "send_by_key err"))
                 }
             }
-            UDP_ID => self.inner.main_channel.send_to(buf, route_key.addr),
+            UDP_ID => self.send_main_udp(buf, route_key.addr),
-            UDP_V6_ID => {
-                if let Some(udp_ipv6) = &self.inner.main_channel_ipv6 {
-                    udp_ipv6.send_to(buf, route_key.addr)
-                } else {
-                    Err(io::Error::new(io::ErrorKind::Other, "not ipv6 udp"))
-                }
-            }
             _ => {
                 if let Some(udp) = self.get_udp_by_route(route_key) {
                     return udp.send_to(buf, route_key.addr).await;
@@ -237,14 +215,7 @@ impl Context {
                     Err(io::Error::new(io::ErrorKind::Other, "send_by_key err"))
                 }
             }
-            UDP_ID => self.inner.main_channel.send_to(buf, route_key.addr),
+            UDP_ID => self.send_main_udp(buf, route_key.addr),
-            UDP_V6_ID => {
-                if let Some(udp_ipv6) = &self.inner.main_channel_ipv6 {
-                    udp_ipv6.send_to(buf, route_key.addr)
-                } else {
-                    Err(io::Error::new(io::ErrorKind::Other, "not ipv6 udp"))
-                }
-            }
             _ => {
                 if let Some(udp) = self.get_udp_by_route(route_key) {
                     return udp.try_send_to(buf, route_key.addr);
@@ -584,28 +555,6 @@ impl Channel {
                 })
                 .unwrap();
         }
-        if let Some(main_channel_ipv6) = &context.inner.main_channel_ipv6 {
-            let worker = worker.worker("main_channel_ipv6");
-            let context = context.clone();
-            let main_channel_ipv6 = main_channel_ipv6.clone();
-            let handler = handler.clone();
-            let buf_sender = buf_sender.clone();
-            thread::Builder::new()
-                .name("ipv6-recv".into())
-                .spawn(move || {
-                    log::info!("启动udp v6");
-                    Self::main_start_(
-                        worker,
-                        context,
-                        UDP_V6_ID,
-                        main_channel_ipv6,
-                        handler,
-                        buf_sender,
-                        head_reserve,
-                    )
-                })
-                .unwrap();
-        }
         {
             let worker = worker.worker("main_channel_1");
             let context = context.clone();

vnt/src/channel/mod.rs

@@ -7,7 +7,6 @@ pub mod sender;
 
 const TCP_ID: usize = 0;
 const UDP_ID: usize = 1;
-const UDP_V6_ID: usize = 2;
 
 #[derive(Copy, Clone, Eq, PartialEq)]
 pub enum Status {

vnt/src/core/mod.rs

@@ -57,7 +57,6 @@ pub struct Vnt {
 pub struct VntUtil {
     config: Config,
     main_channel: UdpSocket,
-    main_channel_ipv6: Option<UdpSocket>,
     main_tcp_channel: Option<TcpStream>,
     response: Option<RegResponse>,
     iface: Option<(DeviceWriter, DeviceReader)>,
@@ -67,24 +66,14 @@ pub struct VntUtil {
 
 impl VntUtil {
     pub fn new(config: Config) -> io::Result<VntUtil> {
+        let address: SocketAddr = format!("[::]:{}", config.port).parse().unwrap();
         //单个udp用同步的性能更好，但是代理和多端口监听用异步更方便，这里将两者结合起来
-        let main_channel = UdpSocket::bind(format!("0.0.0.0:{}", config.port))?;
+        let socket = socket2::Socket::new(socket2::Domain::IPV6, socket2::Type::DGRAM, None)?;
+        socket.set_only_v6(false)?;
+        socket.bind(&address.into())?;
+        let main_channel: UdpSocket = socket.into();
         main_channel.set_write_timeout(Some(Duration::from_secs(5)))?;
         main_channel.set_read_timeout(Some(Duration::from_secs(2)))?;
-        let main_channel_ipv6 = if config.punch_model != PunchModel::IPv4 {
-            match UdpSocket::bind(format!("[::]:{}", config.port)) {
-                Ok(main_channel_ipv6) => {
-                    main_channel_ipv6.set_write_timeout(Some(Duration::from_secs(5)))?;
-                    Some(main_channel_ipv6)
-                }
-                Err(e) => {
-                    log::warn!("绑定ipv6地址失败:{}", e);
-                    None
-                }
-            }
-        } else {
-            None
-        };
         let server_cipher = if config.server_encrypt {
             let mut key = [0u8; 32];
             rand::thread_rng().fill(&mut key);
@@ -95,7 +84,6 @@ impl VntUtil {
         Ok(VntUtil {
             config,
             main_channel,
-            main_channel_ipv6,
             main_tcp_channel: None,
             response: None,
             iface: None,
@@ -256,7 +244,6 @@ impl VntUtil {
         };
         let context = Context::new(
             Arc::new(self.main_channel),
-            self.main_channel_ipv6.map(|v| Arc::new(v)),
             tcp_sender,
             current_device.clone(),
             1,
@@ -282,11 +269,10 @@ impl VntUtil {
         let connect_status = Arc::new(AtomicCell::new(ConnectStatus::Connected));
         let public_ip = response.public_ip;
         let public_port = response.public_port;
-        let local_port = context.main_local_ipv4_port().unwrap_or(0);
+        let local_port = context.main_local_udp_port().unwrap_or(0);
 
         let local_ipv4_addr = crate::nat::local_ipv4_addr(local_port);
-        let ipv6_port = context.main_local_ipv6_port().unwrap_or(0);
+        let ipv6_addr = crate::nat::local_ipv6_addr(local_port);
-        let ipv6_addr = crate::nat::local_ipv6_addr(ipv6_port);
         // NAT检测
         let nat_test = NatTest::new(
             config.stun_server.clone(),

vnt/src/handle/handshake_handler.rs

@@ -1,4 +1,4 @@
-use std::net::SocketAddr;
+use std::net::{SocketAddr, SocketAddrV6};
 
 use crate::channel::channel::Context;
 use crate::channel::RouteKey;
@@ -168,16 +168,25 @@ fn send_recv(
         }
         Ok(len)
     } else {
+        let server_address = if let SocketAddr::V4(ipv4) = server_address {
+            SocketAddr::V6(SocketAddrV6::new(
+                ipv4.ip().to_ipv6_mapped(),
+                ipv4.port(),
+                0,
+                0,
+            ))
+        } else {
+            server_address
+        };
         if let Err(e) = main_channel.send_to(send_buf, server_address) {
             return Err(HandshakeEnum::Other(format!("send error:{}", e)));
         }
         match main_channel.recv_from(recv_buf) {
             Ok((len, addr)) => {
                 if server_address != addr {
-                    Err(HandshakeEnum::Other(format!("invalid data,from {}", addr)))
+                    log::warn!("请求{:?}和响应{:?}地址不一致", server_address, addr);
-                } else {
-                    Ok(len)
                 }
+                Ok(len)
             }
             Err(e) => Err(HandshakeEnum::Other(format!("receiver error:{}", e))),
         }

vnt/src/handle/heartbeat_handler.rs

@@ -3,15 +3,15 @@ use std::net::{Ipv4Addr, ToSocketAddrs};
 use std::sync::Arc;
 use std::time::Duration;
 
+use crossbeam_utils::atomic::AtomicCell;
+use parking_lot::Mutex;
+use rand::prelude::SliceRandom;
+
 use crate::channel::idle::Idle;
 use crate::channel::sender::ChannelSender;
 use crate::channel::Route;
 use crate::cipher::Cipher;
 use crate::core::status::VntWorker;
-use crossbeam_utils::atomic::AtomicCell;
-use parking_lot::Mutex;
-use rand::prelude::SliceRandom;
-
 use crate::handle::{CurrentDeviceInfo, PeerDeviceInfo};
 use crate::protocol::body::ENCRYPTION_RESERVED;
 use crate::protocol::control_packet::PingPacket;
@@ -64,6 +64,7 @@ pub fn start_heartbeat(
         worker.stop_all();
     });
 }
+
 pub fn start_heartbeat_main(
     mut worker: VntWorker,
     sender: ChannelSender,

vnt/src/handle/recv_handler.rs

@@ -592,9 +592,8 @@ impl ChannelDataHandler {
                             .build()
                             .unwrap()
                             .block_on(async move {
-                                let local_port = context.main_local_ipv4_port().unwrap_or(0);
+                                let local_port = context.main_local_udp_port().unwrap_or(0);
                                 let local_ipv4_addr = nat::local_ipv4_addr(local_port);
-                                let local_port = context.main_local_ipv6_port().unwrap_or(0);
                                 let ipv6_addr = nat::local_ipv6_addr(local_port);
                                 let nat_info = nat_test
                                     .re_test(

vnt/src/handle/registration_handler.rs

@@ -1,6 +1,6 @@
 use crossbeam_utils::atomic::AtomicCell;
 use std::io::{Read, Write};
-use std::net::{Ipv4Addr, SocketAddr};
+use std::net::{Ipv4Addr, SocketAddr, SocketAddrV6};
 use std::time::{Duration, Instant};
 
 use crate::channel::sender::ChannelSender;
@@ -82,13 +82,22 @@ pub fn registration(
         }
         &mut recv_buf[4..len]
     } else {
+        let server_address = match server_address {
+            SocketAddr::V4(ipv4) => SocketAddr::V6(SocketAddrV6::new(
+                ipv4.ip().to_ipv6_mapped(),
+                ipv4.port(),
+                0,
+                0,
+            )),
+            SocketAddr::V6(_) => server_address,
+        };
         if let Err(e) = main_channel.send_to(buf, server_address) {
             return Err(ReqEnum::Other(format!("send error:{}", e)));
         }
         match main_channel.recv_from(&mut recv_buf) {
             Ok((len, addr)) => {
                 if server_address != addr {
-                    return Err(ReqEnum::Other(format!("invalid data,from {}", addr)));
+                    log::warn!("请求{:?}和响应{:?}地址不一致", server_address, addr);
                 }
                 &mut recv_buf[..len]
             }

vnt/src/lib.rs

@@ -1,5 +1,5 @@
 use crate::error::Error;
-pub const VNT_VERSION: &'static str = "1.2.7";
+pub const VNT_VERSION: &'static str = "1.2.8";
 pub type Result<T> = std::result::Result<T, Error>;
 
 pub mod channel;