`EPERM` on `pidfd_getfd` with socket - linux

Question

I want to transfer a socket between 2 unrelated processes.
Process 1 creates and listens on the socket, it then attaches shared memory and stores the socket file descriptor in this shared memory and awaits on signal SIGUSR1.
Process 2 attaches to the shared, attempts to transfer the file descriptor, then sends the signal SIGUSR1.
On calling pidfd_getfd in process 2, I get the error EPERM.
Process 1 output
fd: Data { socket: 3, pid: Pid(167046) }
Process 2 output
fd: Data { socket: 3, pid: Pid(167046) }
thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: EPERM', src/bin/receive.rs:44:74
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
Process 1
use std::os::fd::{AsRawFd, RawFd};
use nix::fcntl;
use nix::sys::{
mman, signal,
socket::{self, SockaddrLike},
};
use nix::unistd::{ftruncate, Pid};
#[derive(Debug)]
#[repr(C)]
struct Data {
socket: RawFd,
pid: Pid,
}
const PATH: &str = "/some_arbitrary_path_3";
fn main() {
// Create a TCP socket listening on localhost:8080
// ---------------------------------------------------------------------------------------------
let socket = socket::socket(
socket::AddressFamily::Inet6,
socket::SockType::Stream,
socket::SockFlag::empty(),
None,
)
.unwrap();
let local_host = libc::in6_addr {
s6_addr: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
};
let addr = libc::sockaddr_in6 {
sin6_family: u16::try_from(libc::AF_INET6).unwrap(),
sin6_port: 8765,
sin6_flowinfo: u32::default(),
sin6_addr: local_host,
sin6_scope_id: u32::default(),
};
let addr = unsafe {
socket::SockaddrIn6::from_raw(
std::ptr::addr_of!(addr).cast(),
Some(u32::try_from(std::mem::size_of::<libc::sockaddr_in6>()).unwrap()),
)
.unwrap()
};
socket::bind(socket, &addr).unwrap();
socket::listen(socket, 64).unwrap();
// Store socket file descriptor in shared memory
// ---------------------------------------------------------------------------------------------
let shared_memory_object = std::mem::ManuallyDrop::new(
mman::shm_open(
PATH,
fcntl::OFlag::O_RDWR | fcntl::OFlag::O_CREAT | fcntl::OFlag::O_EXCL,
// TODO: Restrict these to minimum (likely read+write group)
// Uses full permissions
nix::sys::stat::Mode::all(),
)
.unwrap(),
);
let length = std::mem::size_of::<Data>();
ftruncate(shared_memory_object.as_raw_fd(), length as i64).unwrap();
let mapped_shared_memory = unsafe {
mman::mmap(
None,
std::num::NonZeroUsize::new(length).unwrap(),
mman::ProtFlags::PROT_WRITE | mman::ProtFlags::PROT_READ,
mman::MapFlags::MAP_SHARED,
Some(&*shared_memory_object),
0,
)
.unwrap()
};
let ptr = mapped_shared_memory.cast::<Data>();
let pid = Pid::this();
unsafe {
std::ptr::write(ptr, Data { socket, pid });
}
println!("fd: {:?}", unsafe { &*ptr });
// Await SIGUSR1
// ---------------------------------------------------------------------------------------------
let mut sigset = signal::SigSet::empty();
sigset.add(signal::Signal::SIGUSR1);
sigset.wait().unwrap();
}
Process 2
use std::os::fd::AsRawFd;
use std::os::fd::RawFd;
use nix::fcntl;
use nix::sys::{mman, pidfd, signal::Signal};
use nix::unistd::Pid;
#[derive(Debug)]
#[repr(C)]
struct Data {
socket: RawFd,
pid: Pid,
}
const PATH: &str = "/some_arbitrary_path_3";
fn main() {
// Get shared memory object.
let shared_memory_object = std::mem::ManuallyDrop::new(
mman::shm_open(PATH, fcntl::OFlag::O_RDWR, nix::sys::stat::Mode::all()).unwrap(),
);
let length = std::mem::size_of::<Data>();
// Map shared memory.
let mapped_shared_memory = unsafe {
mman::mmap(
None,
std::num::NonZeroUsize::new(length).unwrap(),
mman::ProtFlags::PROT_WRITE | mman::ProtFlags::PROT_READ,
mman::MapFlags::MAP_SHARED,
Some(&*shared_memory_object),
0,
)
.unwrap()
};
// Read data.
let ptr = mapped_shared_memory.cast::<Data>();
let data = unsafe { &mut *ptr };
println!("fd: {:?}", data);
// Transfer socket file descriptor.
let pid_fd = pidfd::pid_open(data.pid, false).unwrap();
let new_socket = pidfd::pidfd_getfd(pid_fd.as_raw_fd(), data.socket).unwrap();
data.socket = new_socket.as_raw_fd();
// Send SIGUSR1
pidfd::pidfd_send_signal(pid_fd, Signal::SIGUSR1, None).unwrap();
}
Dependencies
The dependencies I'm using here are:
nix = { git = "https://github.com/JonathanWoollett-Light/nix", rev = "747b7abf9e2dd57d6e52b7d9288f836780f0ec15" }
libc = "0.2.139" # https://crates.io/crates/libc/0.2.139

Answer 1

There are a few ways to circumvent this.
Run the process as privileged (e.g. sudo).
Use ptrace in the ancestor to give the successor permissions. While this can work, it is very tricky and it is using an extremely over-complicated tool for what we are doing here.
Send the file descriptor over a UDS (Unix Domain Socket), this works, but sending file descriptors over a UDS is ugly.
Enable the SO_REUSEPORT option on the socket such that the new process can use the socket without needing to transfer the file descriptor. This is my preferred solution.