自研异步Runtime中，如何实现TcpStream::connect()的异步版本？

• 为什么std::TcpStream::connect不适用？
  它内部合并了socket(2)和connect(2)系统调用，当连接处于pending状态（返回WouldBlocking）时，你无法获取到底层的文件描述符（fd），也就没法将其注册到事件轮询器中等待连接完成，这不符合异步Runtime的事件驱动模型。

• 是否必须直接调用底层系统调用？
  是的，这是异步connect的标准实现方式。异步网络库（比如async-io）都采用这种方案，因为只有手动拆分socket创建和connect操作，才能拿到未连接的socket fd，进而在连接pending时将其注册到事件轮询器，监听可写事件（连接完成时socket会变为可写状态）。

• 你设想的UnconnectedTcpStream思路完全正确
  这种拆分socket创建与连接的设计，正是异步TCP流实现的核心思路。以下是更贴近实际异步场景的代码示例：

use std::os::unix::io::{RawFd, AsRawFd};
use std::net::SocketAddr;

// 未连接的TCP流，持有原始文件描述符
pub struct UnconnectedTcpStream {
    fd: RawFd,
}

impl UnconnectedTcpStream {
    // 创建非阻塞的未连接socket，对应socket(2)系统调用
    pub fn new() -> std::io::Result<Self> {
        let fd = unsafe { libc::socket(libc::AF_INET, libc::SOCK_STREAM, 0) };
        if fd == -1 {
            return Err(std::io::Error::last_os_error());
        }

        // 设置socket为非阻塞模式，异步操作的前提
        let flags = unsafe { libc::fcntl(fd, libc::F_GETFL) };
        if flags == -1 {
            unsafe { libc::close(fd) };
            return Err(std::io::Error::last_os_error());
        }
        if unsafe { libc::fcntl(fd, libc::F_SETFL, flags | libc::O_NONBLOCK) } == -1 {
            unsafe { libc::close(fd) };
            return Err(std::io::Error::last_os_error());
        }

        Ok(Self { fd })
    }

    // 异步执行连接操作，对应connect(2)系统调用
    pub async fn connect(self, addr: SocketAddr) -> std::io::Result<TcpStream> {
        let (sockaddr_ptr, sockaddr_len) = match addr {
            SocketAddr::V4(v4) => {
                let mut addr = libc::sockaddr_in {
                    sin_family: libc::AF_INET as u16,
                    sin_port: u16::to_be(v4.port()),
                    sin_addr: libc::in_addr { s_addr: u32::to_be(v4.ip().into()) },
                    sin_zero: [0; 8],
                };
                (
                    &addr as *const _ as *const libc::sockaddr,
                    std::mem::size_of_val(&addr) as libc::socklen_t,
                )
            }
            SocketAddr::V6(_) => todo!("IPv6 支持需补充对应逻辑"),
        };

        let connect_result = unsafe { libc::connect(self.fd, sockaddr_ptr, sockaddr_len) };

        match connect_result {
            0 => Ok(TcpStream { fd: self.fd }), // 连接直接成功
            -1 => {
                let err = std::io::Error::last_os_error();
                match err.kind() {
                    std::io::ErrorKind::WouldBlock => {
                        // 连接处于pending，注册到事件轮询器监听可写事件
                        crate::event_poller::get_global_poller().register_write(self.fd).await?;

                        // 检查连接实际结果：可写不代表一定成功，需通过SO_ERROR验证
                        let mut errno = 0;
                        let mut err_len = std::mem::size_of::<i32>() as libc::socklen_t;
                        unsafe {
                            libc::getsockopt(
                                self.fd,
                                libc::SOL_SOCKET,
                                libc::SO_ERROR,
                                &mut errno as *mut _ as *mut libc::c_void,
                                &mut err_len,
                            )
                        };

                        if errno != 0 {
                            Err(std::io::Error::from_raw_os_error(errno))
                        } else {
                            Ok(TcpStream { fd: self.fd })
                        }
                    }
                    _ => Err(err), // 其他连接错误直接返回
                }
            }
            _ => unreachable!(),
        }
    }
}

// 已连接的TCP流，持有原始文件描述符
pub struct TcpStream {
    fd: RawFd,
}

impl AsRawFd for TcpStream {
    fn as_raw_fd(&self) -> RawFd {
        self.fd
    }
}

• 关键注意点
  1. 必须将socket设置为非阻塞模式，否则connect会阻塞线程，违背异步Runtime的设计初衷。
  2. 当connect返回WouldBlocking后，监听socket的可写事件只是第一步，必须通过getsockopt(SO_ERROR)检查连接的实际结果——因为socket变为可写也可能是连接失败的信号。
  3. std::net没有提供拆分的API，是因为它面向同步编程场景，不需要暴露底层的分步操作；而异步场景必须直接操作系统调用，才能实现对事件的精细控制。

内容的提问来源于stack exchange，提问作者wub