如何在Rust中正确轮询原始文件描述符(raw fd)？

问题核心 #

你当前的代码使用同步File::read读取原始套接字，该函数不会异步等待数据到达——当套接字无数据时会直接返回0，导致accept函数被反复调用，不断处理全零缓冲区。要解决这个问题，必须改用异步IO监听套接字可读事件，只有当有新数据时才执行读取操作，否则让出执行权。

实现思路 #

1. 抛弃同步File操作，改用异步IO库包装原始套接字，实现异步等待可读事件。
2. 利用异步运行时的工具，确保只有当套接字有数据时才触发读取逻辑。

可用Crate #

• tokio：官方异步运行时，提供AsyncFd可以将原始文件描述符包装为异步IO对象，监听可读/可写事件。
• socket2：用于创建和配置原始套接字，可与tokio无缝配合，简化套接字初始化流程。
• tuntap：专门针对tun/tap接口的异步Crate，已封装好异步读取逻辑，无需手动处理事件监听，适合你的场景。

代码修改示例 #

方案1：用tokio::AsyncFd改造现有代码 #

首先调整Server结构体，存储异步包装后的文件描述符：

use tokio::io::AsyncFd;
use std::os::unix::io::AsRawFd;

struct Server {
    async_fd: AsyncFd<std::fs::File>,
    num_connections: usize,
    // 其他原有字段
}

impl Server {
    pub fn new(raw_fd: i32) -> Self {
        let file = unsafe { std::fs::File::from_raw_fd(raw_fd) };
        let async_fd = AsyncFd::new(file).expect("Failed to create AsyncFd");
        Server {
            async_fd,
            num_connections: 0,
            // 其他字段初始化
        }
    }

然后重写accept函数，实现异步等待和读取：

pub async fn accept(&mut self, buf: &mut [u8]) -> Result<Connection, ()> {
    loop {
        // 等待套接字变为可读状态
        let mut read_guard = self.async_fd.readable().await.map_err(|_| ())?;

        // 尝试读取数据，处理WouldBlock错误（无数据时继续等待）
        match read_guard.try_io(|file| file.get_ref().read(buf)) {
            Ok(Ok(read_len)) if read_len > 0 => {
                // 仅处理读取到有效数据的情况
                let id = Alphanumeric.sample_string(&mut rand::thread_rng(), 16);
                let mut connection = Connection::new(id);
                connection.set_bytes_in(buf[..read_len].into());

                if self.parse_and_set_header_info(&buf[..read_len], &mut connection).is_err() {
                    return Err(());
                }

                self.num_connections += 1;
                return Ok(connection);
            }
            Ok(Ok(0)) => {
                // 套接字关闭，返回错误
                return Err(());
            }
            Ok(Err(e)) if e.kind() == std::io::ErrorKind::WouldBlock => {
                // 无数据，继续等待下一次可读事件
                continue;
            }
            _ => {
                // 其他读取错误
                return Err(());
            }
        }
    }
}

方案2：使用tuntap crate简化tun/tap处理 #

如果你的场景是tun/tap接口，直接用tuntap的异步封装会更简洁：

use tuntap::{Iface, Mode};
use tokio::io::AsyncReadExt;

// 初始化异步tun接口
let iface = Iface::new("tun0", Mode::Tun).expect("Failed to create tun interface");
let mut async_iface = tuntap::tokio::Async::new(iface).expect("Failed to wrap as async");

// 异步循环读取数据包
loop {
    let mut buf = vec![0; 1504];
    let read_len = async_iface.read(&mut buf).await.expect("Read from tun failed");
    
    if read_len == 0 {
        break; // 接口关闭，退出循环
    }

    // 处理读取到的数据包，创建Connection并 spawn 处理任务
    let id = Alphanumeric.sample_string(&mut rand::thread_rng(), 16);
    let mut connection = Connection::new(id);
    connection.set_bytes_in(buf[..read_len].into());

    if let Ok(()) = self.parse_and_set_header_info(&buf[..read_len], &mut connection) {
        self.num_connections += 1;
        tokio::spawn(async move { process(connection).await });
    }
}

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