Prove out that ORIGINAL_DST only works on listening sockets

Signed-off-by: keithmattix <[email protected]>

Author: keithmattix

src/sys/windows.rs

@@ -21,12 +21,12 @@ use std::{process, ptr, slice};
 
 use windows_sys::Win32::Foundation::{SetHandleInformation, HANDLE, HANDLE_FLAG_INHERIT};
 #[cfg(feature = "all")]
-use windows_sys::Win32::Networking::WinSock::SO_PROTOCOL_INFOW;
+use windows_sys::Win32::Networking::WinSock::{SO_PROTOCOL_INFOW, SO_ORIGINAL_DST, IP6T_SO_ORIGINAL_DST, SOL_IP};
 use windows_sys::Win32::Networking::WinSock::{
     self, tcp_keepalive, FIONBIO, IN6_ADDR, IN6_ADDR_0, INVALID_SOCKET, IN_ADDR, IN_ADDR_0,
     POLLERR, POLLHUP, POLLRDNORM, POLLWRNORM, SD_BOTH, SD_RECEIVE, SD_SEND, SIO_KEEPALIVE_VALS,
     SOCKET_ERROR, WSABUF, WSAEMSGSIZE, WSAESHUTDOWN, WSAPOLLFD, WSAPROTOCOL_INFOW,
-    WSA_FLAG_NO_HANDLE_INHERIT, WSA_FLAG_OVERLAPPED,
+    WSA_FLAG_NO_HANDLE_INHERIT, WSA_FLAG_OVERLAPPED
 };
 use windows_sys::Win32::System::Threading::INFINITE;
 
@@ -77,7 +77,7 @@ pub(crate) use windows_sys::Win32::Networking::WinSock::{
     IP_MREQ_SOURCE as IpMreqSource, IP_MULTICAST_IF, IP_MULTICAST_LOOP, IP_MULTICAST_TTL,
     IP_RECVTOS, IP_TOS, IP_TTL, LINGER as linger, MSG_OOB, MSG_PEEK, SO_BROADCAST, SO_ERROR,
     SO_KEEPALIVE, SO_LINGER, SO_OOBINLINE, SO_RCVBUF, SO_RCVTIMEO, SO_REUSEADDR, SO_SNDBUF,
-    SO_SNDTIMEO, SO_TYPE, TCP_NODELAY, SO_ORIGINAL_DST, IP6T_SO_ORIGINAL_DST, SOL_IP
+    SO_SNDTIMEO, SO_TYPE, TCP_NODELAY
 };
 pub(crate) const IPPROTO_IP: c_int = windows_sys::Win32::Networking::WinSock::IPPROTO_IP as c_int;
 pub(crate) const SOL_SOCKET: c_int = windows_sys::Win32::Networking::WinSock::SOL_SOCKET as c_int;
@@ -929,11 +929,22 @@ impl crate::Socket {
 
     /// Get the value for the `SO_ORIGINAL_DST` option on this socket.
     ///
+    #[cfg(feature = "all")]
+    #[cfg_attr(docsrs, doc(cfg(all(windows, feature = "all"))))]
     pub fn original_dst(&self) -> io::Result<SockAddr> {
-        // Safety: `getsockopt` initialises the `SockAddr` for us.
         unsafe {
             SockAddr::try_init(|storage, len| {
-                getsockopt::<>(self.as_raw(), SOL_IP, SO_ORIGINAL_DST)
+                syscall!(
+                    getsockopt(
+                        self.as_raw(),
+                        SOL_IP as i32,
+                        SO_ORIGINAL_DST as i32,
+                        storage.cast(),
+                        len,
+                ),
+                PartialEq::eq,
+                SOCKET_ERROR
+            )
             })
         }
         .map(|(_, addr)| addr)
@@ -944,19 +955,11 @@ impl crate::Socket {
     #[cfg(feature = "all")]
     #[cfg_attr(docsrs, doc(cfg(all(windows, feature = "all"))))]
     pub fn original_dst_ipv6(&self) -> io::Result<SockAddr> {
-        // Safety: `getsockopt` initialises the `SockAddr` for us.
+        use windows_sys::Win32::Networking::WinSock::SOL_IPV6;
+
         unsafe {
-            SockAddr::try_init(|storage, len| {
-                syscall!(getsockopt(
-                    self.as_raw(),
-                    libc::SOL_IPV6,
-                    IP6T_SO_ORIGINAL_DST,
-                    storage.cast(),
-                    len
-                ))
-            })
+            getsockopt::<SockAddr>(self.as_raw(), SOL_IPV6 as i32, IP6T_SO_ORIGINAL_DST as i32)
         }
-        .map(|(_, addr)| addr)
     }
 
     /// Returns the [`Protocol`] of this socket by checking the `SO_PROTOCOL_INFOW`

tests/socket.rs

@@ -1606,6 +1606,46 @@ fn original_dst() {
     }
 }
 
+#[test]
+#[cfg(all(
+    feature = "all",
+    target_os = "windows"
+))]
+fn original_dst() {
+    use windows_sys::Win32::Networking::WinSock::SOMAXCONN;
+
+
+    let socket = Socket::new(Domain::IPV4, Type::STREAM, Some(Protocol::TCP)).unwrap();
+    let addr = SocketAddr::from(([127, 0, 0, 1], 8000));
+    match socket.bind(&SockAddr::from(addr)) {
+        Ok(_) => {}
+        Err(err) => panic!("failed to bind socket: {}", err),
+    };
+    match socket.listen(SOMAXCONN as i32) {
+        Ok(_) => {}
+        Err(err) => panic!("failed to listen on socket: {}", err),
+    };
+    // Socket must be in an accepting state for SOL_IP and SO_ORIGINAL_DST
+    match socket.accept() {
+        Ok((socket, _)) => {
+            match socket.original_dst() {
+                Ok(addr) => {
+                    println!("Original destination: {:?}", addr);
+                }
+                Err(err) => panic!("failed to get original destination: {}", err),
+            }
+        }
+        Err(err) => panic!("failed to accept connection: {}", err),
+
+    };
+
+    // let socket = Socket::new(Domain::IPV6, Type::STREAM, None).unwrap();
+    // match socket.original_dst() {
+    //     Ok(_) => panic!("original_dst on non-redirected socket should fail"),
+    //     Err(err) => assert_eq!(err.raw_os_error(), Some(SOCKET_ERROR)),
+    // }
+}
+
 #[test]
 #[cfg(all(feature = "all", any(target_os = "android", target_os = "linux")))]
 fn original_dst_ipv6() {