UDP IPv6 outbound socket should disable IPV6_V6ONLY

crates/shadowsocks/src/net/sys/mod.rs

@@ -100,7 +100,7 @@ fn socket_bind_dual_stack_inner(socket: &Socket, addr: &SocketAddr, ipv6_only: b
         socket.bind(&saddr)?;
     } else {
         if let Err(err) = socket.set_only_v6(false) {
-            warn!("failed to set IPV6_V6ONLY: false for listener, error: {}", err);
+            warn!("failed to set IPV6_V6ONLY: false for socket, error: {}", err);
 
             // This is not a fatal error, just warn and skip
         }
@@ -115,7 +115,7 @@ fn socket_bind_dual_stack_inner(socket: &Socket, addr: &SocketAddr, ipv6_only: b
                 );
 
                 if let Err(err) = socket.set_only_v6(true) {
-                    warn!("failed to set IPV6_V6ONLY: true for listener, error: {}", err);
+                    warn!("failed to set IPV6_V6ONLY: true for socket, error: {}", err);
 
                     // This is not a fatal error, just warn and skip
                 }

crates/shadowsocks/src/net/sys/unix/bsd/freebsd.rs

@@ -9,14 +9,15 @@ use std::{
 
 use log::{error, warn};
 use pin_project::pin_project;
+use socket2::{Domain, Protocol, Socket, Type};
 use tokio::{
     io::{AsyncRead, AsyncWrite, ReadBuf},
     net::{TcpSocket, TcpStream as TokioTcpStream, UdpSocket},
 };
 use tokio_tfo::TfoStream;
 
 use crate::net::{
-    sys::{set_common_sockopt_after_connect, set_common_sockopt_for_connect},
+    sys::{set_common_sockopt_after_connect, set_common_sockopt_for_connect, socket_bind_dual_stack},
     AddrFamily,
     ConnectOpts,
 };
@@ -223,7 +224,17 @@ pub async fn create_outbound_udp_socket(af: AddrFamily, config: &ConnectOpts) ->
         (AddrFamily::Ipv6, ..) => SocketAddr::new(Ipv6Addr::UNSPECIFIED.into(), 0),
     };
 
-    let socket = UdpSocket::bind(bind_addr).await?;
+    let socket = if af != AddrFamily::Ipv6 {
+        UdpSocket::bind(bind_addr).await?
+    } else {
+        let socket = Socket::new(Domain::for_address(bind_addr), Type::DGRAM, Some(Protocol::UDP))?;
+        socket_bind_dual_stack(&socket, &bind_addr, false)?;
+
+        // UdpSocket::from_std requires socket to be non-blocked
+        socket.set_nonblocking(true)?;
+        UdpSocket::from_std(socket.into())?
+    };
+
     if let Err(err) = set_disable_ip_fragmentation(af, &socket) {
         warn!("failed to disable IP fragmentation, error: {}", err);
     }

crates/shadowsocks/src/net/sys/unix/bsd/macos.rs

@@ -10,14 +10,15 @@ use std::{
 
 use log::{error, warn};
 use pin_project::pin_project;
+use socket2::{Domain, Protocol, Socket, Type};
 use tokio::{
     io::{AsyncRead, AsyncWrite, ReadBuf},
     net::{TcpSocket, TcpStream as TokioTcpStream, UdpSocket},
 };
 use tokio_tfo::TfoStream;
 
 use crate::net::{
-    sys::{set_common_sockopt_after_connect, set_common_sockopt_for_connect},
+    sys::{set_common_sockopt_after_connect, set_common_sockopt_for_connect, socket_bind_dual_stack},
     AddrFamily,
     ConnectOpts,
 };
@@ -250,7 +251,17 @@ pub async fn create_outbound_udp_socket(af: AddrFamily, config: &ConnectOpts) ->
         (AddrFamily::Ipv6, ..) => SocketAddr::new(Ipv6Addr::UNSPECIFIED.into(), 0),
     };
 
-    let socket = UdpSocket::bind(bind_addr).await?;
+    let socket = if af != AddrFamily::Ipv6 {
+        UdpSocket::bind(bind_addr).await?
+    } else {
+        let socket = Socket::new(Domain::for_address(bind_addr), Type::DGRAM, Some(Protocol::UDP))?;
+        socket_bind_dual_stack(&socket, &bind_addr, false)?;
+
+        // UdpSocket::from_std requires socket to be non-blocked
+        socket.set_nonblocking(true)?;
+        UdpSocket::from_std(socket.into())?
+    };
+
     if let Err(err) = set_disable_ip_fragmentation(af, &socket) {
         warn!("failed to disable IP fragmentation, error: {}", err);
     }

crates/shadowsocks/src/net/sys/unix/linux/mod.rs

@@ -10,14 +10,15 @@ use std::{
 use cfg_if::cfg_if;
 use log::{error, warn};
 use pin_project::pin_project;
+use socket2::{Domain, Protocol, Socket, Type};
 use tokio::{
     io::{AsyncRead, AsyncWrite, ReadBuf},
     net::{TcpSocket, TcpStream as TokioTcpStream, UdpSocket},
 };
 use tokio_tfo::TfoStream;
 
 use crate::net::{
-    sys::{set_common_sockopt_after_connect, set_common_sockopt_for_connect},
+    sys::{set_common_sockopt_after_connect, set_common_sockopt_for_connect, socket_bind_dual_stack},
     AddrFamily,
     ConnectOpts,
 };
@@ -245,7 +246,17 @@ pub async fn create_outbound_udp_socket(af: AddrFamily, config: &ConnectOpts) ->
         (AddrFamily::Ipv6, ..) => SocketAddr::new(Ipv6Addr::UNSPECIFIED.into(), 0),
     };
 
-    let socket = UdpSocket::bind(bind_addr).await?;
+    let socket = if af != AddrFamily::Ipv6 {
+        UdpSocket::bind(bind_addr).await?
+    } else {
+        let socket = Socket::new(Domain::for_address(bind_addr), Type::DGRAM, Some(Protocol::UDP))?;
+        socket_bind_dual_stack(&socket, &bind_addr, false)?;
+
+        // UdpSocket::from_std requires socket to be non-blocked
+        socket.set_nonblocking(true)?;
+        UdpSocket::from_std(socket.into())?
+    };
+
     if let Err(err) = set_disable_ip_fragmentation(af, &socket) {
         warn!("failed to disable IP fragmentation, error: {}", err);
     }

crates/shadowsocks/src/net/sys/windows/mod.rs

@@ -368,7 +368,17 @@ pub async fn create_outbound_udp_socket(af: AddrFamily, opts: &ConnectOpts) -> i
         (AddrFamily::Ipv6, ..) => SocketAddr::new(Ipv6Addr::UNSPECIFIED.into(), 0),
     };
 
-    let socket = UdpSocket::bind(bind_addr).await?;
+    let socket = if af != AddrFamily::Ipv6 {
+        UdpSocket::bind(addr).await?
+    } else {
+        let socket = Socket::new(Domain::for_address(bind_addr), Type::DGRAM, Some(Protocol::UDP))?;
+        socket_bind_dual_stack(&socket, &bind_addr, false)?;
+
+        // UdpSocket::from_std requires socket to be non-blocked
+        socket.set_nonblocking(true)?;
+        UdpSocket::from_std(socket.into())?
+    };
+
     if let Err(err) = set_disable_ip_fragmentation(af, &socket) {
         warn!("failed to disable IP fragmentation, error: {}", err);
     }