From d31e7301c21885ac2dba78bc3b03dd60c3cf70e4 Mon Sep 17 00:00:00 2001
From: Yuyi Wang <Strawberry_Str@hotmail.com>
Date: Sun, 8 Mar 2026 00:00:16 +0800
Subject: [PATCH 1/6] test(driver): rewrite push_and_wait_multi

---
 compio-driver/tests/{file.rs => op.rs} | 88 ++++++++++++++++----------
 1 file changed, 54 insertions(+), 34 deletions(-)
 rename compio-driver/tests/{file.rs => op.rs} (81%)

diff --git a/compio-driver/tests/file.rs b/compio-driver/tests/op.rs
similarity index 81%
rename from compio-driver/tests/file.rs
rename to compio-driver/tests/op.rs
index a9043b341..e6adfd35c 100644
--- a/compio-driver/tests/file.rs
+++ b/compio-driver/tests/op.rs
@@ -1,13 +1,14 @@
+#![feature(gen_blocks)]
+
 use std::{
     io::{self, Write},
     net::{TcpListener, TcpStream},
-    ops::Deref,
     time::Duration,
 };
 
 use compio_buf::BufResult;
 use compio_driver::{
-    AsRawFd, BufferPool, Extra, OpCode, OwnedFd, Proactor, PushEntry, SharedFd, TakeBuffer,
+    AsRawFd, Extra, OpCode, OwnedFd, Proactor, PushEntry, SharedFd, TakeBuffer,
     op::{
         Asyncify, CloseFile, CloseSocket, ReadAt, ReadManagedAt, ReadMultiAt, RecvMulti,
         ResultTakeBuffer,
@@ -104,42 +105,46 @@ fn push_and_wait<O: OpCode + 'static>(driver: &mut Proactor, op: O) -> BufResult
     }
 }
 
-fn push_and_wait_multi<O: OpCode + TakeBuffer<BufferPool = BufferPool> + 'static>(
+fn push_and_wait_multi<O: OpCode + 'static>(
     driver: &mut Proactor,
     op: O,
-    pool: &BufferPool,
-) -> Vec<u8>
-where
-    for<'a> O::Buffer<'a>: Deref<Target = [u8]>,
-{
-    match driver.push(op) {
-        PushEntry::Ready(res) => match (res, driver.default_extra()).take_buffer(pool) {
-            Ok(slice) => slice.to_vec(),
-            Err(_) => vec![],
-        },
-        PushEntry::Pending(mut user_data) => {
-            let mut buffer = vec![];
-            loop {
-                driver.poll(None).unwrap();
-                while let Some(res) = driver.pop_multishot(&user_data) {
-                    match res.take_buffer(pool) {
-                        Ok(slice) => buffer.extend_from_slice(&slice),
-                        Err(_) => break,
-                    }
+) -> impl Iterator<Item = BufResult<usize, Extra>> + '_ {
+    let mut op = Some(op);
+    let mut user_data = None;
+    let mut finished = false;
+
+    std::iter::from_fn(move || {
+        if finished {
+            return None;
+        }
+
+        if user_data.is_none() {
+            match driver.push(op.take().expect("operation should be pushed once")) {
+                PushEntry::Ready(BufResult(res, _)) => {
+                    finished = true;
+                    return Some(BufResult(res, driver.default_extra()));
                 }
-                match driver.pop_with_extra(user_data) {
-                    PushEntry::Pending(k) => user_data = k,
-                    PushEntry::Ready(res) => {
-                        if let Ok(slice) = res.take_buffer(pool) {
-                            buffer.extend_from_slice(&slice)
-                        }
-                        break;
-                    }
+                PushEntry::Pending(k) => user_data = Some(k),
+            }
+        }
+
+        loop {
+            if let Some(res) = user_data.as_ref().and_then(|key| driver.pop_multishot(key)) {
+                return Some(res);
+            }
+
+            let key = user_data.take().expect("pending key should exist");
+            match driver.pop_with_extra(key) {
+                PushEntry::Pending(k) => user_data = Some(k),
+                PushEntry::Ready((BufResult(res, _), extra)) => {
+                    finished = true;
+                    return Some(BufResult(res, extra));
                 }
             }
-            buffer
+
+            driver.poll(None).unwrap();
         }
-    }
+    })
 }
 
 #[test]
@@ -275,7 +280,13 @@ fn read_multi() {
     let pool = driver.create_buffer_pool(4, 1024).unwrap();
 
     let op = ReadMultiAt::new(fd.clone(), 0, &pool, 1024).unwrap();
-    let buffer = push_and_wait_multi(&mut driver, op, &pool);
+    let buffer = push_and_wait_multi(&mut driver, op)
+        .map(|res| res.take_buffer(&pool).map(|buf| buf.to_vec()))
+        .collect::<io::Result<Vec<_>>>()
+        .unwrap()
+        .into_iter()
+        .flatten()
+        .collect::<Vec<_>>();
 
     println!("{}", std::str::from_utf8(&buffer).unwrap());
 
@@ -310,7 +321,16 @@ fn recv_multi() {
     let mut buffer = vec![];
     loop {
         let op = RecvMulti::new(stream.clone(), &pool, 0, 0).unwrap();
-        let slice = push_and_wait_multi(&mut driver, op, &pool);
+        let slice = push_and_wait_multi(&mut driver, op)
+            .map(|res| {
+                res.take_buffer(&pool)
+                    .map(|buf| buf.to_vec())
+                    .unwrap_or_default()
+            })
+            .collect::<Vec<_>>()
+            .into_iter()
+            .flatten()
+            .collect::<Vec<_>>();
         if slice.is_empty() {
             break;
         }

From 2431cbc6618852c03d7e2ffeae1557b5ff83aac8 Mon Sep 17 00:00:00 2001
From: Yuyi Wang <Strawberry_Str@hotmail.com>
Date: Sun, 8 Mar 2026 02:16:13 +0800
Subject: [PATCH 2/6] feat(driver): accept multi

---
 compio-driver/src/op.rs            | 12 +++--
 compio-driver/src/sys/fusion/op.rs |  1 +
 compio-driver/src/sys/iour/op.rs   | 79 +++++++++++++++++++++++++++++-
 compio-driver/src/sys/poll/op.rs   | 38 ++++++++++++++
 compio-driver/src/sys/stub/op.rs   |  2 +
 compio-driver/src/sys/unix_op.rs   |  7 ++-
 compio-driver/tests/op.rs          | 54 +++++++++++++++++++-
 compio-net/src/socket.rs           |  2 +-
 8 files changed, 184 insertions(+), 11 deletions(-)

diff --git a/compio-driver/src/op.rs b/compio-driver/src/op.rs
index 7fc282b92..46aada4da 100644
--- a/compio-driver/src/op.rs
+++ b/compio-driver/src/op.rs
@@ -16,14 +16,14 @@ pub use crate::sys::op::{
     Accept, Recv, RecvFrom, RecvFromVectored, RecvMsg, RecvVectored, Send, SendMsg, SendTo,
     SendToVectored, SendVectored,
 };
-#[cfg(windows)]
-pub use crate::sys::op::{ConnectNamedPipe, DeviceIoControl};
 #[cfg(unix)]
 pub use crate::sys::op::{
-    CreateDir, CreateSocket, CurrentDir, FileStat, HardLink, Interest, OpenFile, PathStat,
-    PollOnce, ReadVectored, ReadVectoredAt, Rename, Stat, Symlink, TruncateFile, Unlink,
+    AcceptMulti, CreateDir, CreateSocket, CurrentDir, FileStat, HardLink, Interest, OpenFile,
+    PathStat, PollOnce, ReadVectored, ReadVectoredAt, Rename, Stat, Symlink, TruncateFile, Unlink,
     WriteVectored, WriteVectoredAt,
 };
+#[cfg(windows)]
+pub use crate::sys::op::{ConnectNamedPipe, DeviceIoControl};
 #[cfg(io_uring)]
 pub use crate::sys::op::{
     ReadManaged, ReadManagedAt, ReadMulti, ReadMultiAt, RecvFromManaged, RecvManaged, RecvMulti,
@@ -665,7 +665,9 @@ pub(crate) mod managed {
 }
 
 #[cfg(not(io_uring))]
-pub use managed::*;
+pub use managed::{
+    ReadManaged, ReadManagedAt, ReadMulti, ReadMultiAt, RecvFromManaged, RecvManaged, RecvMulti,
+};
 
 bitflags::bitflags! {
     /// Flags for operations.
diff --git a/compio-driver/src/sys/fusion/op.rs b/compio-driver/src/sys/fusion/op.rs
index 15c3f6b59..b8800e694 100644
--- a/compio-driver/src/sys/fusion/op.rs
+++ b/compio-driver/src/sys/fusion/op.rs
@@ -126,6 +126,7 @@ mod iour { pub use crate::sys::iour::{op::*, OpCode}; }
 #[rustfmt::skip]
 mod poll { pub use crate::sys::poll::{op::*, OpCode}; }
 
+op!(<S: AsFd> AcceptMulti(fd: S));
 op!(<T: IoBufMut, S: AsFd> RecvFrom(fd: S, buffer: T, flags: i32));
 op!(<T: IoBuf, S: AsFd> SendTo(fd: S, buffer: T, addr: SockAddr, flags: i32));
 op!(<T: IoVectoredBufMut, S: AsFd> RecvFromVectored(fd: S, buffer: T, flags: i32));
diff --git a/compio-driver/src/sys/iour/op.rs b/compio-driver/src/sys/iour/op.rs
index 3470a3aa0..8f6ef8d1e 100644
--- a/compio-driver/src/sys/iour/op.rs
+++ b/compio-driver/src/sys/iour/op.rs
@@ -1,8 +1,9 @@
 use std::{
+    collections::VecDeque,
     ffi::CString,
     io,
     marker::PhantomPinned,
-    os::fd::{AsFd, AsRawFd, FromRawFd, OwnedFd},
+    os::fd::{AsFd, AsRawFd, FromRawFd, IntoRawFd, OwnedFd},
     pin::Pin,
 };
 
@@ -557,6 +558,82 @@ unsafe impl<S: AsFd> OpCode for Accept<S> {
     }
 }
 
+struct AcceptMultishotResult {
+    res: io::Result<Socket2>,
+    extra: crate::Extra,
+}
+
+impl AcceptMultishotResult {
+    pub unsafe fn new(res: io::Result<usize>, extra: crate::Extra) -> Self {
+        Self {
+            res: res.map(|fd| unsafe { Socket2::from_raw_fd(fd as _) }),
+            extra,
+        }
+    }
+
+    pub fn into_result(self) -> BufResult<usize, crate::Extra> {
+        BufResult(self.res.map(|fd| fd.into_raw_fd() as _), self.extra)
+    }
+}
+
+pin_project! {
+    /// Accept multiple connections.
+    pub struct AcceptMulti<S> {
+        #[pin]
+        pub(crate) op: Accept<S>,
+        multishots: VecDeque<AcceptMultishotResult>
+    }
+}
+
+impl<S> AcceptMulti<S> {
+    /// Create [`AcceptMulti`].
+    pub fn new(fd: S) -> Self {
+        Self {
+            op: Accept::new(fd),
+            multishots: VecDeque::new(),
+        }
+    }
+}
+
+unsafe impl<S: AsFd> OpCode for AcceptMulti<S> {
+    fn create_entry(self: Pin<&mut Self>) -> OpEntry {
+        let this = self.project();
+        opcode::AcceptMulti::new(Fd(this.op.fd.as_fd().as_raw_fd()))
+            .flags(libc::SOCK_CLOEXEC)
+            .build()
+            .into()
+    }
+
+    fn create_entry_fallback(self: Pin<&mut Self>) -> OpEntry {
+        self.project().op.create_entry()
+    }
+
+    unsafe fn set_result(self: Pin<&mut Self>, res: &io::Result<usize>, extra: &crate::Extra) {
+        unsafe { self.project().op.set_result(res, extra) }
+    }
+
+    unsafe fn push_multishot(self: Pin<&mut Self>, res: io::Result<usize>, extra: crate::Extra) {
+        self.project()
+            .multishots
+            .push_back(unsafe { AcceptMultishotResult::new(res, extra) });
+    }
+
+    fn pop_multishot(self: Pin<&mut Self>) -> Option<BufResult<usize, crate::sys::Extra>> {
+        self.project()
+            .multishots
+            .pop_front()
+            .map(|res| res.into_result())
+    }
+}
+
+impl<S> IntoInner for AcceptMulti<S> {
+    type Inner = (Socket2, SockAddr);
+
+    fn into_inner(self) -> Self::Inner {
+        self.op.into_inner()
+    }
+}
+
 unsafe impl<S: AsFd> OpCode for Connect<S> {
     fn create_entry(self: Pin<&mut Self>) -> OpEntry {
         opcode::Connect::new(
diff --git a/compio-driver/src/sys/poll/op.rs b/compio-driver/src/sys/poll/op.rs
index be99dc513..c8dd8414e 100644
--- a/compio-driver/src/sys/poll/op.rs
+++ b/compio-driver/src/sys/poll/op.rs
@@ -768,6 +768,44 @@ unsafe impl<S: AsFd> OpCode for Accept<S> {
     }
 }
 
+pin_project! {
+    /// Accept multiple connections.
+    pub struct AcceptMulti<S> {
+        #[pin]
+        pub(crate) op: Accept<S>,
+    }
+}
+
+impl<S> AcceptMulti<S> {
+    /// Create [`AcceptMulti`].
+    pub fn new(fd: S) -> Self {
+        Self {
+            op: Accept::new(fd),
+        }
+    }
+}
+
+unsafe impl<S: AsFd> OpCode for AcceptMulti<S> {
+    fn pre_submit(self: Pin<&mut Self>) -> io::Result<Decision> {
+        self.project().op.pre_submit()
+    }
+
+    fn op_type(self: Pin<&mut Self>) -> Option<OpType> {
+        self.project().op.op_type()
+    }
+
+    fn operate(self: Pin<&mut Self>) -> Poll<io::Result<usize>> {
+        self.project().op.operate()
+    }
+}
+
+impl<S> IntoInner for AcceptMulti<S> {
+    type Inner = (Socket2, SockAddr);
+
+    fn into_inner(self) -> Self::Inner {
+        self.op.into_inner()
+    }
+}
 unsafe impl<S: AsFd> OpCode for Connect<S> {
     fn pre_submit(self: Pin<&mut Self>) -> io::Result<Decision> {
         syscall!(
diff --git a/compio-driver/src/sys/stub/op.rs b/compio-driver/src/sys/stub/op.rs
index 29f71f8e3..73566b85b 100644
--- a/compio-driver/src/sys/stub/op.rs
+++ b/compio-driver/src/sys/stub/op.rs
@@ -125,6 +125,8 @@ impl OpCode for CloseSocket {}
 
 impl<S: AsFd> OpCode for Accept<S> {}
 
+impl<S: AsFd> OpCode for AcceptMulti<S> {}
+
 impl<S: AsFd> OpCode for Connect<S> {}
 
 impl<T: IoBufMut, S: AsFd> OpCode for Recv<T, S> {}
diff --git a/compio-driver/src/sys/unix_op.rs b/compio-driver/src/sys/unix_op.rs
index 115a7ca89..7a142b16a 100644
--- a/compio-driver/src/sys/unix_op.rs
+++ b/compio-driver/src/sys/unix_op.rs
@@ -548,9 +548,12 @@ impl<S> Accept<S> {
             _p: PhantomPinned,
         }
     }
+}
+
+impl<S> IntoInner for Accept<S> {
+    type Inner = (Socket2, SockAddr);
 
-    /// Get the remote address from the inner buffer.
-    pub fn into_addr(mut self) -> (Socket2, SockAddr) {
+    fn into_inner(mut self) -> Self::Inner {
         let socket = self.accepted_fd.take().expect("socket not accepted");
         (socket, unsafe { SockAddr::new(self.buffer, self.addr_len) })
     }
diff --git a/compio-driver/tests/op.rs b/compio-driver/tests/op.rs
index e6adfd35c..616673149 100644
--- a/compio-driver/tests/op.rs
+++ b/compio-driver/tests/op.rs
@@ -1,5 +1,3 @@
-#![feature(gen_blocks)]
-
 use std::{
     io::{self, Write},
     net::{TcpListener, TcpStream},
@@ -16,6 +14,9 @@ use compio_driver::{
 };
 mod pipe2;
 
+#[cfg(unix)]
+use compio_driver::op::AcceptMulti;
+
 #[cfg(unix)]
 #[test]
 fn truncate_file_poll() {
@@ -343,6 +344,55 @@ fn recv_multi() {
     push_and_wait(&mut driver, op).unwrap();
 }
 
+#[cfg(unix)]
+#[test]
+fn accept_multi() {
+    let server = TcpListener::bind("127.0.0.1:0").unwrap();
+    let addr = server.local_addr().unwrap();
+
+    let handle = std::thread::spawn(move || {
+        let mut driver = Proactor::new().unwrap();
+
+        let server = socket2::Socket::from(server);
+        if driver.driver_type().is_polling() {
+            server.set_nonblocking(true).unwrap();
+        }
+        let server = SharedFd::new(server);
+
+        driver.attach(server.as_raw_fd()).unwrap();
+
+        let mut i = 0;
+        loop {
+            let op = AcceptMulti::new(server.clone());
+            for BufResult(res, _) in push_and_wait_multi(&mut driver, op) {
+                let mut client = unsafe {
+                    use std::os::fd::FromRawFd;
+                    socket2::Socket::from_raw_fd(res.unwrap() as _)
+                };
+                client
+                    .write_all(format!("Hello, {}", i).as_bytes())
+                    .unwrap();
+                client.shutdown(std::net::Shutdown::Both).unwrap();
+                i += 1;
+                if i >= 2 {
+                    return;
+                }
+            }
+        }
+    });
+    for i in 0..2 {
+        use std::io::Read;
+
+        let mut client = TcpStream::connect(addr).unwrap();
+        let mut s = String::new();
+        client.read_to_string(&mut s).unwrap();
+        assert_eq!(s, format!("Hello, {}", i));
+    }
+    if let Err(e) = handle.join() {
+        std::panic::resume_unwind(e)
+    }
+}
+
 #[test]
 #[cfg(all(target_pointer_width = "64", any(io_uring, target_os = "windows")))]
 fn read_len_over_u32() {
diff --git a/compio-net/src/socket.rs b/compio-net/src/socket.rs
index eea8de0b1..ede37a2a7 100644
--- a/compio-net/src/socket.rs
+++ b/compio-net/src/socket.rs
@@ -95,7 +95,7 @@ impl Socket {
     pub async fn accept(&self) -> io::Result<(Self, SockAddr)> {
         let op = Accept::new(self.to_shared_fd());
         let (_, op) = buf_try!(@try compio_runtime::submit(op).await);
-        let (accept_sock, addr) = op.into_addr();
+        let (accept_sock, addr) = op.into_inner();
         let accept_sock = Self::from_socket2(accept_sock)?;
         Ok((accept_sock, addr))
     }

From 6ee247fec2601f37f0505974f062f519b80adc44 Mon Sep 17 00:00:00 2001
From: Yuyi Wang <Strawberry_Str@hotmail.com>
Date: Tue, 10 Mar 2026 22:50:36 +0800
Subject: [PATCH 3/6] fix(driver,stub): add accept multi

---
 compio-driver/src/sys/stub/op.rs | 22 +++++++++++++++++++++-
 1 file changed, 21 insertions(+), 1 deletion(-)

diff --git a/compio-driver/src/sys/stub/op.rs b/compio-driver/src/sys/stub/op.rs
index 73566b85b..b9269709a 100644
--- a/compio-driver/src/sys/stub/op.rs
+++ b/compio-driver/src/sys/stub/op.rs
@@ -3,7 +3,7 @@
 use std::ffi::CString;
 
 use compio_buf::{BufResult, IntoInner, IoBuf, IoBufMut, IoVectoredBuf, IoVectoredBufMut};
-use socket2::{SockAddr, SockAddrStorage, socklen_t};
+use socket2::{SockAddr, SockAddrStorage, Socket as Socket2, socklen_t};
 
 use super::{OpCode, stub_unimpl};
 pub use crate::sys::unix_op::*;
@@ -125,6 +125,26 @@ impl OpCode for CloseSocket {}
 
 impl<S: AsFd> OpCode for Accept<S> {}
 
+/// Accept multiple connections.
+pub struct Accept<S> {
+    fd: S,
+}
+
+impl<S> Accept<S> {
+    /// Create [`Accept`].
+    pub fn new(fd: S) -> Self {
+        Self { fd }
+    }
+}
+
+impl<S> IntoInner for Accept<S> {
+    type Inner = (Socket2, SockAddr);
+
+    fn into_inner(self) -> Self::Inner {
+        stub_unimpl()
+    }
+}
+
 impl<S: AsFd> OpCode for AcceptMulti<S> {}
 
 impl<S: AsFd> OpCode for Connect<S> {}

From 1959289bc8c102c981c7270ce5fd696e6ee1d3b8 Mon Sep 17 00:00:00 2001
From: Yuyi Wang <Strawberry_Str@hotmail.com>
Date: Tue, 10 Mar 2026 23:02:03 +0800
Subject: [PATCH 4/6] fix(driver): use returned op correctly

---
 compio-driver/tests/op.rs | 51 ++++++++++++++++++++++++++-------------
 1 file changed, 34 insertions(+), 17 deletions(-)

diff --git a/compio-driver/tests/op.rs b/compio-driver/tests/op.rs
index 616673149..5dbee7b7e 100644
--- a/compio-driver/tests/op.rs
+++ b/compio-driver/tests/op.rs
@@ -109,7 +109,7 @@ fn push_and_wait<O: OpCode + 'static>(driver: &mut Proactor, op: O) -> BufResult
 fn push_and_wait_multi<O: OpCode + 'static>(
     driver: &mut Proactor,
     op: O,
-) -> impl Iterator<Item = BufResult<usize, Extra>> + '_ {
+) -> impl Iterator<Item = BufResult<usize, (Extra, Option<O>)>> + '_ {
     let mut op = Some(op);
     let mut user_data = None;
     let mut finished = false;
@@ -121,9 +121,9 @@ fn push_and_wait_multi<O: OpCode + 'static>(
 
         if user_data.is_none() {
             match driver.push(op.take().expect("operation should be pushed once")) {
-                PushEntry::Ready(BufResult(res, _)) => {
+                PushEntry::Ready(BufResult(res, op)) => {
                     finished = true;
-                    return Some(BufResult(res, driver.default_extra()));
+                    return Some(BufResult(res, (driver.default_extra(), Some(op))));
                 }
                 PushEntry::Pending(k) => user_data = Some(k),
             }
@@ -131,15 +131,15 @@ fn push_and_wait_multi<O: OpCode + 'static>(
 
         loop {
             if let Some(res) = user_data.as_ref().and_then(|key| driver.pop_multishot(key)) {
-                return Some(res);
+                return Some(res.map_buffer(|extra| (extra, None)));
             }
 
             let key = user_data.take().expect("pending key should exist");
             match driver.pop_with_extra(key) {
                 PushEntry::Pending(k) => user_data = Some(k),
-                PushEntry::Ready((BufResult(res, _), extra)) => {
+                PushEntry::Ready((BufResult(res, op), extra)) => {
                     finished = true;
-                    return Some(BufResult(res, extra));
+                    return Some(BufResult(res, (extra, Some(op))));
                 }
             }
 
@@ -282,9 +282,16 @@ fn read_multi() {
 
     let op = ReadMultiAt::new(fd.clone(), 0, &pool, 1024).unwrap();
     let buffer = push_and_wait_multi(&mut driver, op)
-        .map(|res| res.take_buffer(&pool).map(|buf| buf.to_vec()))
-        .collect::<io::Result<Vec<_>>>()
-        .unwrap()
+        .map(|BufResult(res, (extra, op))| {
+            if let Some(op) = op {
+                (BufResult(res, op), extra).take_buffer(&pool)
+            } else {
+                BufResult(res, extra).take_buffer(&pool)
+            }
+            .map(|buf| buf.to_vec())
+            .unwrap_or_default()
+        })
+        .collect::<Vec<_>>()
         .into_iter()
         .flatten()
         .collect::<Vec<_>>();
@@ -323,10 +330,14 @@ fn recv_multi() {
     loop {
         let op = RecvMulti::new(stream.clone(), &pool, 0, 0).unwrap();
         let slice = push_and_wait_multi(&mut driver, op)
-            .map(|res| {
-                res.take_buffer(&pool)
-                    .map(|buf| buf.to_vec())
-                    .unwrap_or_default()
+            .map(|BufResult(res, (extra, op))| {
+                if let Some(op) = op {
+                    (BufResult(res, op), extra).take_buffer(&pool)
+                } else {
+                    BufResult(res, extra).take_buffer(&pool)
+                }
+                .map(|buf| buf.to_vec())
+                .unwrap_or_default()
             })
             .collect::<Vec<_>>()
             .into_iter()
@@ -364,10 +375,16 @@ fn accept_multi() {
         let mut i = 0;
         loop {
             let op = AcceptMulti::new(server.clone());
-            for BufResult(res, _) in push_and_wait_multi(&mut driver, op) {
-                let mut client = unsafe {
-                    use std::os::fd::FromRawFd;
-                    socket2::Socket::from_raw_fd(res.unwrap() as _)
+            for BufResult(res, (_, op)) in push_and_wait_multi(&mut driver, op) {
+                let mut client = if let Some(op) = op {
+                    use compio_buf::IntoInner;
+
+                    op.into_inner().0
+                } else {
+                    unsafe {
+                        use std::os::fd::FromRawFd;
+                        socket2::Socket::from_raw_fd(res.unwrap() as _)
+                    }
                 };
                 client
                     .write_all(format!("Hello, {}", i).as_bytes())

From 86548d28222cedd72344f207fe51cada3360464e Mon Sep 17 00:00:00 2001
From: Yuyi Wang <Strawberry_Str@hotmail.com>
Date: Tue, 10 Mar 2026 23:07:25 +0800
Subject: [PATCH 5/6] fix(driver,stub): typo

---
 compio-driver/src/sys/stub/op.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/compio-driver/src/sys/stub/op.rs b/compio-driver/src/sys/stub/op.rs
index b9269709a..02f51fc63 100644
--- a/compio-driver/src/sys/stub/op.rs
+++ b/compio-driver/src/sys/stub/op.rs
@@ -126,18 +126,18 @@ impl OpCode for CloseSocket {}
 impl<S: AsFd> OpCode for Accept<S> {}
 
 /// Accept multiple connections.
-pub struct Accept<S> {
+pub struct AcceptMulti<S> {
     fd: S,
 }
 
-impl<S> Accept<S> {
-    /// Create [`Accept`].
+impl<S> AcceptMulti<S> {
+    /// Create [`AcceptMulti`].
     pub fn new(fd: S) -> Self {
         Self { fd }
     }
 }
 
-impl<S> IntoInner for Accept<S> {
+impl<S> IntoInner for AcceptMulti<S> {
     type Inner = (Socket2, SockAddr);
 
     fn into_inner(self) -> Self::Inner {

From 7284ae060df4600e5fc1cc8504208aa530d057a9 Mon Sep 17 00:00:00 2001
From: Yuyi Wang <Strawberry_Str@hotmail.com>
Date: Tue, 10 Mar 2026 23:36:09 +0800
Subject: [PATCH 6/6] fix(driver,unix): don't return addr in AcceptMulti

---
 compio-driver/src/sys/iour/op.rs | 4 ++--
 compio-driver/src/sys/poll/op.rs | 4 ++--
 compio-driver/src/sys/stub/op.rs | 2 +-
 compio-driver/tests/op.rs        | 2 +-
 4 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/compio-driver/src/sys/iour/op.rs b/compio-driver/src/sys/iour/op.rs
index 8f6ef8d1e..dffaa7499 100644
--- a/compio-driver/src/sys/iour/op.rs
+++ b/compio-driver/src/sys/iour/op.rs
@@ -627,10 +627,10 @@ unsafe impl<S: AsFd> OpCode for AcceptMulti<S> {
 }
 
 impl<S> IntoInner for AcceptMulti<S> {
-    type Inner = (Socket2, SockAddr);
+    type Inner = Socket2;
 
     fn into_inner(self) -> Self::Inner {
-        self.op.into_inner()
+        self.op.into_inner().0
     }
 }
 
diff --git a/compio-driver/src/sys/poll/op.rs b/compio-driver/src/sys/poll/op.rs
index c8dd8414e..fec16aea5 100644
--- a/compio-driver/src/sys/poll/op.rs
+++ b/compio-driver/src/sys/poll/op.rs
@@ -800,10 +800,10 @@ unsafe impl<S: AsFd> OpCode for AcceptMulti<S> {
 }
 
 impl<S> IntoInner for AcceptMulti<S> {
-    type Inner = (Socket2, SockAddr);
+    type Inner = Socket2;
 
     fn into_inner(self) -> Self::Inner {
-        self.op.into_inner()
+        self.op.into_inner().0
     }
 }
 unsafe impl<S: AsFd> OpCode for Connect<S> {
diff --git a/compio-driver/src/sys/stub/op.rs b/compio-driver/src/sys/stub/op.rs
index 02f51fc63..e190562ad 100644
--- a/compio-driver/src/sys/stub/op.rs
+++ b/compio-driver/src/sys/stub/op.rs
@@ -138,7 +138,7 @@ impl<S> AcceptMulti<S> {
 }
 
 impl<S> IntoInner for AcceptMulti<S> {
-    type Inner = (Socket2, SockAddr);
+    type Inner = Socket2;
 
     fn into_inner(self) -> Self::Inner {
         stub_unimpl()
diff --git a/compio-driver/tests/op.rs b/compio-driver/tests/op.rs
index 5dbee7b7e..45b29e9b2 100644
--- a/compio-driver/tests/op.rs
+++ b/compio-driver/tests/op.rs
@@ -379,7 +379,7 @@ fn accept_multi() {
                 let mut client = if let Some(op) = op {
                     use compio_buf::IntoInner;
 
-                    op.into_inner().0
+                    op.into_inner()
                 } else {
                     unsafe {
                         use std::os::fd::FromRawFd;