可读事件读到 0 字节，或者事件里只有错误位

use std::io::{ErrorKind, Read, Write};
use std::net::Shutdown;
use std::time::Duration;

use exp_mio_pit2::{bools, raw};
use mio::net::{TcpListener, UdpSocket};
use mio::{Events, Interest, Poll, Token};

fn show(poll: &mut Poll, title: &str) {
  let mut events = Events::with_capacity(8);
  poll.poll(&mut events, Some(Duration::from_millis(200))).unwrap();
  println!("{title}: {} event(s)", events.iter().count());
  for e in &events {
    println!("    {}  => {}", raw(e), bools(e));
  }
}

fn closed_udp_port() -> std::net::SocketAddr {
  std::net::UdpSocket::bind("127.0.0.1:0").unwrap().local_addr().unwrap()
}

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

  // 1. peer sends 2 bytes and then FIN
  let mut peer = std::net::TcpStream::connect(l.local_addr()?)?;
  std::thread::sleep(Duration::from_millis(20));
  let (mut s, _) = l.accept()?;
  let mut poll = Poll::new()?;
  poll.registry().register(&mut s, Token(1), Interest::READABLE)?;
  peer.write_all(b"hi")?;
  peer.shutdown(Shutdown::Write)?;
  show(&mut poll, "1. peer writes \"hi\", then shutdown(Write)");
  // a loop that only stops at WouldBlock, capped at 4 reads
  let mut buf = [0u8; 16];
  for i in 1..=4 {
    match s.read(&mut buf) {
      Ok(n) => println!("    read #{i}: Ok({n})"),
      Err(e) if e.kind() == ErrorKind::WouldBlock => {
        println!("    read #{i}: WouldBlock");
        break;
      }
      Err(e) => println!("    read #{i}: Err({e})"),
    }
  }
  show(&mut poll, "   poll again");

  // 2. connected UDP socket, peer port closed, READABLE only; recv before take_error
  let mut poll = Poll::new()?;
  let mut u = UdpSocket::bind("127.0.0.1:0".parse().unwrap())?;
  u.connect(closed_udp_port())?;
  poll.registry().register(&mut u, Token(2), Interest::READABLE)?;
  u.send(b"anyone?")?;
  show(&mut poll, "2. connected UDP, send to a closed port");
  println!("    recv       = {:?}", u.recv(&mut buf).map_err(|e| e.kind()));
  println!("    take_error = {:?}", u.take_error()?.map(|e| e.kind()));
  println!("    recv       = {:?}", u.recv(&mut buf).map_err(|e| e.kind()));

  // 3. unconnected UDP socket, send_to a closed port
  let mut poll = Poll::new()?;
  let mut u = UdpSocket::bind("127.0.0.1:0".parse().unwrap())?;
  poll.registry().register(&mut u, Token(3), Interest::READABLE)?;
  u.send_to(b"anyone?", closed_udp_port())?;
  show(&mut poll, "3. unconnected UDP, send_to a closed port");
  println!("    take_error = {:?}", u.take_error()?.map(|e| e.kind()));

  // 4. WRITABLE only, peer shutdown(Write)
  let peer = std::net::TcpStream::connect(l.local_addr()?)?;
  std::thread::sleep(Duration::from_millis(20));
  let (mut s, _) = l.accept()?;
  let mut poll = Poll::new()?;
  poll.registry().register(&mut s, Token(4), Interest::WRITABLE)?;
  show(&mut poll, "4. WRITABLE only, initial");
  peer.shutdown(Shutdown::Write)?;
  show(&mut poll, "   peer shutdown(Write)");
  Ok(())
}

os=linux
1. peer writes "hi", then shutdown(Write): 1 event(s)
    events=IN|RDHUP data=0x1  => readable read_closed
    read #1: Ok(2)
    read #2: Ok(0)
    read #3: Ok(0)
    read #4: Ok(0)
   poll again: 0 event(s)
2. connected UDP, send to a closed port: 1 event(s)
    events=ERR data=0x2  => error write_closed
    recv       = Err(ConnectionRefused)
    take_error = None
    recv       = Err(WouldBlock)
3. unconnected UDP, send_to a closed port: 0 event(s)
    take_error = None
4. WRITABLE only, initial: 1 event(s)
    events=OUT data=0x4  => writable
   peer shutdown(Write): 1 event(s)
    events=OUT data=0x4  => writable

os=macos
1. peer writes "hi", then shutdown(Write): 1 event(s)
    filter=READ flags=EOF|CLEAR fflags=0 data=2 udata=0x1  => readable read_closed
    read #1: Ok(2)
    read #2: Ok(0)
    read #3: Ok(0)
    read #4: Ok(0)
   poll again: 1 event(s)
    filter=READ flags=EOF|CLEAR fflags=0 data=0 udata=0x1  => readable read_closed
2. connected UDP, send to a closed port: 1 event(s)
    filter=READ flags=CLEAR fflags=0 data=0 udata=0x2  => readable
    recv       = Err(ConnectionRefused)
    take_error = None
    recv       = Err(WouldBlock)
3. unconnected UDP, send_to a closed port: 0 event(s)
    take_error = None
4. WRITABLE only, initial: 1 event(s)
    filter=WRITE flags=CLEAR fflags=0 data=146988 udata=0x4  => writable
   peer shutdown(Write): 0 event(s)

    pub fn is_read_closed(event: &Event) -> bool {
        // Both halves of the socket have closed
        event.events as libc::c_int & libc::EPOLLHUP != 0
            // Socket has received FIN or called shutdown(SHUT_RD)
            || (event.events as libc::c_int & libc::EPOLLIN != 0
                && event.events as libc::c_int & libc::EPOLLRDHUP != 0)
    }

    pub fn is_read_closed(event: &Event) -> bool {
        event.0.filter == libc::EVFILT_READ && event.0.flags & libc::EV_EOF != 0
    }

tokio = { version = "=1.54.1", features = ["rt", "net", "time", "macros"] }

use std::time::Duration;

use tokio::net::UdpSocket;

// connected UDP socket, peer port closed: does recv().await return?
#[tokio::main(flavor = "current_thread")]
async fn main() -> std::io::Result<()> {
  println!("os={}", std::env::consts::OS);
  let closed = std::net::UdpSocket::bind("127.0.0.1:0")?.local_addr()?;
  let u = UdpSocket::bind("127.0.0.1:0").await?;
  u.connect(closed).await?;
  u.send(b"anyone?").await?;
  let mut buf = [0u8; 64];
  let r = tokio::time::timeout(Duration::from_secs(1), u.recv(&mut buf)).await;
  println!("recv().await within 1s: {:?}", r.map(|r| r.map_err(|e| e.kind())));
  Ok(())
}

recv().await within 1s: Ok(Err(ConnectionRefused))

os=linux
recv().await within 1s: Err(Elapsed(()))

epoll_ctl(5, EPOLL_CTL_ADD, 6, {events=EPOLLIN|EPOLLOUT|EPOLLRDHUP|EPOLLET, data=0xffffb6338b00}) = 0
connect(6, {sa_family=AF_INET, sin_port=htons(46355), sin_addr=inet_addr("127.0.0.1")}, 16) = 0
epoll_pwait(3, [{events=EPOLLOUT, data=0xffffb6338b00}], 1024, -1, NULL, 8) = 1
sendto(6, "anyone?", 7, MSG_NOSIGNAL, NULL, 0) = 7
epoll_pwait(3, [{events=EPOLLOUT|EPOLLERR, data=0xffffb6338b00}, {events=EPOLLIN, data=0}], 1024, 959, NULL, 8) = 2
recvfrom(6, 0xfffff2651eb8, 64, 0, NULL, NULL) = -1 ECONNREFUSED (Connection refused)