Use OwnedFd/OwnedSocket in Socket

Instead of the workaround where we use std::net::TcpStream.

Author: Thomasdezeeuw

src/socket.rs

@@ -73,12 +73,9 @@ use crate::{MaybeUninitSlice, MsgHdr, RecvFlags};
 /// # Ok(()) }
 /// ```
 pub struct Socket {
-    inner: Inner,
+    inner: sys::Socket,
 }
 
-/// Store a `TcpStream` internally to take advantage of its niche optimizations on Unix platforms.
-pub(crate) type Inner = std::net::TcpStream;
-
 impl Socket {
     /// # Safety
     ///
@@ -88,24 +85,11 @@ impl Socket {
     /// inconvenient to mark it as `unsafe`.
     pub(crate) fn from_raw(raw: sys::RawSocket) -> Socket {
         Socket {
-            inner: unsafe {
-                // SAFETY: the caller must ensure that `raw` is a valid file
-                // descriptor, but when it isn't it could return I/O errors, or
-                // potentially close a fd it doesn't own. All of that isn't
-                // memory unsafe, so it's not desired but never memory unsafe or
-                // causes UB.
-                //
-                // However there is one exception. We use `TcpStream` to
-                // represent the `Socket` internally (see `Inner` type),
-                // `TcpStream` has a layout optimisation that doesn't allow for
-                // negative file descriptors (as those are always invalid).
-                // Violating this assumption (fd never negative) causes UB,
-                // something we don't want. So check for that we have this
-                // `assert!`.
-                #[cfg(unix)]
-                assert!(raw >= 0, "tried to create a `Socket` with an invalid fd");
-                sys::socket_from_raw(raw)
-            },
+            // SAFETY: the caller must ensure that `raw` is a valid file
+            // descriptor, but when it isn't it could return I/O errors, or
+            // potentially close a fd it doesn't own. All of that isn't memory
+            // unsafe, so it's not desired but never memory unsafe or causes UB.
+            inner: unsafe { sys::socket_from_raw(raw) },
         }
     }
 

src/sys/unix.rs

@@ -859,17 +859,18 @@ impl SockAddr {
     }
 }
 
+pub(crate) type Socket = std::os::fd::OwnedFd;
 pub(crate) type RawSocket = c_int;
 
-pub(crate) unsafe fn socket_from_raw(socket: RawSocket) -> crate::socket::Inner {
-    crate::socket::Inner::from_raw_fd(socket)
+pub(crate) unsafe fn socket_from_raw(socket: RawSocket) -> Socket {
+    Socket::from_raw_fd(socket)
 }
 
-pub(crate) fn socket_as_raw(socket: &crate::socket::Inner) -> RawSocket {
+pub(crate) fn socket_as_raw(socket: &Socket) -> RawSocket {
     socket.as_raw_fd()
 }
 
-pub(crate) fn socket_into_raw(socket: crate::socket::Inner) -> RawSocket {
+pub(crate) fn socket_into_raw(socket: Socket) -> RawSocket {
     socket.into_raw_fd()
 }
 

src/sys/windows.rs

@@ -235,17 +235,18 @@ fn init() {
     });
 }
 
+pub(crate) type Socket = std::os::windows::io::OwnedSocket;
 pub(crate) type RawSocket = windows_sys::Win32::Networking::WinSock::SOCKET;
 
-pub(crate) unsafe fn socket_from_raw(socket: RawSocket) -> crate::socket::Inner {
-    crate::socket::Inner::from_raw_socket(socket as StdRawSocket)
+pub(crate) unsafe fn socket_from_raw(socket: RawSocket) -> Socket {
+    Socket::from_raw_socket(socket as StdRawSocket)
 }
 
-pub(crate) fn socket_as_raw(socket: &crate::socket::Inner) -> RawSocket {
+pub(crate) fn socket_as_raw(socket: &Socket) -> RawSocket {
     socket.as_raw_socket() as RawSocket
 }
 
-pub(crate) fn socket_into_raw(socket: crate::socket::Inner) -> RawSocket {
+pub(crate) fn socket_into_raw(socket: Socket) -> RawSocket {
     socket.into_raw_socket() as RawSocket
 }
 

tests/socket.rs

@@ -140,7 +140,7 @@ fn protocol_fmt_debug() {
 }
 
 #[test]
-#[should_panic = "tried to create a `Socket` with an invalid fd"]
+#[should_panic = "fd != -1"]
 #[cfg(unix)]
 fn from_invalid_raw_fd_should_panic() {
     use std::os::unix::io::FromRawFd;