Rust and File Descriptors

I'm working on a program in Rust that for various reasons^[1] needs to pass data to a child process using a file descriptor^[2].

This is an odd pattern that exists in some old Unix programs. Normally, a program will accept input in the form of command-line arguments, files, or standard input. But some programs will also take input on an arbitrary file descriptor that you provide them (and tell them about with a command-line argument).

How does one pass data through a file descriptor to another program, you ask? Well, the Unix way of running a child process is to first create a copy of the current process (the fork system call), and then replace it with whatever other program you want (the exec system call). In the course of doing this, the child inherits quite a lot of stuff from the parent, including any file descriptors open at the time of the fork, unless the child closes them before doing its exec.

So doing this should be easy, right? Open a file (or make a pipe, or whatever), get its file descriptor number, fork and exec, passing the number as a command-line argument.

Well, not quite. Rust, being a safe-by-default language, sensibly creates all file descriptors with the FD_CLOEXEC flag, which means they automatically close on an exec system call, without needing to be explicitly closed. This is usually what you want; you don't generally want to be passing handles to all your open files to whatever random process you run. But Rust doesn't provide a way to turn this off.

Not out of the box, at least. But it's okay! Rust makes interoperating with C code really easy, and in fact there's a crate available with bindings to most of libc out there. So it's a simple matter of using the fcntl system call to turn that flag off of whatever file descriptor you want your child to inherit.

I made a nice utility class that demonstrates this. It's called InheritablePipe, and it uses the libc crate to call the pipe system call, which also doesn't seem to be available in the standard library.

The other nifty thing it does is to take the parent-end of the pipe and create a regular old Rust std::fs::File instance out of it by using the std::os::unix::io::FromRawFd trait which is helpfully implemented by File. Yeah, it's not actually backed by anything on the filesystem, but Rust doesn't really care; it just uses the file descriptor as if it were a real file.