UDP 与 Unix 域套接字

pub fn bind(addr: SocketAddr) -> io::Result<net::UdpSocket> {
    let fd = new_ip_socket(addr, libc::SOCK_DGRAM)?;
    let socket = unsafe { net::UdpSocket::from_raw_fd(fd) };

    let (raw_addr, raw_addr_length) = socket_addr(&addr);
    syscall!(bind(fd, raw_addr.as_ptr(), raw_addr_length))?;

    Ok(socket)
}

use std::io::ErrorKind;
use std::time::Duration;

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

fn show(poll: &mut Poll, events: &mut Events) -> std::io::Result<()> {
  poll.poll(events, Some(Duration::from_secs(1)))?;
  for e in events.iter() {
    println!("event: {}  => {}", raw(e), bools(e));
  }
  Ok(())
}

fn main() -> std::io::Result<()> {
  println!("os={}", std::env::consts::OS);
  let mut events = Events::with_capacity(8);
  let mut buf = [0u8; 64];

  // 1. three datagrams before one poll
  let mut poll = Poll::new()?;
  let a = UdpSocket::bind("127.0.0.1:0".parse().unwrap())?;
  let mut b = UdpSocket::bind("127.0.0.1:0".parse().unwrap())?;
  poll.registry().register(&mut b, Token(1), Interest::READABLE)?;
  for msg in [&b"one"[..], b"two", b"three"] {
    a.send_to(msg, b.local_addr()?)?;
  }
  show(&mut poll, &mut events)?;
  loop {
    match b.recv_from(&mut buf) {
      Ok((n, from)) => println!("recv_from: {:?} from a: {}", String::from_utf8_lossy(&buf[..n]), from == a.local_addr()?),
      Err(e) if e.kind() == ErrorKind::WouldBlock => {
        println!("recv_from: WouldBlock");
        break;
      }
      Err(e) => return Err(e),
    }
  }

  // 2. connect + send, peek then recv
  let mut poll = Poll::new()?;
  let mut d = UdpSocket::bind("127.0.0.1:0".parse().unwrap())?;
  poll.registry().register(&mut d, Token(2), Interest::READABLE)?;
  a.connect(d.local_addr()?)?;
  a.send(b"hi")?;
  show(&mut poll, &mut events)?;
  let n = d.peek(&mut buf)?;
  println!("peek: {:?}", String::from_utf8_lossy(&buf[..n]));
  let n = d.recv(&mut buf)?;
  println!("recv: {:?}", String::from_utf8_lossy(&buf[..n]));
  println!("recv again: {:?}", d.recv(&mut buf).map_err(|e| e.kind()));

  // 3. connected socket, peer port closed
  let mut poll = Poll::new()?;
  let closed = std::net::UdpSocket::bind("127.0.0.1:0")?.local_addr()?;
  let mut c = UdpSocket::bind("127.0.0.1:0".parse().unwrap())?;
  c.connect(closed)?;
  poll.registry().register(&mut c, Token(3), Interest::READABLE)?;
  c.send(b"anyone?")?;
  show(&mut poll, &mut events)?;
  println!("take_error = {:?}", c.take_error()?);
  println!("recv = {:?}", c.recv(&mut buf).map_err(|e| e.kind()));
  Ok(())
}

os=macos
event: filter=READ flags=CLEAR fflags=0 data=3 udata=0x1  => readable
recv_from: "one" from a: true
recv_from: "two" from a: true
recv_from: "three" from a: true
recv_from: WouldBlock
event: filter=READ flags=CLEAR fflags=0 data=2 udata=0x2  => readable
peek: "hi"
recv: "hi"
recv again: Err(WouldBlock)

os=linux
event: events=IN data=0x1  => readable
recv_from: "one" from a: true
recv_from: "two" from a: true
recv_from: "three" from a: true
recv_from: WouldBlock
event: events=IN data=0x2  => readable
peek: "hi"
recv: "hi"
recv again: Err(WouldBlock)

4     write(1, "os=linux\n", 9)         = 9
4     socket(AF_INET, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, IPPROTO_IP) = 4
4     bind(4, {sa_family=AF_INET, sin_port=htons(0), sin_addr=inet_addr("127.0.0.1")}, 16) = 0
4     socket(AF_INET, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, IPPROTO_IP) = 5
4     bind(5, {sa_family=AF_INET, sin_port=htons(0), sin_addr=inet_addr("127.0.0.1")}, 16) = 0
4     epoll_ctl(3, EPOLL_CTL_ADD, 5, {events=EPOLLIN|EPOLLRDHUP|EPOLLET, data=0x1}) = 0
4     sendto(4, "one", 3, MSG_NOSIGNAL, {sa_family=AF_INET, sin_port=htons(51232), sin_addr=inet_addr("127.0.0.1")}, 16) = 3
4     sendto(4, "two", 3, MSG_NOSIGNAL, {sa_family=AF_INET, sin_port=htons(51232), sin_addr=inet_addr("127.0.0.1")}, 16) = 3
4     sendto(4, "three", 5, MSG_NOSIGNAL, {sa_family=AF_INET, sin_port=htons(51232), sin_addr=inet_addr("127.0.0.1")}, 16) = 5
4     epoll_pwait(3, [{events=EPOLLIN, data=0x1}], 8, 1000, NULL, 8) = 1
4     write(1, "event: events=IN data=0x1  => re"..., 39) = 39
4     recvfrom(5, "one", 64, 0, {sa_family=AF_INET, sin_port=htons(56327), sin_addr=inet_addr("127.0.0.1")}, [128 => 16]) = 3
4     write(1, "recv_from: \"one\" from a: true\n", 30) = 30
4     recvfrom(5, "two", 64, 0, {sa_family=AF_INET, sin_port=htons(56327), sin_addr=inet_addr("127.0.0.1")}, [128 => 16]) = 3
4     write(1, "recv_from: \"two\" from a: true\n", 30) = 30
4     recvfrom(5, "three", 64, 0, {sa_family=AF_INET, sin_port=htons(56327), sin_addr=inet_addr("127.0.0.1")}, [128 => 16]) = 5
4     write(1, "recv_from: \"three\" from a: true\n", 32) = 32
4     recvfrom(5, 0xffffdcfa4fc0, 64, 0, 0xffffdcfa4ef8, [128]) = -1 EAGAIN (Resource temporarily unavailable)
4     write(1, "recv_from: WouldBlock\n", 22) = 22
4     socket(AF_INET, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, IPPROTO_IP) = 7
4     bind(7, {sa_family=AF_INET, sin_port=htons(0), sin_addr=inet_addr("127.0.0.1")}, 16) = 0
4     epoll_ctl(6, EPOLL_CTL_ADD, 7, {events=EPOLLIN|EPOLLRDHUP|EPOLLET, data=0x2}) = 0
4     connect(4, {sa_family=AF_INET, sin_port=htons(40476), sin_addr=inet_addr("127.0.0.1")}, 16) = 0
4     sendto(4, "hi", 2, MSG_NOSIGNAL, NULL, 0) = 2
4     epoll_pwait(6, [{events=EPOLLIN, data=0x2}], 8, 1000, NULL, 8) = 1
4     write(1, "event: events=IN data=0x2  => re"..., 39) = 39
4     recvfrom(7, "hi", 64, MSG_PEEK, NULL, NULL) = 2
4     write(1, "peek: \"hi\"\n", 11)    = 11
4     recvfrom(7, "hi", 64, 0, NULL, NULL) = 2
4     write(1, "recv: \"hi\"\n", 11)    = 11
4     recvfrom(7, 0xffffdcfa4fc0, 64, 0, NULL, NULL) = -1 EAGAIN (Resource temporarily unavailable)
4     write(1, "recv again: Err(WouldBlock)\n", 28) = 28

    pub fn bind<P: AsRef<Path>>(path: P) -> io::Result<UnixListener> {
        let addr = SocketAddr::from_pathname(path)?;
        UnixListener::bind_addr(&addr)
    }

    let mut addrlen = path_offset(&sockaddr) + addr.len();
    // +1 for null byte at the end of the path, not needed for abstract
    // namespaces (which start with a null byte).
    match addr.first() {
        Some(&0) | None => {}
        Some(_) => addrlen += 1,
    }

    #[allow(unused_mut)] // See below.
    let mut path_len = socklen as usize - path_offset(&sockaddr);
    // On FreeBSD and Darwin, it returns a length of 14/16, but an unnamed (all
    // zero) address. Map that to a length of 0 to match other OS.
    if sockaddr.sun_path[0] == 0 {
        path_len = 0;
    }
    // SAFETY: going from i8 to u8 is fine in this context.
    let mut path =
        unsafe { &*(&sockaddr.sun_path[..path_len] as *const [libc::c_char] as *const [u8]) };
    // Remove last null as `SocketAddr::from_pathname` doesn't accept it.
    if let Some(0) = path.last() {
        path = &path[..path.len() - 1];
    }
    let address = SocketAddr::from_pathname(Path::new(OsStr::from_bytes(path)))?;
    Ok((socket, address))

use std::os::fd::AsRawFd;

// What does a raw accept(2) on a Unix listener put into sockaddr_un for an
// unbound (unnamed) client? This is what mio's uds::listener::accept has to parse.
fn main() -> std::io::Result<()> {
  println!("os={}", std::env::consts::OS);
  let path = std::env::temp_dir().join(format!("mio-len-{}.sock", std::process::id()));
  let listener = std::os::unix::net::UnixListener::bind(&path)?;
  let _client = std::os::unix::net::UnixStream::connect(&path)?;

  let mut sa: libc::sockaddr_un = unsafe { std::mem::zeroed() };
  let mut len = size_of::<libc::sockaddr_un>() as libc::socklen_t;
  println!("socklen in = {len}");
  let fd = unsafe { libc::accept(listener.as_raw_fd(), &mut sa as *mut _ as *mut libc::sockaddr, &mut len) };
  assert!(fd >= 0);
  let offset = (&sa.sun_path as *const _ as usize) - (&sa as *const _ as usize);
  println!("socklen out = {len}, path offset = {offset}, sun_path[0] = {}", sa.sun_path[0]);
  unsafe { libc::close(fd) };
  std::fs::remove_file(&path)?;
  Ok(())
}

os=macos
socklen in = 106
socklen out = 16, path offset = 2, sun_path[0] = 0

os=linux
socklen in = 110
socklen out = 2, path offset = 2, sun_path[0] = 0

pub(crate) fn connect_addr(address: &SocketAddr) -> io::Result<net::UnixStream> {
    let fd = new_socket(libc::AF_UNIX, libc::SOCK_STREAM)?;
    let socket = unsafe { net::UnixStream::from_raw_fd(fd) };

    let (unix_address, addrlen) = unix_addr(address);
    let sockaddr = &unix_address as *const libc::sockaddr_un as *const libc::sockaddr;
    match syscall!(connect(fd, sockaddr, addrlen)) {
        Ok(_) => {}
        Err(ref err) if err.raw_os_error() == Some(libc::EINPROGRESS) => {}
        Err(e) => return Err(e),
    }

    Ok(socket)
}

use std::os::fd::AsRawFd;

use mio::net::{UnixListener, UnixStream};

// Shrink the listener's backlog to 0, never accept, connect until the first failure.
fn main() -> std::io::Result<()> {
  println!("os={}", std::env::consts::OS);
  let path = std::env::temp_dir().join(format!("mio-bl-{}.sock", std::process::id()));
  let listener = UnixListener::bind(&path)?;
  assert_eq!(unsafe { libc::listen(listener.as_raw_fd(), 0) }, 0);
  let mut keep = Vec::new();
  for i in 1..=1000 {
    match UnixStream::connect(&path) {
      Ok(s) => keep.push(s),
      Err(e) => {
        println!("connect #{i}: Err({:?}) {e}", e.kind());
        break;
      }
    }
  }
  println!("{} connect(s) returned Ok", keep.len());
  std::fs::remove_file(&path)?;
  Ok(())
}

os=linux
connect #2: Err(WouldBlock) Resource temporarily unavailable (os error 11)
1 connect(s) returned Ok

4     listen(3, -1)                     = 0
4     listen(3, 0)                      = 0
4     connect(4, {sa_family=AF_UNIX, sun_path="/tmp/mio-bl-4.sock"}, 21) = 0
4     connect(5, {sa_family=AF_UNIX, sun_path="/tmp/mio-bl-4.sock"}, 21) = -1 EAGAIN (Resource temporarily unavailable)
4     +++ exited with 0 +++

os=macos
connect #129: Err(ConnectionRefused) Connection refused (os error 61)
128 connect(s) returned Ok

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

use exp_mio_net::{bools, raw};
use mio::net::{UnixDatagram, UnixListener, UnixStream};
use mio::{Events, Interest, Poll, Token};

fn main() -> std::io::Result<()> {
  println!("os={}", std::env::consts::OS);
  let dir = std::env::temp_dir().join(format!("mio-uds-{}", std::process::id()));
  std::fs::create_dir(&dir)?;
  let mut poll = Poll::new()?;
  let mut events = Events::with_capacity(8);

  // 1. listener + stream
  let path = dir.join("l.sock");
  let mut listener = UnixListener::bind(&path)?;
  poll.registry().register(&mut listener, Token(0), Interest::READABLE)?;
  let mut client = UnixStream::connect(&path)?;
  println!("client peer_addr = {:?}", client.peer_addr()?.as_pathname().map(|p| p.file_name().unwrap().to_owned()));
  poll.poll(&mut events, Some(Duration::from_secs(1)))?;
  for e in &events {
    println!("event: {}  => {}", raw(e), bools(e));
  }
  let (mut server, addr) = listener.accept()?;
  println!("accept addr = {addr:?}, is_unnamed = {}", addr.is_unnamed());
  println!("accept again = {:?}", listener.accept().map(|_| ()).map_err(|e| e.kind()));
  poll.registry().register(&mut server, Token(1), Interest::READABLE)?;
  client.write_all(b"ping")?;
  poll.poll(&mut events, Some(Duration::from_secs(1)))?;
  for e in &events {
    println!("event: {}  => {}", raw(e), bools(e));
  }
  let mut buf = [0u8; 64];
  let n = server.read(&mut buf)?;
  println!("server read {:?}", String::from_utf8_lossy(&buf[..n]));

  // 2. datagram: bound receiver, one unbound and one bound sender
  let rpath = dir.join("r.sock");
  let mut r = UnixDatagram::bind(&rpath)?;
  poll.registry().register(&mut r, Token(2), Interest::READABLE)?;
  let unbound = UnixDatagram::unbound()?;
  let bound = UnixDatagram::bind(dir.join("s.sock"))?;
  unbound.send_to(b"from unbound", &rpath)?;
  bound.send_to(b"from bound", &rpath)?;
  poll.poll(&mut events, Some(Duration::from_secs(1)))?;
  for e in &events {
    println!("event: {}  => {}", raw(e), bools(e));
  }
  while let Ok((n, from)) = r.recv_from(&mut buf) {
    println!(
      "recv_from {:?}: unnamed={} path={:?}",
      String::from_utf8_lossy(&buf[..n]),
      from.is_unnamed(),
      from.as_pathname().map(|p| p.file_name().unwrap().to_owned())
    );
  }

  // 3. Linux only: abstract namespace through bind_addr
  #[cfg(target_os = "linux")]
  {
    use std::os::linux::net::SocketAddrExt;
    let addr = std::os::unix::net::SocketAddr::from_abstract_name(b"mio-demo")?;
    let l = UnixListener::bind_addr(&addr)?;
    println!("abstract local_addr = {:?}", l.local_addr()?);
  }

  std::fs::remove_dir_all(&dir)?;
  Ok(())
}

os=macos
client peer_addr = Some("l.sock")
event: filter=READ flags=CLEAR fflags=0 data=1 udata=0x0  => readable
accept addr = (unnamed), is_unnamed = true
accept again = Err(WouldBlock)
event: filter=READ flags=CLEAR fflags=0 data=4 udata=0x1  => readable
server read "ping"
event: filter=READ flags=CLEAR fflags=0 data=22 udata=0x2  => readable
recv_from "from unbound": unnamed=true path=None
recv_from "from bound": unnamed=false path=Some("s.sock")

os=linux
client peer_addr = Some("l.sock")
event: events=IN data=0x0  => readable
accept addr = (unnamed), is_unnamed = true
accept again = Err(WouldBlock)
event: events=IN data=0x1  => readable
server read "ping"
event: events=IN data=0x2  => readable
recv_from "from unbound": unnamed=true path=None
recv_from "from bound": unnamed=false path=Some("s.sock")
abstract local_addr = "mio-demo" (abstract)

4     write(1, "os=linux\n", 9)         = 9
4     socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0) = 4
4     bind(4, {sa_family=AF_UNIX, sun_path="/tmp/mio-uds-4/l.sock"}, 24) = 0
4     listen(4, -1)                     = 0
4     epoll_ctl(3, EPOLL_CTL_ADD, 4, {events=EPOLLIN|EPOLLRDHUP|EPOLLET, data=0}) = 0
4     socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0) = 5
4     connect(5, {sa_family=AF_UNIX, sun_path="/tmp/mio-uds-4/l.sock"}, 24) = 0
4     write(1, "client peer_addr = Some(\"l.sock\""..., 34) = 34
4     epoll_pwait(3, [{events=EPOLLIN, data=0}], 8, 1000, NULL, 8) = 1
4     write(1, "event: events=IN data=0x0  => re"..., 39) = 39
4     accept4(4, {sa_family=AF_UNIX}, [110 => 2], SOCK_CLOEXEC|SOCK_NONBLOCK) = 6
4     write(1, "accept addr = (unnamed), is_unna"..., 43) = 43
4     accept4(4, 0xffffd9088cc0, [110], SOCK_CLOEXEC|SOCK_NONBLOCK) = -1 EAGAIN (Resource temporarily unavailable)
4     write(1, "accept again = Err(WouldBlock)\n", 31) = 31
4     epoll_ctl(3, EPOLL_CTL_ADD, 6, {events=EPOLLIN|EPOLLRDHUP|EPOLLET, data=0x1}) = 0
4     sendto(5, "ping", 4, MSG_NOSIGNAL, NULL, 0) = 4
4     epoll_pwait(3, [{events=EPOLLIN, data=0x1}], 8, 1000, NULL, 8) = 1
4     write(1, "event: events=IN data=0x1  => re"..., 39) = 39
4     recvfrom(6, "ping", 64, 0, NULL, NULL) = 4
4     write(1, "server read \"ping\"\n", 19) = 19
4     socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0) = 7
4     bind(7, {sa_family=AF_UNIX, sun_path="/tmp/mio-uds-4/r.sock"}, 24) = 0
4     epoll_ctl(3, EPOLL_CTL_ADD, 7, {events=EPOLLIN|EPOLLRDHUP|EPOLLET, data=0x2}) = 0
4     socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0) = 8
4     socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0) = 9
4     bind(9, {sa_family=AF_UNIX, sun_path="/tmp/mio-uds-4/s.sock"}, 24) = 0
4     sendto(8, "from unbound", 12, MSG_NOSIGNAL, {sa_family=AF_UNIX, sun_path="/tmp/mio-uds-4/r.sock"}, 24) = 12
4     sendto(9, "from bound", 10, MSG_NOSIGNAL, {sa_family=AF_UNIX, sun_path="/tmp/mio-uds-4/r.sock"}, 24) = 10
4     epoll_pwait(3, [{events=EPOLLIN, data=0x2}], 8, 1000, NULL, 8) = 1
4     write(1, "event: events=IN data=0x2  => re"..., 39) = 39
4     recvfrom(7, "from unbound", 64, 0, 0xffffd9088d30, [110 => 0]) = 12
4     write(1, "recv_from \"from unbound\": unname"..., 49) = 49
4     recvfrom(7, "from bound", 64, 0, {sa_family=AF_UNIX, sun_path="/tmp/mio-uds-4/s.sock"}, [110 => 24]) = 10
4     write(1, "recv_from \"from bound\": unnamed="..., 58) = 58
4     recvfrom(7, 0xffffd9088ee0, 64, 0, 0xffffd9088d30, [110]) = -1 EAGAIN (Resource temporarily unavailable)
4     socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0) = 10
4     bind(10, {sa_family=AF_UNIX, sun_path=@"mio-demo"}, 11) = 0
4     listen(10, -1)                    = 0
4     write(1, "abstract local_addr = \"mio-demo\""..., 44) = 44
4     +++ exited with 0 +++

pub fn new() -> io::Result<(Sender, Receiver)> {
    let fds = new_raw()?;
    // SAFETY: `new_raw` initialised the `fds` above.
    let r = unsafe { Receiver::from_raw_fd(fds[0]) };
    let w = unsafe { Sender::from_raw_fd(fds[1]) };
    Ok((w, r))
}

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

use exp_mio_net::{bools, fd_flags, raw};
use mio::unix::pipe;
use mio::{Events, Interest, Poll, Token};

fn main() -> std::io::Result<()> {
  println!("os={}", std::env::consts::OS);
  let mut poll = Poll::new()?;
  let mut events = Events::with_capacity(8);

  // 1. pipe::new: one write, one readable event
  let (mut tx, mut rx) = pipe::new()?;
  println!("tx: {}  rx: {}", fd_flags(tx.as_raw_fd()), fd_flags(rx.as_raw_fd()));
  poll.registry().register(&mut rx, Token(0), Interest::READABLE)?;
  tx.write_all(b"hello")?;
  poll.poll(&mut events, Some(Duration::from_secs(1)))?;
  for e in &events {
    println!("event: {}  => {}", raw(e), bools(e));
  }
  let mut buf = [0u8; 64];
  println!("read = {:?}", rx.read(&mut buf));
  println!("read again = {:?}", rx.read(&mut buf).map_err(|e| e.kind()));

  // 2. a child's stdout: blocking until set_nonblocking(true)
  let mut child = Command::new("/bin/echo").arg("from child").stdout(Stdio::piped()).spawn()?;
  let mut out = pipe::Receiver::from(child.stdout.take().unwrap());
  println!("child stdout before: {}", fd_flags(out.as_raw_fd()));
  out.set_nonblocking(true)?;
  println!("child stdout after:  {}", fd_flags(out.as_raw_fd()));
  poll.registry().register(&mut out, Token(1), Interest::READABLE)?;
  child.wait()?;
  poll.poll(&mut events, Some(Duration::from_secs(1)))?;
  for e in &events {
    println!("event: {}  => {}", raw(e), bools(e));
  }
  loop {
    match out.read(&mut buf) {
      Ok(0) => {
        println!("read = Ok(0): EOF");
        break;
      }
      Ok(n) => println!("read {:?}", String::from_utf8_lossy(&buf[..n])),
      Err(e) if e.kind() == ErrorKind::WouldBlock => {
        println!("read = WouldBlock");
        break;
      }
      Err(e) => return Err(e),
    }
  }
  Ok(())
}

os=macos
tx: nonblock=true cloexec=true  rx: nonblock=true cloexec=true
event: filter=READ flags=CLEAR fflags=0 data=5 udata=0x0  => readable
read = Ok(5)
read again = Err(WouldBlock)
child stdout before: nonblock=false cloexec=true
child stdout after:  nonblock=true cloexec=true
event: filter=READ flags=EOF|CLEAR fflags=0 data=11 udata=0x1  => readable read_closed
read "from child\n"
read = Ok(0): EOF

os=linux
tx: nonblock=true cloexec=true  rx: nonblock=true cloexec=true
event: events=IN data=0x0  => readable
read = Ok(5)
read again = Err(WouldBlock)
child stdout before: nonblock=false cloexec=true
child stdout after:  nonblock=true cloexec=true
event: events=IN|HUP data=0x1  => readable read_closed write_closed
read "from child\n"
read = Ok(0): EOF

4     write(1, "os=linux\n", 9)         = 9
4     pipe2([4, 5], O_NONBLOCK|O_CLOEXEC) = 0
4     write(1, "tx: nonblock=true cloexec=true  "..., 63) = 63
4     epoll_ctl(3, EPOLL_CTL_ADD, 4, {events=EPOLLIN|EPOLLRDHUP|EPOLLET, data=0}) = 0
4     write(5, "hello", 5)              = 5
4     epoll_pwait(3, [{events=EPOLLIN, data=0}], 8, 1000, NULL, 8) = 1
4     write(1, "event: events=IN data=0x0  => re"..., 39) = 39
4     read(4, "hello", 64)              = 5
4     write(1, "read = Ok(5)\n", 13)    = 13
4     read(4, 0xffffcfe06880, 64)       = -1 EAGAIN (Resource temporarily unavailable)
4     write(1, "read again = Err(WouldBlock)\n", 29) = 29
4     pipe2([6, 7], O_CLOEXEC)          = 0
4     pipe2([8, 9], O_CLOEXEC)          = 0
4     read(8, "", 4)                    = 0
4     write(1, "child stdout before: nonblock=fa"..., 49) = 49
4     ioctl(6, FIONBIO, [1])            = 0
4     write(1, "child stdout after:  nonblock=tr"..., 48) = 48
4     epoll_ctl(3, EPOLL_CTL_ADD, 6, {events=EPOLLIN|EPOLLRDHUP|EPOLLET, data=0x1}) = 0
5     write(1, "from child\n", 11)      = 11
5     +++ exited with 0 +++
4     --- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=5, si_uid=0, si_status=0, si_utime=0, si_stime=0} ---
4     epoll_pwait(3, [{events=EPOLLIN|EPOLLHUP, data=0x1}], 8, 1000, NULL, 8) = 1
4     write(1, "event: events=IN|HUP data=0x1  ="..., 68) = 68
4     read(6, "from child\n", 64)       = 11
4     write(1, "read \"from child\\n\"\n", 20) = 20
4     read(6, "", 64)                   = 0
4     write(1, "read = Ok(0): EOF\n", 18) = 18
4     +++ exited with 0 +++

event: filter=READ flags=CLEAR fflags=0 data=0 udata=0x3  => readable
take_error = Some(Os { code: 61, kind: ConnectionRefused, message: "Connection refused" })
recv = Err(WouldBlock)

event: events=ERR data=0x3  => error write_closed
take_error = Some(Os { code: 111, kind: ConnectionRefused, message: "Connection refused" })
recv = Err(WouldBlock)

4     socket(AF_INET, SOCK_DGRAM|SOCK_CLOEXEC, IPPROTO_IP) = 9
4     bind(9, {sa_family=AF_INET, sin_port=htons(0), sin_addr=inet_addr("127.0.0.1")}, 16) = 0
4     socket(AF_INET, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, IPPROTO_IP) = 9
4     bind(9, {sa_family=AF_INET, sin_port=htons(0), sin_addr=inet_addr("127.0.0.1")}, 16) = 0
4     connect(9, {sa_family=AF_INET, sin_port=htons(45515), sin_addr=inet_addr("127.0.0.1")}, 16) = 0
4     epoll_ctl(8, EPOLL_CTL_ADD, 9, {events=EPOLLIN|EPOLLRDHUP|EPOLLET, data=0x3}) = 0
4     sendto(9, "anyone?", 7, MSG_NOSIGNAL, NULL, 0) = 7
4     epoll_pwait(8, [{events=EPOLLERR, data=0x3}], 8, 1000, NULL, 8) = 1
4     write(1, "event: events=ERR data=0x3  => e"..., 50) = 50
4     getsockopt(9, SOL_SOCKET, SO_ERROR, [ECONNREFUSED], [4]) = 0
4     write(1, "take_error = Some(Os { code: 111"..., 92) = 92
4     recvfrom(9, 0xffffdcfa4fc0, 64, 0, NULL, NULL) = -1 EAGAIN (Resource temporarily unavailable)
4     write(1, "recv = Err(WouldBlock)\n", 23) = 23
4     +++ exited with 0 +++