109 lines
4.0 KiB
Rust
109 lines
4.0 KiB
Rust
|
//! File descriptor polling utilities for timeout support.
|
||
|
|
|
||
|
|
use std::os::fd::BorrowedFd;
|
||
|
|
use std::time::{Duration, Instant};
|
||
|
|
|
||
|
|
use nix::poll::{PollFd, PollFlags, PollTimeout, poll};
|
||
|
|
|
||
|
|
use crate::openfiles::OpenFile;
|
||
|
|
|
||
|
|
/// Polls an open file for input readability with a timeout.
|
||
|
|
///
|
||
|
|
/// Returns `Ok(true)` if data is available for reading, `Ok(false)` if the timeout
|
||
|
|
/// elapsed without data becoming available.
|
||
|
|
///
|
||
|
|
/// For regular files, always returns `Ok(true)` immediately since they're always
|
||
|
|
/// "ready" (matching bash behavior where `-t` has no effect on regular files).
|
||
|
|
///
|
||
|
|
/// # Arguments
|
||
|
|
///
|
||
|
|
/// * `file` - The open file to poll.
|
||
|
|
/// * `timeout` - Maximum time to wait. Use `Duration::ZERO` to check without blocking.
|
||
|
|
///
|
||
|
|
/// # Errors
|
||
|
|
///
|
||
|
|
/// Returns an error if polling fails or the file descriptor cannot be borrowed.
|
||
|
|
pub fn poll_for_input(file: &OpenFile, timeout: Duration) -> std::io::Result<bool> {
|
||
|
|
let fd = file
|
||
|
|
.try_borrow_as_fd()
|
||
|
|
.map_err(|e| std::io::Error::other(e.to_string()))?;
|
||
|
|
|
||
|
|
// Regular files are always ready - timeout has no effect (bash behavior).
|
||
|
|
if is_regular_file(fd) {
|
||
|
|
return Ok(true);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Convert timeout to deadline for accurate time tracking across EINTR retries.
|
||
|
|
let deadline = if timeout.is_zero() {
|
||
|
|
// For zero timeout, use current instant so first check sees zero remaining.
|
||
|
|
Some(Instant::now())
|
||
|
|
} else {
|
||
|
|
Some(Instant::now() + timeout)
|
||
|
|
};
|
||
|
|
|
||
|
|
poll_fd_for_input(fd, deadline)
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Polls a file descriptor for input readability with a deadline.
|
||
|
|
///
|
||
|
|
/// Returns `Ok(true)` if data is available, `Ok(false)` if deadline passed.
|
||
|
|
///
|
||
|
|
/// # Arguments
|
||
|
|
///
|
||
|
|
/// * `fd` - File descriptor to poll
|
||
|
|
/// * `deadline` - Optional deadline; `None` indicates no deadline.
|
||
|
|
fn poll_fd_for_input(fd: BorrowedFd<'_>, deadline: Option<Instant>) -> std::io::Result<bool> {
|
||
|
|
let mut poll_fds = [PollFd::new(fd, PollFlags::POLLIN)];
|
||
|
|
let mut first_iteration = true;
|
||
|
|
|
||
|
|
loop {
|
||
|
|
// Calculate remaining time on each iteration to handle EINTR correctly.
|
||
|
|
let timeout_ms = match deadline {
|
||
|
|
Some(d) => {
|
||
|
|
let remaining = d.saturating_duration_since(Instant::now());
|
||
|
|
// On first iteration, always do at least one poll even with zero timeout.
|
||
|
|
// This allows `-t 0` to check if input is immediately available.
|
||
|
|
if remaining.is_zero() && !first_iteration {
|
||
|
|
return Ok(false); // Deadline passed after initial poll.
|
||
|
|
}
|
||
|
|
i32::try_from(remaining.as_millis()).unwrap_or(i32::MAX)
|
||
|
|
}
|
||
|
|
None => -1, // Block indefinitely.
|
||
|
|
};
|
||
|
|
first_iteration = false;
|
||
|
|
let poll_timeout = PollTimeout::try_from(timeout_ms).unwrap_or(PollTimeout::MAX);
|
||
|
|
|
||
|
|
match poll(&mut poll_fds, poll_timeout) {
|
||
|
|
Ok(0) => return Ok(false), // Timeout
|
||
|
|
Ok(_) => {
|
||
|
|
let revents = poll_fds[0].revents().unwrap_or(PollFlags::empty());
|
||
|
|
// POLLIN means data available. POLLHUP/POLLERR without POLLIN means
|
||
|
|
// EOF/error - return true so caller reads and gets the proper result.
|
||
|
|
return Ok(
|
||
|
|
revents.intersects(PollFlags::POLLIN | PollFlags::POLLHUP | PollFlags::POLLERR)
|
||
|
|
);
|
||
|
|
}
|
||
|
|
Err(nix::errno::Errno::EINTR) => (), // Retry on signal with recalculated timeout.
|
||
|
|
Err(e) => return Err(std::io::Error::from_raw_os_error(e as i32)),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Checks if a file descriptor refers to a regular file.
|
||
|
|
///
|
||
|
|
/// Regular files are always "ready" for reading (poll has no effect).
|
||
|
|
///
|
||
|
|
/// # Arguments
|
||
|
|
///
|
||
|
|
/// * `fd` - File descriptor to check
|
||
|
|
fn is_regular_file(fd: BorrowedFd<'_>) -> bool {
|
||
|
|
match nix::sys::stat::fstat(fd) {
|
||
|
|
Ok(stat) => {
|
||
|
|
use nix::sys::stat::{SFlag, mode_t};
|
||
|
|
mode_t::try_from(stat.st_mode)
|
||
|
|
.is_ok_and(|mode| SFlag::from_bits_truncate(mode).contains(SFlag::S_IFREG))
|
||
|
|
}
|
||
|
|
Err(_) => false,
|
||
|
|
}
|
||
|
|
}
|