Fix attach on Windows when runtime is enabled.

Author: Berrysoft

src/driver/iocp/mod.rs

@@ -1,19 +1,24 @@
 use crate::driver::{Entry, Poller};
 use crossbeam_queue::SegQueue;
 use std::{
+    ffi::c_void,
     io,
     os::windows::{
         io::HandleOrNull,
         prelude::{AsRawHandle, OwnedHandle, RawHandle},
     },
-    ptr::null_mut,
+    ptr::{null, null_mut},
     task::Poll,
     time::Duration,
 };
 use windows_sys::Win32::{
-    Foundation::{GetLastError, ERROR_HANDLE_EOF, INVALID_HANDLE_VALUE, WAIT_TIMEOUT},
+    Foundation::{
+        GetLastError, RtlNtStatusToDosError, ERROR_HANDLE_EOF, INVALID_HANDLE_VALUE, NTSTATUS,
+        STATUS_SUCCESS, WAIT_TIMEOUT,
+    },
     System::{
         Threading::INFINITE,
+        WindowsProgramming::{FILE_INFORMATION_CLASS, IO_STATUS_BLOCK},
         IO::{
             CreateIoCompletionPort, GetQueuedCompletionStatus, PostQueuedCompletionStatus,
             OVERLAPPED,
@@ -91,8 +96,54 @@ impl Driver {
     }
 }
 
+fn deattach_iocp(fd: RawFd) -> io::Result<()> {
+    #[link(name = "ntdll")]
+    extern "system" {
+        fn NtSetInformationFile(
+            FileHandle: usize,
+            IoStatusBlock: *mut IO_STATUS_BLOCK,
+            FileInformation: *const c_void,
+            Length: u32,
+            FileInformationClass: FILE_INFORMATION_CLASS,
+        ) -> NTSTATUS;
+    }
+    #[allow(non_upper_case_globals)]
+    const FileReplaceCompletionInformation: FILE_INFORMATION_CLASS = 61;
+    #[repr(C)]
+    #[allow(non_camel_case_types)]
+    #[allow(non_snake_case)]
+    struct FILE_COMPLETION_INFORMATION {
+        Port: usize,
+        Key: *const c_void,
+    }
+
+    let mut block = unsafe { std::mem::zeroed() };
+    let info = FILE_COMPLETION_INFORMATION {
+        Port: 0,
+        Key: null(),
+    };
+    unsafe {
+        NtSetInformationFile(
+            fd as _,
+            &mut block,
+            &info as *const _ as _,
+            std::mem::size_of_val(&info) as _,
+            FileReplaceCompletionInformation,
+        )
+    };
+    let res = unsafe { block.Anonymous.Status };
+    if res != STATUS_SUCCESS {
+        Err(io::Error::from_raw_os_error(unsafe {
+            RtlNtStatusToDosError(res) as _
+        }))
+    } else {
+        Ok(())
+    }
+}
+
 impl Poller for Driver {
     fn attach(&self, fd: RawFd) -> io::Result<()> {
+        deattach_iocp(fd)?;
         let port = unsafe { CreateIoCompletionPort(fd as _, self.port.as_raw_handle() as _, 0, 0) };
         if port == 0 {
             Err(io::Error::last_os_error())

src/driver/mod.rs

@@ -17,6 +17,54 @@ cfg_if::cfg_if! {
 /// It contains some low-level actions of completion-based IO.
 ///
 /// You don't need them unless you are controlling a [`Driver`] yourself.
+///
+/// # Examples
+///
+/// ```
+/// use compio::{
+///     buf::IntoInner,
+///     driver::{AsRawFd, Driver, Poller},
+///     net::UdpSocket,
+///     op,
+/// };
+/// use std::net::SocketAddr;
+///
+/// let first_addr: SocketAddr = "127.0.0.1:0".parse().unwrap();
+/// let second_addr: SocketAddr = "127.0.0.1:0".parse().unwrap();
+///
+/// // bind sockets
+/// let socket = UdpSocket::bind(first_addr).unwrap();
+/// let first_addr = socket.local_addr().unwrap();
+/// let other_socket = UdpSocket::bind(second_addr).unwrap();
+/// let second_addr = other_socket.local_addr().unwrap();
+///
+/// // connect sockets
+/// socket.connect(second_addr).unwrap();
+/// other_socket.connect(first_addr).unwrap();
+///
+/// let driver = Driver::new().unwrap();
+/// driver.attach(socket.as_raw_fd()).unwrap();
+/// driver.attach(other_socket.as_raw_fd()).unwrap();
+///
+/// // write data
+/// let mut op = op::Send::new(socket.as_raw_fd(), "hello world");
+/// unsafe { driver.push(&mut op, 1) }.unwrap();
+/// let entry = driver.poll(None).unwrap();
+/// assert_eq!(entry.user_data(), 1);
+/// entry.into_result().unwrap();
+///
+/// // read data
+/// let buf = Vec::with_capacity(32);
+/// let mut op = op::Recv::new(other_socket.as_raw_fd(), buf);
+/// unsafe { driver.push(&mut op, 2) }.unwrap();
+/// let entry = driver.poll(None).unwrap();
+/// assert_eq!(entry.user_data(), 2);
+/// let n_bytes = entry.into_result().unwrap();
+/// let mut buf = op.into_inner().into_inner();
+/// unsafe { buf.set_len(n_bytes) };
+///
+/// assert_eq!(buf, b"hello world");
+/// ```
 pub trait Poller {
     /// Attach an fd to the driver.
     fn attach(&self, fd: RawFd) -> io::Result<()>;