Cosmo specific support plus I/O safe traits

Cargo.toml

@@ -11,6 +11,5 @@ members = [
   "benches",
   "examples",
   "stress-test",
-  "tests-build",
-  "tests-integration",
+  "tests-build"
 ]

tokio-stream/Cargo.toml

@@ -19,11 +19,9 @@ categories = ["asynchronous"]
 [features]
 default = ["time"]
 time = ["tokio/time"]
-net = ["tokio/net"]
 io-util = ["tokio/io-util"]
 fs = ["tokio/fs"]
 sync = ["tokio/sync", "tokio-util"]
-signal = ["tokio/signal"]
 
 [dependencies]
 futures-core = { version = "0.3.0" }

tokio-util/Cargo.toml

@@ -21,9 +21,8 @@ categories = ["asynchronous"]
 default = []
 
 # Shorthand for enabling everything
-full = ["codec", "compat", "io-util", "time", "net", "rt"]
+full = ["codec", "compat", "io-util", "time", "rt"]
 
-net = ["tokio/net"]
 compat = ["futures-io",]
 codec = ["tracing"]
 time = ["tokio/time","slab"]

tokio/Cargo.toml

@@ -31,12 +31,9 @@ full = [
   "io-util",
   "io-std",
   "macros",
-  "net",
   "parking_lot",
-  "process",
   "rt",
   "rt-multi-thread",
-  "signal",
   "sync",
   "time",
 ]
@@ -46,44 +43,12 @@ io-util = ["memchr", "bytes"]
 # stdin, stdout, stderr
 io-std = []
 macros = ["tokio-macros"]
-net = [
-  "libc",
-  "mio/os-poll",
-  "mio/os-ext",
-  "mio/net",
-  "socket2",
-  "windows-sys/Win32_Foundation",
-  "windows-sys/Win32_Security",
-  "windows-sys/Win32_Storage_FileSystem",
-  "windows-sys/Win32_System_Pipes",
-  "windows-sys/Win32_System_SystemServices",
-]
-process = [
-  "bytes",
-  "libc",
-  "mio/os-poll",
-  "mio/os-ext",
-  "mio/net",
-  "signal-hook-registry",
-  "windows-sys/Win32_Foundation",
-  "windows-sys/Win32_System_Threading",
-  "windows-sys/Win32_System_WindowsProgramming",
-]
 # Includes basic task execution capabilities
 rt = []
 rt-multi-thread = [
   "num_cpus",
   "rt",
 ]
-signal = [
-  "libc",
-  "mio/os-poll",
-  "mio/net",
-  "mio/os-ext",
-  "signal-hook-registry",
-  "windows-sys/Win32_Foundation",
-  "windows-sys/Win32_System_Console",
-]
 sync = []
 test-util = ["rt", "sync", "time"]
 time = []
@@ -117,11 +82,9 @@ socket2 = { version = "0.4.4", optional = true, features = [ "all" ] }
 tracing = { version = "0.1.25", default-features = false, features = ["std"], optional = true } # Not in full
 
 [target.'cfg(unix)'.dependencies]
-libc = { version = "0.2.42", optional = true }
 signal-hook-registry = { version = "1.1.1", optional = true }
 
 [target.'cfg(unix)'.dev-dependencies]
-libc = { version = "0.2.42" }
 nix = { version = "0.26", default-features = false, features = ["fs", "socket"] }
 
 [target.'cfg(windows)'.dependencies.windows-sys]

tokio/build.rs

@@ -43,6 +43,7 @@ fn main() {
     let mut enable_addr_of = false;
     let mut enable_target_has_atomic = false;
     let mut enable_const_mutex_new = false;
+    let mut enable_as_fd = false;
     let mut target_needs_atomic_u64_fallback = false;
 
     match AutoCfg::new() {
@@ -106,6 +107,7 @@ fn main() {
             // The `Mutex::new` method was made const in 1.63.
             if ac.probe_rustc_version(1, 64) {
                 enable_const_mutex_new = true;
+                enable_as_fd = true;
             } else if ac.probe_rustc_version(1, 63) {
                 // This compiler claims to be 1.63, but there are some nightly
                 // compilers that claim to be 1.63 without supporting the
@@ -115,6 +117,7 @@ fn main() {
                 // The oldest nightly that supports the feature is 2022-06-20.
                 if ac.probe_expression(CONST_MUTEX_NEW_PROBE) {
                     enable_const_mutex_new = true;
+                    enable_as_fd = true;
                 }
             }
         }
@@ -162,6 +165,14 @@ fn main() {
         autocfg::emit("tokio_no_const_mutex_new")
     }
 
+    if !enable_as_fd {
+        // To disable this feature on compilers that support it, you can
+        // explicitly pass this flag with the following environment variable:
+        //
+        // RUSTFLAGS="--cfg tokio_no_as_fd"
+        autocfg::emit("tokio_no_as_fd");
+    }
+
     if target_needs_atomic_u64_fallback {
         // To disable this feature on compilers that support it, you can
         // explicitly pass this flag with the following environment variable:

tokio/src/fs/file.rs

@@ -725,6 +725,15 @@ impl std::os::unix::io::AsRawFd for File {
     }
 }
 
+#[cfg(all(unix, not(tokio_no_as_fd)))]
+impl std::os::unix::io::AsFd for File {
+    fn as_fd(&self) -> std::os::unix::io::BorrowedFd<'_> {
+        unsafe {
+            std::os::unix::io::BorrowedFd::borrow_raw(std::os::unix::io::AsRawFd::as_raw_fd(self))
+        }
+    }
+}
+
 #[cfg(unix)]
 impl std::os::unix::io::FromRawFd for File {
     unsafe fn from_raw_fd(fd: std::os::unix::io::RawFd) -> Self {
@@ -739,6 +748,17 @@ impl std::os::windows::io::AsRawHandle for File {
     }
 }
 
+#[cfg(all(windows, not(tokio_no_as_fd)))]
+impl std::os::windows::io::AsHandle for File {
+    fn as_handle(&self) -> std::os::windows::io::BorrowedHandle<'_> {
+        unsafe {
+            std::os::windows::io::BorrowedHandle::borrow_raw(
+                std::os::windows::io::AsRawHandle::as_raw_handle(self),
+            )
+        }
+    }
+}
+
 #[cfg(windows)]
 impl std::os::windows::io::FromRawHandle for File {
     unsafe fn from_raw_handle(handle: std::os::windows::io::RawHandle) -> Self {

tokio/src/fs/open_options.rs

@@ -1,3 +1,4 @@
+extern crate libc;
 use crate::fs::{asyncify, File};
 
 use std::io;

tokio/src/lib.rs

@@ -443,6 +443,8 @@
 //! Because of this, sockets must currently be created via the `FromRawFd`
 //! trait.
 
+#![feature(rustc_private)]
+
 // Test that pointer width is compatible. This asserts that e.g. usize is at
 // least 32 bits, which a lot of components in Tokio currently assumes.
 //

tokio/src/net/tcp/listener.rs

@@ -407,6 +407,13 @@ mod sys {
             self.io.as_raw_fd()
         }
     }
+
+    #[cfg(not(tokio_no_as_fd))]
+    impl AsFd for TcpListener {
+        fn as_fd(&self) -> BorrowedFd<'_> {
+            unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) }
+        }
+    }
 }
 
 cfg_unstable! {
@@ -420,6 +427,13 @@ cfg_unstable! {
                 self.io.as_raw_fd()
             }
         }
+
+        #[cfg(not(tokio_no_as_fd))]
+        impl AsFd for TcpListener {
+            fn as_fd(&self) -> BorrowedFd<'_> {
+                unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) }
+            }
+        }
     }
 }
 
@@ -433,4 +447,11 @@ mod sys {
             self.io.as_raw_socket()
         }
     }
+
+    #[cfg(not(tokio_no_as_fd))]
+    impl AsSocket for TcpListener {
+        fn as_socket(&self) -> BorrowedSocket<'_> {
+            unsafe { BorrowedSocket::borrow_raw(self.as_raw_socket()) }
+        }
+    }
 }

tokio/src/net/tcp/socket.rs

@@ -1,13 +1,18 @@
+extern crate libc;
 use crate::net::{TcpListener, TcpStream};
 
 use std::fmt;
 use std::io;
 use std::net::SocketAddr;
 
+#[cfg(all(unix, not(tokio_no_as_fd)))]
+use std::os::unix::io::{AsFd, BorrowedFd};
 #[cfg(unix)]
 use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
 #[cfg(windows)]
 use std::os::windows::io::{AsRawSocket, FromRawSocket, IntoRawSocket, RawSocket};
+#[cfg(all(windows, not(tokio_no_as_fd)))]
+use std::os::windows::io::{AsSocket, BorrowedSocket};
 use std::time::Duration;
 
 cfg_net! {
@@ -737,6 +742,13 @@ impl AsRawFd for TcpSocket {
     }
 }
 
+#[cfg(all(unix, not(tokio_no_as_fd)))]
+impl AsFd for TcpSocket {
+    fn as_fd(&self) -> BorrowedFd<'_> {
+        unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) }
+    }
+}
+
 #[cfg(unix)]
 impl FromRawFd for TcpSocket {
     /// Converts a `RawFd` to a `TcpSocket`.
@@ -772,6 +784,13 @@ impl AsRawSocket for TcpSocket {
     }
 }
 
+#[cfg(all(windows, not(tokio_no_as_fd)))]
+impl AsSocket for TcpSocket {
+    fn as_socket(&self) -> BorrowedSocket<'_> {
+        unsafe { BorrowedSocket::borrow_raw(self.as_raw_socket()) }
+    }
+}
+
 #[cfg(windows)]
 impl FromRawSocket for TcpSocket {
     /// Converts a `RawSocket` to a `TcpStream`.

tokio/src/net/tcp/stream.rs

@@ -1342,6 +1342,13 @@ mod sys {
             self.io.as_raw_fd()
         }
     }
+
+    #[cfg(not(tokio_no_as_fd))]
+    impl AsFd for TcpStream {
+        fn as_fd(&self) -> BorrowedFd<'_> {
+            unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) }
+        }
+    }
 }
 
 #[cfg(windows)]
@@ -1354,6 +1361,13 @@ mod sys {
             self.io.as_raw_socket()
         }
     }
+
+    #[cfg(not(tokio_no_as_fd))]
+    impl AsSocket for TcpStream {
+        fn as_socket(&self) -> BorrowedSocket<'_> {
+            unsafe { BorrowedSocket::borrow_raw(self.as_raw_socket()) }
+        }
+    }
 }
 
 #[cfg(all(tokio_unstable, tokio_wasi))]
@@ -1366,4 +1380,11 @@ mod sys {
             self.io.as_raw_fd()
         }
     }
+
+    #[cfg(not(tokio_no_as_fd))]
+    impl AsFd for TcpStream {
+        fn as_fd(&self) -> BorrowedFd<'_> {
+            unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) }
+        }
+    }
 }

tokio/src/net/udp.rs

@@ -1691,7 +1691,7 @@ impl fmt::Debug for UdpSocket {
     }
 }
 
-#[cfg(all(unix))]
+#[cfg(unix)]
 mod sys {
     use super::UdpSocket;
     use std::os::unix::prelude::*;
@@ -1701,6 +1701,13 @@ mod sys {
             self.io.as_raw_fd()
         }
     }
+
+    #[cfg(not(tokio_no_as_fd))]
+    impl AsFd for UdpSocket {
+        fn as_fd(&self) -> BorrowedFd<'_> {
+            unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) }
+        }
+    }
 }
 
 #[cfg(windows)]
@@ -1713,4 +1720,11 @@ mod sys {
             self.io.as_raw_socket()
         }
     }
+
+    #[cfg(not(tokio_no_as_fd))]
+    impl AsSocket for UdpSocket {
+        fn as_socket(&self) -> BorrowedSocket<'_> {
+            unsafe { BorrowedSocket::borrow_raw(self.as_raw_socket()) }
+        }
+    }
 }

tokio/src/net/unix/datagram/socket.rs

@@ -5,6 +5,8 @@ use std::convert::TryFrom;
 use std::fmt;
 use std::io;
 use std::net::Shutdown;
+#[cfg(not(tokio_no_as_fd))]
+use std::os::unix::io::{AsFd, BorrowedFd};
 use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
 use std::os::unix::net;
 use std::path::Path;
@@ -1436,3 +1438,10 @@ impl AsRawFd for UnixDatagram {
         self.io.as_raw_fd()
     }
 }
+
+#[cfg(not(tokio_no_as_fd))]
+impl AsFd for UnixDatagram {
+    fn as_fd(&self) -> BorrowedFd<'_> {
+        unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) }
+    }
+}

tokio/src/net/unix/listener.rs

@@ -4,6 +4,8 @@ use crate::net::unix::{SocketAddr, UnixStream};
 use std::convert::TryFrom;
 use std::fmt;
 use std::io;
+#[cfg(not(tokio_no_as_fd))]
+use std::os::unix::io::{AsFd, BorrowedFd};
 use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
 use std::os::unix::net;
 use std::path::Path;
@@ -208,3 +210,10 @@ impl AsRawFd for UnixListener {
         self.io.as_raw_fd()
     }
 }
+
+#[cfg(not(tokio_no_as_fd))]
+impl AsFd for UnixListener {
+    fn as_fd(&self) -> BorrowedFd<'_> {
+        unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) }
+    }
+}