#![allow(unsafe_code)]
use core::fmt;
use std::fs::File;
use std::io;
use std::os::fd::{AsFd, BorrowedFd, IntoRawFd};
use std::os::unix::io::{FromRawFd, RawFd};
#[cfg(target_os = "linux")]
use std::path::Path;
pub(crate) const RESERVED_FD_FLOOR: RawFd = 3;
pub fn adoptable_fd(fd: RawFd) -> Result<(), SysError> {
if fd < RESERVED_FD_FLOOR {
return Err(SysError::ReservedFd(fd));
}
nix::fcntl::fcntl(fd, nix::fcntl::FcntlArg::F_GETFD).map_err(|errno| SysError::BadFd {
fd,
errno: errno.to_string(),
})?;
Ok(())
}
pub unsafe fn adopt_fd(fd: RawFd) -> Result<File, SysError> {
adoptable_fd(fd)?;
Ok(unsafe { File::from_raw_fd(fd) })
}
pub fn adopt_handover_fd(fd: RawFd) -> Result<File, SysError> {
unsafe { adopt_fd(fd) }
}
#[derive(Debug)]
pub(crate) struct OpenFd(RawFd);
impl OpenFd {
pub(crate) fn new(fd: RawFd) -> Result<Self, SysError> {
adoptable_fd(fd)?;
Ok(Self(fd))
}
}
impl AsFd for OpenFd {
fn as_fd(&self) -> BorrowedFd<'_> {
unsafe { BorrowedFd::borrow_raw(self.0) }
}
}
pub(crate) fn duplicate_fd(fd: RawFd) -> io::Result<RawFd> {
nix::fcntl::fcntl(fd, nix::fcntl::FcntlArg::F_GETFD)?;
let borrowed = unsafe { BorrowedFd::borrow_raw(fd) };
Ok(borrowed.try_clone_to_owned()?.into_raw_fd())
}
pub(crate) fn is_listening_socket(socket: &impl AsFd) -> bool {
#[cfg(target_vendor = "apple")]
{
use std::os::fd::AsRawFd;
const TCPS_LISTEN: u8 = 1;
let mut info = core::mem::MaybeUninit::<nix::libc::tcp_connection_info>::zeroed();
let mut len = nix::libc::socklen_t::try_from(size_of::<nix::libc::tcp_connection_info>())
.unwrap_or(nix::libc::socklen_t::MAX);
let read = unsafe {
nix::libc::getsockopt(
socket.as_fd().as_raw_fd(),
nix::libc::IPPROTO_TCP,
nix::libc::TCP_CONNECTION_INFO,
info.as_mut_ptr().cast(),
&raw mut len,
)
};
read == 0 && unsafe { info.assume_init() }.tcpi_state == TCPS_LISTEN
}
#[cfg(not(target_vendor = "apple"))]
{
nix::sys::socket::getsockopt(socket, nix::sys::socket::sockopt::AcceptConn).unwrap_or(false)
}
}
#[cfg(target_os = "linux")]
pub(crate) fn open_resolving_no_symlinks(
path: &Path,
flags: nix::fcntl::OFlag,
mode: nix::sys::stat::Mode,
) -> io::Result<File> {
use nix::fcntl::{OpenHow, ResolveFlag, openat2};
let how = OpenHow::new()
.flags(flags)
.mode(mode)
.resolve(ResolveFlag::RESOLVE_NO_SYMLINKS);
let fd = openat2(nix::libc::AT_FDCWD, path, how)?;
Ok(unsafe { File::from_raw_fd(fd) })
}
pub(crate) struct ListenEnv {
_block: Vec<u8>,
table: Vec<*mut core::ffi::c_char>,
pid_slot: *mut u8,
}
unsafe impl Send for ListenEnv {}
unsafe impl Sync for ListenEnv {}
const PID_SLOT_LEN: usize = 11;
impl ListenEnv {
pub(crate) fn new(vars: &std::collections::BTreeMap<String, String>) -> io::Result<Self> {
let mut block = Vec::new();
let mut starts = Vec::with_capacity(vars.len() + 1);
for (key, value) in vars {
if key.is_empty() || key.contains('=') || key.contains('\0') || value.contains('\0') {
return Err(io::Error::new(
io::ErrorKind::InvalidInput,
format!("environment variable `{key}` cannot be passed to a child"),
));
}
starts.push(block.len());
block.extend_from_slice(key.as_bytes());
block.push(b'=');
block.extend_from_slice(value.as_bytes());
block.push(0);
}
starts.push(block.len());
block.extend_from_slice(b"LISTEN_PID=");
let slot_at = block.len();
block.resize(slot_at + PID_SLOT_LEN, 0);
let base = block.as_mut_ptr();
let mut table: Vec<*mut core::ffi::c_char> = starts
.iter()
.map(|at| unsafe { base.add(*at) }.cast())
.collect();
table.push(core::ptr::null_mut());
let pid_slot = unsafe { base.add(slot_at) };
Ok(Self {
_block: block,
table,
pid_slot,
})
}
fn install(&mut self) -> io::Result<()> {
let pid = unsafe { nix::libc::getpid() }.unsigned_abs();
let mut reversed = [0u8; PID_SLOT_LEN];
let (mut rest, mut len) = (pid, 0);
loop {
reversed[len] = b'0' + (rest % 10) as u8;
rest /= 10;
len += 1;
if rest == 0 {
break;
}
}
debug_assert!(len < PID_SLOT_LEN, "a u32 is ten digits at most");
for (at, digit) in reversed[..len].iter().rev().enumerate() {
unsafe { self.pid_slot.add(at).write(*digit) };
}
unsafe { self.pid_slot.add(len).write(0) };
unsafe { *environ_slot() = self.table.as_mut_ptr() };
Ok(())
}
}
#[cfg(target_vendor = "apple")]
unsafe fn environ_slot() -> *mut *mut *mut core::ffi::c_char {
unsafe { nix::libc::_NSGetEnviron() }
}
#[cfg(not(target_vendor = "apple"))]
unsafe fn environ_slot() -> *mut *mut *mut core::ffi::c_char {
unsafe extern "C" {
static mut environ: *mut *mut core::ffi::c_char;
}
&raw mut environ
}
pub(crate) fn set_listen_env(command: &mut std::process::Command, mut env: ListenEnv) {
use std::os::unix::process::CommandExt as _;
unsafe { command.pre_exec(move || env.install()) };
}
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum SysError {
ReservedFd(RawFd),
BadFd {
fd: RawFd,
errno: String,
},
}
impl fmt::Display for SysError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::ReservedFd(fd) if *fd < 0 => {
write!(f, "fd {fd} is negative and cannot name a descriptor")
}
Self::ReservedFd(fd) => {
write!(f, "fd {fd} is reserved for stdio and cannot be adopted")
}
Self::BadFd { fd, errno } => {
write!(
f,
"fd {fd} is not an open descriptor in this process: {errno}"
)
}
}
}
}
impl core::error::Error for SysError {}
#[cfg(test)]
mod tests {
use super::*;
use std::io::Read;
use std::os::unix::io::{AsRawFd, IntoRawFd};
#[test]
fn a_listening_tcp_socket_reads_as_one() {
let listening = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
assert!(is_listening_socket(&listening));
}
#[test]
fn a_bound_tcp_socket_that_never_listened_does_not_read_as_one() {
use nix::sys::socket::{
AddressFamily, SockFlag, SockType, SockaddrIn, bind, socket as open_socket,
};
let bound = open_socket(
AddressFamily::Inet,
SockType::Stream,
SockFlag::empty(),
None,
)
.unwrap();
bind(
bound.as_raw_fd(),
&SockaddrIn::from(std::net::SocketAddrV4::new(
std::net::Ipv4Addr::LOCALHOST,
0,
)),
)
.unwrap();
assert!(!is_listening_socket(&bound));
}
#[test]
fn a_connected_socket_and_a_file_do_not() {
let (connected, _peer) = std::os::unix::net::UnixStream::pair().unwrap();
let file = tempfile::tempfile().unwrap();
assert!(!is_listening_socket(&connected));
assert!(!is_listening_socket(&file));
}
#[test]
fn a_real_inherited_descriptor_is_adopted_and_owned() {
let (parent, child) = std::os::unix::net::UnixStream::pair().unwrap();
let fd = child.into_raw_fd();
{
let mut adopted = unsafe { adopt_fd(fd) }.unwrap();
std::io::Write::write_all(&mut adopted, b"hello\n").unwrap();
} let mut read = String::new();
let mut parent = parent;
parent.read_to_string(&mut read).unwrap();
assert_eq!(
read, "hello\n",
"EOF proves the adopted descriptor was closed on drop"
);
}
#[test]
fn stdio_numbers_are_refused() {
for fd in 0..3 {
let result = unsafe { adopt_fd(fd) };
assert_eq!(result.unwrap_err(), SysError::ReservedFd(fd));
}
}
#[test]
fn a_negative_fd_is_refused_with_an_accurate_message() {
let err = unsafe { adopt_fd(-1) }.unwrap_err();
assert_eq!(err, SysError::ReservedFd(-1));
assert!(
err.to_string().contains("negative"),
"a negative fd is not \"reserved for stdio\": {err}"
);
}
#[test]
fn a_closed_descriptor_is_refused_instead_of_adopted() {
const PROBE_FD: RawFd = 2048;
let (a, _b) = std::os::unix::net::UnixStream::pair().unwrap();
let parked = nix::fcntl::fcntl(a.as_raw_fd(), nix::fcntl::FcntlArg::F_DUPFD(PROBE_FD))
.expect("duplicating onto a high fd number must succeed");
assert!(
parked >= PROBE_FD,
"F_DUPFD must return a number at or above its floor, got {parked}"
);
drop(unsafe { adopt_fd(parked) }.unwrap()); let second = unsafe { adopt_fd(parked) };
assert!(matches!(second, Err(SysError::BadFd { .. })));
}
#[test]
fn a_fd_this_process_never_owned_is_refused() {
let err = unsafe { adopt_fd(4096) }.unwrap_err();
assert!(
matches!(err, SysError::BadFd { fd: 4096, .. }),
"a fd this process never owned must be refused as BadFd: {err:?}"
);
}
#[test]
fn a_listen_child_reads_its_own_pid_in_a_block_that_replaces_the_environment() {
let vars = std::collections::BTreeMap::from([("FOO".to_string(), "bar baz".to_string())]);
let mut command = std::process::Command::new("/bin/sh");
command.args([
"-c",
r#"printf '%s|%s|%s|[%s]' "$LISTEN_PID" "$$" "$FOO" "$HOME""#,
]);
set_listen_env(&mut command, ListenEnv::new(&vars).unwrap());
let out = command.output().unwrap();
let text = String::from_utf8(out.stdout).unwrap();
let parts: Vec<&str> = text.split('|').collect();
assert_eq!(
parts[0], parts[1],
"LISTEN_PID is the child's own pid: {text}"
);
assert!(parts[0].parse::<u32>().is_ok(), "{text}");
assert_eq!((parts[2], parts[3]), ("bar baz", "[]"), "{text}");
}
#[test]
fn two_children_of_one_block_each_read_their_own_pid() {
let mut pids = Vec::new();
for _ in 0..2 {
let mut command = std::process::Command::new("/bin/sh");
command.args(["-c", r#"printf '%s' "$LISTEN_PID""#]);
set_listen_env(&mut command, ListenEnv::new(&Default::default()).unwrap());
let out = command.output().unwrap();
pids.push(String::from_utf8(out.stdout).unwrap());
}
assert_ne!(pids[0], pids[1]);
}
#[test]
fn a_name_or_value_a_command_would_refuse_is_refused_up_front() {
for (key, value) in [("", "v"), ("A=B", "v"), ("A\0B", "v"), ("A", "v\0")] {
let vars = std::collections::BTreeMap::from([(key.to_string(), value.to_string())]);
let error = ListenEnv::new(&vars).err().expect("refused");
assert_eq!(error.kind(), io::ErrorKind::InvalidInput, "{key:?}");
}
}
#[cfg(target_os = "linux")]
#[test]
fn a_symlink_in_the_path_is_refused_by_the_syscall_itself() {
use nix::fcntl::OFlag;
use nix::sys::stat::Mode;
let dir = tempfile::tempdir().unwrap();
let real = dir.path().join("real");
std::fs::create_dir(&real).unwrap();
std::os::unix::fs::symlink(&real, dir.path().join("logs")).unwrap();
let flags = OFlag::O_WRONLY | OFlag::O_CREAT | OFlag::O_CLOEXEC;
let mode = Mode::from_bits_truncate(0o600);
let refused = open_resolving_no_symlinks(&dir.path().join("logs/web-out.log"), flags, mode);
assert_eq!(
refused.unwrap_err().raw_os_error(),
Some(nix::libc::ELOOP),
"a link met mid-path must be ELOOP"
);
assert!(!real.join("web-out.log").exists());
open_resolving_no_symlinks(&real.join("web-out.log"), flags, mode)
.expect("the same file by its real path opens");
}
}