use std::ffi::c_void;
use std::os::fd::RawFd;
#[repr(C)]
struct IoVec {
base: *mut c_void,
len: usize,
}
#[repr(C)]
struct MsgHdr {
name: *mut c_void,
namelen: u32,
iov: *mut IoVec,
iovlen: usize,
control: *mut c_void,
controllen: usize,
flags: i32,
}
#[repr(C)]
struct CmsgHdr {
len: usize,
level: i32,
kind: i32,
}
const SOL_SOCKET: i32 = 1;
const SCM_RIGHTS: i32 = 1;
const CONTROL_CAPACITY: usize = 256;
unsafe extern "C" {
fn recvmsg(fd: RawFd, msg: *mut MsgHdr, flags: i32) -> isize;
fn close(fd: RawFd) -> i32;
fn dup(fd: RawFd) -> RawFd;
}
const fn align(len: usize) -> usize {
let a = std::mem::align_of::<usize>();
(len + a - 1) & !(a - 1)
}
pub struct Received {
pub bytes: usize,
pub fds: Vec<RawFd>,
}
pub fn recv_with_fds(fd: RawFd, buffer: &mut [u8]) -> std::io::Result<Option<Received>> {
let mut control = [0u8; CONTROL_CAPACITY];
let mut iov = IoVec {
base: buffer.as_mut_ptr() as *mut c_void,
len: buffer.len(),
};
let mut header = MsgHdr {
name: std::ptr::null_mut(),
namelen: 0,
iov: &mut iov,
iovlen: 1,
control: control.as_mut_ptr() as *mut c_void,
controllen: control.len(),
flags: 0,
};
let n = unsafe { recvmsg(fd, &mut header, 0) };
if n < 0 {
let e = std::io::Error::last_os_error();
if e.kind() == std::io::ErrorKind::Interrupted {
return Ok(None);
}
return Err(e);
}
let mut fds = Vec::new();
let mut offset = 0usize;
while offset + std::mem::size_of::<CmsgHdr>() <= header.controllen {
let cmsg = unsafe { &*(control.as_ptr().add(offset) as *const CmsgHdr) };
if cmsg.len < std::mem::size_of::<CmsgHdr>() || offset + cmsg.len > header.controllen {
break; }
if cmsg.level == SOL_SOCKET && cmsg.kind == SCM_RIGHTS {
let payload = cmsg.len - std::mem::size_of::<CmsgHdr>();
let count = payload / std::mem::size_of::<RawFd>();
let data = unsafe {
control
.as_ptr()
.add(offset + std::mem::size_of::<CmsgHdr>())
};
for i in 0..count {
let raw = unsafe { std::ptr::read_unaligned(data.cast::<RawFd>().add(i)) };
fds.push(raw);
}
}
offset += align(cmsg.len);
}
Ok(Some(Received {
bytes: n as usize,
fds,
}))
}
pub unsafe fn close_raw(fd: RawFd) {
unsafe { close(fd) };
}
pub fn duplicate(fd: RawFd) -> std::io::Result<RawFd> {
let duplicate = unsafe { dup(fd) };
if duplicate < 0 {
Err(std::io::Error::last_os_error())
} else {
Ok(duplicate)
}
}
#[derive(Default)]
pub struct Pending {
queue: std::collections::VecDeque<RawFd>,
}
impl Pending {
pub fn push(&mut self, fds: impl IntoIterator<Item = RawFd>) {
self.queue.extend(fds);
}
pub fn take(&mut self, count: usize) -> Vec<RawFd> {
(0..count).filter_map(|_| self.queue.pop_front()).collect()
}
pub fn len(&self) -> usize {
self.queue.len()
}
pub fn is_empty(&self) -> bool {
self.queue.is_empty()
}
}
impl Drop for Pending {
fn drop(&mut self) {
for fd in self.queue.drain(..) {
unsafe { close(fd) };
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn control_messages_are_word_aligned() {
let word = std::mem::size_of::<usize>();
assert_eq!(align(1), word);
assert_eq!(align(word), word);
assert_eq!(align(word + 1), word * 2);
}
#[test]
fn the_headers_match_the_kernel_abi() {
assert_eq!(
std::mem::size_of::<CmsgHdr>(),
std::mem::size_of::<usize>() + 2 * std::mem::size_of::<i32>(),
);
assert_eq!(
std::mem::align_of::<CmsgHdr>(),
std::mem::align_of::<usize>()
);
assert_eq!(
std::mem::size_of::<IoVec>(),
std::mem::size_of::<*mut c_void>() + std::mem::size_of::<usize>(),
);
}
#[test]
fn a_message_takes_only_what_it_declared() {
let mut pending = Pending::default();
pending.push([10, 11, 12]);
assert_eq!(pending.len(), 3);
assert_eq!(pending.take(0), Vec::<RawFd>::new(), "a message with none");
assert_eq!(pending.take(1), vec![10], "takes from the front");
assert_eq!(pending.take(2), vec![11, 12]);
assert!(pending.is_empty());
assert_eq!(pending.take(4), Vec::<RawFd>::new());
assert!(
pending.is_empty(),
"or dropping it would close 10, 11 and 12"
);
}
#[test]
fn descriptors_come_out_in_the_order_they_arrived() {
let mut pending = Pending::default();
pending.push([1, 2]);
pending.push([3]);
assert_eq!(pending.take(3), vec![1, 2, 3]);
assert!(pending.is_empty(), "or dropping it would close 1, 2 and 3");
}
#[cfg(target_os = "linux")]
#[test]
fn duplicate_creates_an_independent_descriptor() {
use std::os::fd::{AsRawFd, FromRawFd};
let (left, _right) = std::os::unix::net::UnixStream::pair().unwrap();
let duplicate = duplicate(left.as_raw_fd()).unwrap();
let duplicate_file = unsafe { std::fs::File::from_raw_fd(duplicate) };
drop(duplicate_file);
assert!(left.peer_addr().is_ok());
}
#[test]
fn duplicate_rejects_invalid_descriptors() {
assert!(duplicate(-1).is_err());
}
}