drop 之后还收到旧 token 的事件

mio = { version = "=1.2.4", features = ["os-poll", "net", "os-ext"] }
libc = "=0.2.191"

use std::io::{self, Write};
use std::os::fd::AsRawFd;
use std::process::Command;
use std::time::Duration;

use mio::net::{TcpListener, TcpStream};
use mio::{Events, Interest, Poll, Token};

// One registered server-side socket (Token(1)) plus its peer.
fn setup(l: &TcpListener) -> io::Result<(Poll, TcpStream, std::net::TcpStream)> {
  let peer = std::net::TcpStream::connect(l.local_addr()?)?;
  std::thread::sleep(Duration::from_millis(20));
  let (mut s, _) = l.accept()?;
  let poll = Poll::new()?;
  poll.registry().register(&mut s, Token(1), Interest::READABLE)?;
  Ok((poll, s, peer))
}

fn tokens(poll: &mut Poll) -> Vec<usize> {
  let mut events = Events::with_capacity(8);
  poll.poll(&mut events, Some(Duration::from_millis(100))).unwrap();
  events.iter().map(|e| e.token().0).collect()
}

// Linux: the epoll instance's interest list, from /proc/self/fdinfo
#[cfg(target_os = "linux")]
fn interest_list(poll: &Poll) -> String {
  let info = std::fs::read_to_string(format!("/proc/self/fdinfo/{}", poll.as_raw_fd())).unwrap();
  let items: Vec<&str> = info.lines().filter(|l| l.starts_with("tfd:")).collect();
  format!("{items:?}")
}

#[cfg(not(target_os = "linux"))]
fn interest_list(_: &Poll) -> String {
  "n/a".to_string()
}

fn cloexec(fd: i32) -> bool {
  unsafe { libc::fcntl(fd, libc::F_GETFD) & libc::FD_CLOEXEC != 0 }
}

fn main() -> io::Result<()> {
  println!("os={}", std::env::consts::OS);
  let l = TcpListener::bind("127.0.0.1:0".parse().unwrap())?;

  // A. a child process started with Command while the socket is registered
  let (mut poll, s, mut peer) = setup(&l)?;
  println!("A. socket fd {} has FD_CLOEXEC: {}", s.as_raw_fd(), cloexec(s.as_raw_fd()));
  let mut child = Command::new("sleep").arg("1").spawn()?;
  drop(s);
  peer.write_all(b"x")?;
  println!("   Command child alive, dropped, peer writes -> tokens {:?}", tokens(&mut poll));
  child.kill()?;
  child.wait()?;

  // B. fork() without exec: the child holds a copy of every fd
  let (mut poll, s, mut peer) = setup(&l)?;
  let pid = unsafe { libc::fork() };
  if pid == 0 {
    std::thread::sleep(Duration::from_millis(500));
    unsafe { libc::_exit(0) };
  }
  drop(s);
  peer.write_all(b"x")?;
  println!("B. forked child alive, dropped, peer writes  -> tokens {:?}", tokens(&mut poll));
  unsafe { libc::waitpid(pid, std::ptr::null_mut(), 0) };
  let _ = peer.write_all(b"x"); // the socket is closed now: may fail
  println!("   child exited, peer writes again          -> tokens {:?}", tokens(&mut poll));

  // C. libc::dup, then drop without deregister
  let (mut poll, s, mut peer) = setup(&l)?;
  let dup = unsafe { libc::dup(s.as_raw_fd()) };
  drop(s);
  peer.write_all(b"x")?;
  println!("C. dup fd {dup} open, dropped, peer writes      -> tokens {:?}", tokens(&mut poll));
  println!("   interest list: {}", interest_list(&poll));
  peer.write_all(b"x")?;
  println!("   peer writes again                         -> tokens {:?}", tokens(&mut poll));
  unsafe { libc::close(dup) };

  // D. the fix: deregister first, then drop
  let (mut poll, mut s, mut peer) = setup(&l)?;
  let dup = unsafe { libc::dup(s.as_raw_fd()) };
  poll.registry().deregister(&mut s)?;
  drop(s);
  peer.write_all(b"x")?;
  println!("D. dup fd {dup} open, deregister+drop, peer writes -> tokens {:?}", tokens(&mut poll));
  unsafe { libc::close(dup) };
  Ok(())
}

os=linux
A. socket fd 5 has FD_CLOEXEC: true
   Command child alive, dropped, peer writes -> tokens []
B. forked child alive, dropped, peer writes  -> tokens [1]
   child exited, peer writes again          -> tokens []
C. dup fd 11 open, dropped, peer writes      -> tokens [1]
   interest list: ["tfd:        9 events: 80002019 data:                1  pos:0 ino:c16 sdev:7"]
   peer writes again                         -> tokens [1]
D. dup fd 13 open, deregister+drop, peer writes -> tokens []

os=macos
A. socket fd 5 has FD_CLOEXEC: true
   Command child alive, dropped, peer writes -> tokens []
B. forked child alive, dropped, peer writes  -> tokens []
   child exited, peer writes again          -> tokens []
C. dup fd 11 open, dropped, peer writes      -> tokens []
   interest list: n/a
   peer writes again                         -> tokens []
D. dup fd 13 open, deregister+drop, peer writes -> tokens []

/// # Dropping `event::Source`s
///
/// All `event::Source`s, unless otherwise specified, need to be [deregistered]
/// before being dropped for them to not leak resources. This goes against the
/// normal drop behaviour of types in Rust which cleanup after themselves, e.g.
/// a `File` will close itself. However since deregistering needs access to
/// [`Registry`] this cannot be done while being dropped.

impl<E: Source> Drop for PollEvented<E> {
    fn drop(&mut self) {
        if let Some(mut io) = self.io.take() {
            // Ignore errors
            let _ = self.registration.deregister(&mut io);
        }
    }
}