3.2 epoll 與事件迴圈：用 libc 直接包 epoll#

struct epoll_event ev;
ev.events = EPOLLIN;
ev.data.fd = sock_fd;        // 只能塞一個整數/指標
epoll_ctl(epfd, EPOLL_CTL_ADD, sock_fd, &ev);

[dependencies]
libc = "0.2"

use std::collections::HashMap;
use std::io::{Read, Write, ErrorKind};
use std::os::unix::io::{AsRawFd, FromRawFd, OwnedFd, RawFd};
use std::net::{TcpListener, TcpStream};

fn main() -> std::io::Result<()> {
    let listener = TcpListener::bind("0.0.0.0:8080")?;
    listener.set_nonblocking(true)?;

    let epfd = unsafe { libc::epoll_create1(0) };
    assert!(epfd >= 0);

    let mut add = libc::epoll_event { events: libc::EPOLLIN as u32, u64: 0 };
    unsafe {
        libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, listener.as_raw_fd(), &mut add);
    }

    // fd → 連線的所有權表：epoll 的 data 只放 fd 編號，
    // 「事件回來時連線還活著」由這張 HashMap 的所有權保證
    let mut conns: HashMap<RawFd, OwnedFd> = HashMap::new();
    let mut events = [libc::epoll_event { events: 0, u64: 0 }; 64];
    let mut buf = [0u8; 4096];

    loop {
        let n = unsafe { libc::epoll_wait(epfd, events.as_mut_ptr(), 64, -1) };
        if n < 0 {
            let e = std::io::Error::last_os_error();
            if e.kind() == ErrorKind::Interrupted { continue; }  // EINTR 重試
            return Err(e);
        }
        for ev in &events[..n as usize] {
            let fd = ev.u64 as RawFd;
            if fd == listener.as_raw_fd() {
                // 新連線
                if let Ok((stream, _addr)) = listener.accept() {
                    stream.set_nonblocking(true)?;
                    let owned = unsafe { OwnedFd::from_raw_fd(stream.into_raw_fd()) };
                    let mut ev2 = libc::epoll_event {
                        events: (libc::EPOLLIN | libc::EPOLLET) as u32,
                        u64: owned.as_raw_fd() as u64,
                    };
                    unsafe {
                        libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD,
                                        owned.as_raw_fd(), &mut ev2);
                    }
                    conns.insert(owned.as_raw_fd(), owned);   // 所有權入表
                }
            } else {
                // 已連線：EPOLLET 邊緣觸發 → 讀到 EAGAIN 為止
                let mut owned = match conns.get(&fd) {
                    Some(o) => unsafe { OwnedFd::from_raw_fd(o.as_raw_fd()) },
                    None => continue,             // 理論上不會發生：型別保證
                };
                loop {
                    let n = unsafe {
                        libc::read(fd, buf.as_mut_ptr() as *mut _, buf.len())
                    };
                    if n > 0 {
                        let resp = format!("HTTP/1.1 200 OK\r\nContent-Length: {}\r\n\r\n", n);
                        let out = format!("{resp}{}", String::from_utf8_lossy(&buf[..n as usize]));
                        unsafe { libc::write(fd, out.as_ptr() as *const _, out.len()); }
                    } else if n == 0 {
                        // 對端關閉：從 epoll 摘除 → 從表移除 → fd 自動關閉
                        unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_DEL, fd, std::ptr::null_mut()); }
                        conns.remove(&fd);
                        break;
                    } else {
                        let e = std::io::Error::last_os_error();
                        if e.kind() == ErrorKind::WouldBlock { break; }   // EAGAIN
                        unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_DEL, fd, std::ptr::null_mut()); }
                        conns.remove(&fd);
                        break;
                    }
                }
                drop(owned);   // 借用版 fd（非擁有）drop 不會 close
            }
        }
    }
}