Merge pull request #4 from sfackler/unix-socket

Unix socket support

Author: alexcrichton

.travis.yml

@@ -6,7 +6,7 @@ before_script:
   - pip install 'travis-cargo<0.2' --user && export PATH=$HOME/.local/bin:$PATH
 script:
   - cargo test
-  - cargo test --features reuseport
+  - cargo test --features "reuseport unix pair"
   - cargo doc --no-deps --all-features
 after_success:
   - travis-cargo --only nightly doc-upload

Cargo.toml

@@ -12,6 +12,9 @@ Utilities for handling networking sockets with a maximal amount of configuration
 possible intended.
 """
 
+[package.metadata.docs.rs]
+all-features = true
+
 [target."cfg(windows)".dependencies]
 ws2_32-sys = "0.2"
 winapi = "0.2"
@@ -21,5 +24,10 @@ kernel32-sys = "0.2"
 cfg-if = "0.1"
 libc = "0.2.14"
 
+[dev-dependencies]
+tempdir = "0.3"
+
 [features]
 reuseport = []
+pair = []
+unix = []

src/lib.rs

@@ -44,6 +44,8 @@
 #[cfg(windows)] extern crate winapi;
 #[cfg(windows)] extern crate ws2_32;
 
+#[cfg(test)] extern crate tempdir;
+
 use utils::NetInt;
 
 #[cfg(unix)] use libc::{sockaddr_storage, socklen_t};

src/sockaddr.rs

@@ -1,7 +1,7 @@
-use std::net::{SocketAddrV4, SocketAddrV6, SocketAddr};
+use std::fmt;
 use std::mem;
+use std::net::{SocketAddrV4, SocketAddrV6, SocketAddr};
 use std::ptr;
-use std::fmt;
 
 #[cfg(unix)]
 use libc::{sockaddr, sockaddr_storage, sockaddr_in, sockaddr_in6, sa_family_t, socklen_t, AF_INET,
@@ -40,6 +40,61 @@ impl SockAddr {
         }
     }
 
+    /// Constructs a `SockAddr` with the family `AF_UNIX` and the provided path.
+    ///
+    /// This function is only available on Unix when the `unix` feature is
+    /// enabled.
+    ///
+    /// # Failure
+    ///
+    /// Returns an error if the path is longer than `SUN_LEN`.
+    #[cfg(all(unix, feature = "unix"))]
+    pub fn unix<P>(path: P) -> ::std::io::Result<SockAddr>
+        where P: AsRef<::std::path::Path>
+    {
+        use std::cmp::Ordering;
+        use std::io;
+        use std::os::unix::ffi::OsStrExt;
+        use libc::{sockaddr_un, AF_UNIX, c_char};
+
+        unsafe {
+            let mut addr = mem::zeroed::<sockaddr_un>();
+            addr.sun_family = AF_UNIX as sa_family_t;
+
+            let bytes = path.as_ref().as_os_str().as_bytes();
+
+            match (bytes.get(0), bytes.len().cmp(&addr.sun_path.len())) {
+                // Abstract paths don't need a null terminator
+                (Some(&0), Ordering::Greater) => {
+                    return Err(io::Error::new(io::ErrorKind::InvalidInput,
+                                            "path must be no longer than SUN_LEN"));
+                }
+                (Some(&0), _) => {}
+                (_, Ordering::Greater) | (_, Ordering::Equal) => {
+                    return Err(io::Error::new(io::ErrorKind::InvalidInput,
+                                            "path must be shorter than SUN_LEN"));
+                }
+                _ => {}
+            }
+
+            for (dst, src) in addr.sun_path.iter_mut().zip(bytes) {
+                *dst = *src as c_char;
+            }            
+            // null byte for pathname is already there since we zeroed up front
+
+            let base = &addr as *const _ as usize;
+            let path = &addr.sun_path as *const _ as usize;
+            let sun_path_offset = path - base;
+
+            let mut len = sun_path_offset + bytes.len();
+            match bytes.get(0) {
+                Some(&0) | None => {}
+                Some(_) => len += 1,
+            }
+            Ok(SockAddr::from_raw_parts(&addr as *const _ as *const _, len as socklen_t))
+        }
+    }
+
     unsafe fn as_<T>(&self, family: sa_family_t) -> Option<T> {
         if self.storage.ss_family != family {
             return None;

src/socket.rs

@@ -36,6 +36,21 @@ impl Socket {
         })
     }
 
+    /// Creates a pair of sockets which are connected to each other.
+    ///
+    /// This function corresponds to `socketpair(2)`.
+    ///
+    /// This function is only available on Unix when the `pair` feature is
+    /// enabled.
+    #[cfg(all(unix, feature = "pair"))]
+    pub fn pair(domain: Domain,
+                type_: Type,
+                protocol: Option<Protocol>) -> io::Result<(Socket, Socket)> {
+        let protocol = protocol.map(|p| p.0).unwrap_or(0);
+        let sockets = sys::Socket::pair(domain.0, type_.0, protocol)?;
+        Ok((Socket { inner: sockets.0 }, Socket { inner: sockets.1 }))
+    }
+
     /// Consumes this `Socket`, converting it to a `TcpStream`.
     pub fn into_tcp_stream(self) -> net::TcpStream {
         self.into()
@@ -627,6 +642,15 @@ impl Domain {
     pub fn ipv6() -> Domain {
         Domain(c::AF_INET6)
     }
+
+    /// Domain for Unix socket communication, corresponding to `AF_UNIX`.
+    ///
+    /// This function is only available on Unix when the `unix` feature is
+    /// activated.
+    #[cfg(all(unix, feature = "unix"))]
+    pub fn unix() -> Domain {
+        Domain(c::AF_UNIX)
+    }
 }
 
 impl From<i32> for Domain {
@@ -721,4 +745,37 @@ mod test {
         let socket = Socket::new(Domain::ipv4(), Type::stream(), None).unwrap();
         socket.connect_timeout(&addr, Duration::from_millis(250)).unwrap();
     }
+
+    #[test]
+    #[cfg(all(unix, feature = "pair", feature = "unix"))]
+    fn pair() {
+        let (mut a, mut b) = Socket::pair(Domain::unix(), Type::stream(), None).unwrap();
+        a.write_all(b"hello world").unwrap();
+        let mut buf = [0; 11];
+        b.read_exact(&mut buf).unwrap();
+        assert_eq!(buf, &b"hello world"[..]);
+    }
+
+    #[test]
+    #[cfg(all(unix, feature = "unix"))]
+    fn unix() {
+        use tempdir::TempDir;
+
+        let dir = TempDir::new("unix").unwrap();
+        let addr = SockAddr::unix(dir.path().join("sock")).unwrap();
+
+        let listener = Socket::new(Domain::unix(), Type::stream(), None).unwrap();
+        listener.bind(&addr).unwrap();
+        listener.listen(10).unwrap();
+
+        let mut a = Socket::new(Domain::unix(), Type::stream(), None).unwrap();
+        a.connect(&addr).unwrap();
+
+        let mut b = listener.accept().unwrap().0;
+
+        a.write_all(b"hello world").unwrap();
+        let mut buf = [0; 11];
+        b.read_exact(&mut buf).unwrap();
+        assert_eq!(buf, &b"hello world"[..]);
+    }
 }

src/sys/unix/mod.rs

@@ -94,6 +94,21 @@ impl Socket {
         }
     }
 
+    pub fn pair(family: c_int, ty: c_int, protocol: c_int) -> io::Result<(Socket, Socket)> {
+        unsafe {
+            let mut fds = [0, 0];
+            cvt(libc::socketpair(family, ty, protocol, fds.as_mut_ptr()))?;
+            let fds = (Socket::from_raw_fd(fds[0]), Socket::from_raw_fd(fds[1]));
+            set_cloexec(fds.0.as_raw_fd())?;
+            set_cloexec(fds.1.as_raw_fd())?;
+            #[cfg(target_os = "macos")] {
+                fds.0.setsockopt(libc::SOL_SOCKET, libc::SO_NOSIGPIPE, 1i32)?;
+                fds.1.setsockopt(libc::SOL_SOCKET, libc::SO_NOSIGPIPE, 1i32)?;
+            }
+            Ok(fds)
+        }
+    }
+
     pub fn bind(&self, addr: &SockAddr) -> io::Result<()> {
         unsafe {
             cvt(libc::bind(self.fd, addr.as_ptr(), addr.len() as _)).map(|_| ())