Function sock_select

crates/stdlib/src/socket.rs:2766–2822

returns true if timed out

(
        sock: &Socket,
        kind: SelectKind,
        interval: Option<Duration>,
    )

    /// returns true if timed out
    pub(crate) fn sock_select(
        sock: &Socket,
        kind: SelectKind,
        interval: Option<Duration>,
    ) -> io::Result<bool> {
        #[cfg(unix)]
        {
            use nix::poll::*;
            use std::os::fd::AsFd;
            let events = match kind {
                SelectKind::Read => PollFlags::POLLIN,
                SelectKind::Write => PollFlags::POLLOUT,
                SelectKind::Connect => PollFlags::POLLOUT | PollFlags::POLLERR,
            };
            let mut pollfd = [PollFd::new(sock.as_fd(), events)];
            let timeout = match interval {
                Some(d) => d.try_into().unwrap_or(PollTimeout::MAX),
                None => PollTimeout::NONE,
            };
            let ret = poll(&mut pollfd, timeout)?;
            Ok(ret == 0)
        }
        #[cfg(windows)]
        {
            use crate::select;

            let fd = sock_fileno(sock);

            let mut reads = select::FdSet::new();
            let mut writes = select::FdSet::new();
            let mut errs = select::FdSet::new();

            let fd = fd as usize;
            match kind {
                SelectKind::Read => reads.insert(fd),
                SelectKind::Write => writes.insert(fd),
                SelectKind::Connect => {
                    writes.insert(fd);
                    errs.insert(fd);
                }
            }

            let mut interval = interval.map(|dur| select::timeval {
                tv_sec: dur.as_secs() as _,
                tv_usec: dur.subsec_micros() as _,
            });

            select::select(
                fd as i32 + 1,
                &mut reads,
                &mut writes,
                &mut errs,
                interval.as_mut(),
            )
            .map(|ret| ret == 0)
        }
    }