Implement vectored I/O, except for target_os = "redox".

Author: de-vri-es

src/socket.rs

@@ -8,6 +8,8 @@
 
 use std::fmt;
 use std::io::{self, Read, Write};
+#[cfg(not(target_os = "redox"))]
+use std::io::{IoSlice, IoSliceMut};
 use std::net::{self, Ipv4Addr, Ipv6Addr, Shutdown};
 #[cfg(all(feature = "all", unix))]
 use std::os::unix::net::{UnixDatagram, UnixListener, UnixStream};
@@ -260,6 +262,21 @@ impl Socket {
         self.inner().recv(buf, flags)
     }
 
+    /// Identical to [`recv_with_flags`] but reads into a slice of buffers.
+    ///
+    /// In addition to the number of bytes read, this function a flag to indicate if a received datagram was truncated.
+    /// For stream sockets, the flag has no meaning.
+    ///
+    /// [`recv_with_flags`]: #method.recv_with_flags
+    #[cfg(not(target_os = "redox"))]
+    pub fn recv_vectored(
+        &self,
+        bufs: &mut [IoSliceMut<'_>],
+        flags: i32,
+    ) -> io::Result<(usize, bool)> {
+        self.inner().recv_vectored(bufs, flags)
+    }
+
     /// Receives out-of-band (OOB) data on the socket from the remote address to
     /// which it is connected by setting the `MSG_OOB` flag for this call.
     ///
@@ -300,6 +317,21 @@ impl Socket {
         self.inner().recv_from(buf, flags)
     }
 
+    /// Identical to [`recv_from_with_flags`] but reads into a slice of buffers.
+    ///
+    /// In addition to the number of bytes read, this function a flag to indicate if a received datagram was truncated.
+    /// For stream sockets, the flag has no meaning.
+    ///
+    /// [`recv_from_with_flags`]: #method.recv_from_with_flags
+    #[cfg(not(target_os = "redox"))]
+    pub fn recv_from_vectored(
+        &self,
+        bufs: &mut [IoSliceMut<'_>],
+        flags: i32,
+    ) -> io::Result<(usize, bool, SockAddr)> {
+        self.inner().recv_from_vectored(bufs, flags)
+    }
+
     /// Receives data from the socket, without removing it from the queue.
     ///
     /// Successive calls return the same data. This is accomplished by passing
@@ -329,6 +361,14 @@ impl Socket {
         self.inner().send(buf, flags)
     }
 
+    /// Identical to [`send_with_flags`] but writes from a slice of buffers.
+    ///
+    /// [`send_with_flags`]: #method.send_with_flags
+    #[cfg(not(target_os = "redox"))]
+    pub fn send_vectored(&self, bufs: &[IoSlice<'_>], flags: i32) -> io::Result<usize> {
+        self.inner().send_vectored(bufs, flags)
+    }
+
     /// Sends out-of-band (OOB) data on the socket to connected peer
     /// by setting the `MSG_OOB` flag for this call.
     ///
@@ -358,6 +398,19 @@ impl Socket {
         self.inner().send_to(buf, flags, addr)
     }
 
+    /// Identical to [`send_with_flags`] but writes from a slice of buffers.
+    ///
+    /// [`send_with_flags`]: #method.send_with_flags
+    #[cfg(not(target_os = "redox"))]
+    pub fn send_to_vectored(
+        &self,
+        bufs: &[IoSlice<'_>],
+        addr: &SockAddr,
+        flags: i32,
+    ) -> io::Result<usize> {
+        self.inner().send_to_vectored(bufs, flags, addr)
+    }
+
     // ================================================
 
     /// Gets the value of the `IP_TTL` option for this socket.

src/sys/unix.rs

@@ -6,6 +6,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#[cfg(not(target_os = "redox"))]
+use std::io::{IoSlice, IoSliceMut};
 use std::io::{Read, Write};
 use std::net::Shutdown;
 use std::net::{self, Ipv4Addr, Ipv6Addr};
@@ -79,6 +81,20 @@ macro_rules! syscall {
     }};
 }
 
+#[cfg(any(target_os = "android", all(target_os = "linux", target_env = "gnu")))]
+type IovLen = usize;
+
+#[cfg(any(
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "ios",
+    all(target_os = "linux", target_env = "musl",),
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "openbsd",
+))]
+type IovLen = c_int;
+
 /// Unix only API.
 impl Domain {
     /// Domain for Unix socket communication, corresponding to `AF_UNIX`.
@@ -488,6 +504,51 @@ impl Socket {
         Ok((n as usize, addr))
     }
 
+    #[cfg(not(target_os = "redox"))]
+    pub fn recv_vectored(
+        &self,
+        bufs: &mut [IoSliceMut<'_>],
+        flags: c_int,
+    ) -> io::Result<(usize, bool)> {
+        let mut msg = libc::msghdr {
+            msg_name: std::ptr::null_mut(),
+            msg_namelen: 0,
+            msg_iov: bufs.as_mut_ptr().cast(),
+            msg_iovlen: bufs.len().min(IovLen::MAX as usize) as IovLen,
+            msg_control: std::ptr::null_mut(),
+            msg_controllen: 0,
+            msg_flags: 0,
+        };
+
+        let n = syscall!(recvmsg(self.fd, &mut msg as *mut _, flags))?;
+        let truncated = msg.msg_flags & libc::MSG_TRUNC != 0;
+        Ok((n as usize, truncated))
+    }
+
+    #[cfg(not(target_os = "redox"))]
+    pub fn recv_from_vectored(
+        &self,
+        bufs: &mut [IoSliceMut<'_>],
+        flags: c_int,
+    ) -> io::Result<(usize, bool, SockAddr)> {
+        let mut storage: libc::sockaddr_storage = unsafe { mem::zeroed() };
+        let mut msg = libc::msghdr {
+            msg_name: &mut storage as *mut libc::sockaddr_storage as *mut c_void,
+            msg_namelen: mem::size_of_val(&storage) as socklen_t,
+            msg_iov: bufs.as_mut_ptr().cast(),
+            msg_iovlen: bufs.len().min(IovLen::MAX as usize) as IovLen,
+            msg_control: std::ptr::null_mut(),
+            msg_controllen: 0,
+            msg_flags: 0,
+        };
+
+        let n = syscall!(recvmsg(self.fd, &mut msg as *mut _, flags))?;
+        let truncated = msg.msg_flags & libc::MSG_TRUNC != 0;
+        let addr =
+            unsafe { SockAddr::from_raw_parts(&storage as *const _ as *const _, msg.msg_namelen) };
+        Ok((n as usize, truncated, addr))
+    }
+
     pub fn send(&self, buf: &[u8], flags: c_int) -> io::Result<usize> {
         let n = syscall!(send(
             self.fd,
@@ -510,6 +571,43 @@ impl Socket {
         Ok(n as usize)
     }
 
+    #[cfg(not(target_os = "redox"))]
+    pub fn send_vectored(&self, bufs: &[IoSlice<'_>], flags: c_int) -> io::Result<usize> {
+        let mut msg = libc::msghdr {
+            msg_name: std::ptr::null_mut(),
+            msg_namelen: 0,
+            msg_iov: bufs.as_ptr() as *mut libc::iovec,
+            msg_iovlen: bufs.len().min(IovLen::MAX as usize) as IovLen,
+            msg_control: std::ptr::null_mut(),
+            msg_controllen: 0,
+            msg_flags: 0,
+        };
+
+        let n = syscall!(sendmsg(self.fd, &mut msg as *mut libc::msghdr, flags))?;
+        Ok(n as usize)
+    }
+
+    #[cfg(not(target_os = "redox"))]
+    pub fn send_to_vectored(
+        &self,
+        bufs: &[IoSlice<'_>],
+        flags: c_int,
+        addr: &SockAddr,
+    ) -> io::Result<usize> {
+        let mut msg = libc::msghdr {
+            msg_name: addr.as_ptr() as *mut c_void,
+            msg_namelen: addr.len(),
+            msg_iov: bufs.as_ptr() as *mut libc::iovec,
+            msg_iovlen: bufs.len().min(IovLen::MAX as usize) as IovLen,
+            msg_control: std::ptr::null_mut(),
+            msg_controllen: 0,
+            msg_flags: 0,
+        };
+
+        let n = syscall!(sendmsg(self.fd, &mut msg as *mut libc::msghdr, flags))?;
+        Ok(n as usize)
+    }
+
     pub fn ttl(&self) -> io::Result<u32> {
         unsafe {
             let raw: c_int = self.getsockopt(libc::IPPROTO_IP, libc::IP_TTL)?;

src/sys/windows.rs

@@ -9,7 +9,7 @@
 use std::cmp;
 use std::fmt;
 use std::io;
-use std::io::{Read, Write};
+use std::io::{IoSlice, IoSliceMut, Read, Write};
 use std::mem;
 use std::net::Shutdown;
 use std::net::{self, Ipv4Addr, Ipv6Addr};
@@ -338,6 +338,77 @@ impl Socket {
         }
     }
 
+    pub fn recv_vectored(
+        &self,
+        bufs: &mut [IoSliceMut<'_>],
+        flags: c_int,
+    ) -> io::Result<(usize, bool)> {
+        let mut nread = 0;
+        let mut flags = flags as DWORD;
+        let ret = unsafe {
+            sock::WSARecv(
+                self.socket,
+                bufs.as_mut_ptr() as *mut WSABUF,
+                bufs.len().min(DWORD::MAX as usize) as DWORD,
+                &mut nread,
+                &mut flags,
+                ptr::null_mut(),
+                None,
+            )
+        };
+
+        let nread = nread as usize;
+        if ret == 0 {
+            Ok((nread, false))
+        } else {
+            let error = last_error();
+            match error.raw_os_error() {
+                Some(sock::WSAESHUTDOWN) => Ok((0, false)),
+                Some(sock::WSAEMSGSIZE) => Ok((nread, true)),
+                _ => Err(error),
+            }
+        }
+    }
+
+    pub fn recv_from_vectored(
+        &self,
+        bufs: &mut [IoSliceMut<'_>],
+        flags: c_int,
+    ) -> io::Result<(usize, bool, SockAddr)> {
+        let mut nread = 0;
+        let mut flags = flags as DWORD;
+        let mut storage: SOCKADDR_STORAGE = unsafe { mem::zeroed() };
+        let mut addrlen = mem::size_of_val(&storage) as c_int;
+        let ret = unsafe {
+            sock::WSARecvFrom(
+                self.socket,
+                bufs.as_mut_ptr() as *mut WSABUF,
+                bufs.len().min(DWORD::MAX as usize) as DWORD,
+                &mut nread,
+                &mut flags,
+                &mut storage as *mut SOCKADDR_STORAGE as *mut SOCKADDR,
+                &mut addrlen,
+                ptr::null_mut(),
+                None,
+            )
+        };
+
+        let truncated;
+        if ret == 0 {
+            truncated = false;
+        } else {
+            let error = last_error();
+            if error.raw_os_error() == Some(sock::WSAEMSGSIZE) {
+                truncated = true;
+            } else {
+                return Err(error);
+            }
+        }
+
+        let addr = unsafe { SockAddr::from_raw_parts(&storage as *const _ as *const _, addrlen) };
+        Ok((nread as usize, truncated, addr))
+    }
+
     pub fn send(&self, buf: &[u8], flags: c_int) -> io::Result<usize> {
         unsafe {
             let n = {
@@ -376,6 +447,51 @@ impl Socket {
         }
     }
 
+    pub fn send_vectored(&self, bufs: &[IoSlice<'_>], flags: c_int) -> io::Result<usize> {
+        let mut nsent = 0;
+        let ret = unsafe {
+            sock::WSASend(
+                self.socket,
+                bufs.as_ptr() as *mut WSABUF,
+                bufs.len().min(DWORD::MAX as usize) as DWORD,
+                &mut nsent,
+                flags as DWORD,
+                std::ptr::null_mut(),
+                None,
+            )
+        };
+        match ret {
+            0 => Ok(nsent as usize),
+            _ => Err(last_error()),
+        }
+    }
+
+    pub fn send_to_vectored(
+        &self,
+        bufs: &[IoSlice<'_>],
+        flags: c_int,
+        addr: &SockAddr,
+    ) -> io::Result<usize> {
+        let mut nsent = 0;
+        let ret = unsafe {
+            sock::WSASendTo(
+                self.socket,
+                bufs.as_ptr() as *mut WSABUF,
+                bufs.len().min(DWORD::MAX as usize) as DWORD,
+                &mut nsent,
+                flags as DWORD,
+                addr.as_ptr(),
+                addr.len(),
+                std::ptr::null_mut(),
+                None,
+            )
+        };
+        match ret {
+            0 => Ok(nsent as usize),
+            _ => Err(last_error()),
+        }
+    }
+
     // ================================================
 
     pub fn ttl(&self) -> io::Result<u32> {