Refactor Socket::send

Author: Thomasdezeeuw

src/socket.rs

@@ -411,15 +411,15 @@ impl Socket {
     ///
     /// On success returns the number of bytes that were sent.
     pub fn send(&self, buf: &[u8]) -> io::Result<usize> {
-        self.inner().send(buf, 0)
+        self.send_with_flags(buf, 0)
     }
 
     /// Identical to [`send`] but allows for specification of arbitrary flags to the underlying
     /// `send` call.
     ///
     /// [`send`]: #method.send
     pub fn send_with_flags(&self, buf: &[u8], flags: i32) -> io::Result<usize> {
-        self.inner().send(buf, flags)
+        sys::send(self.inner, buf, flags)
     }
 
     /// Identical to [`send_with_flags`] but writes from a slice of buffers.
@@ -439,7 +439,7 @@ impl Socket {
     /// [`out_of_band_inline`]: #method.out_of_band_inline
     #[cfg(all(feature = "all", not(target_os = "redox")))]
     pub fn send_out_of_band(&self, buf: &[u8]) -> io::Result<usize> {
-        self.inner().send(buf, sys::MSG_OOB)
+        self.send_with_flags(buf, sys::MSG_OOB)
     }
 
     /// Sends data on the socket to the given address. On success, returns the

src/sys/unix.rs

@@ -435,7 +435,7 @@ pub(crate) fn recv_vectored(
 }
 
 #[cfg(not(target_os = "redox"))]
-pub fn recv_from_vectored(
+pub(crate) fn recv_from_vectored(
     fd: SysSocket,
     bufs: &mut [IoSliceMut<'_>],
     flags: c_int,
@@ -475,6 +475,16 @@ fn recvmsg(
         .map(|n| (n as usize, msg.msg_namelen, RecvFlags(msg.msg_flags)))
 }
 
+pub(crate) fn send(fd: SysSocket, buf: &[u8], flags: c_int) -> io::Result<usize> {
+    syscall!(send(
+        fd,
+        buf.as_ptr().cast(),
+        min(buf.len(), MAX_BUF_LEN),
+        flags,
+    ))
+    .map(|n| n as usize)
+}
+
 /// Unix only API.
 impl crate::Socket {
     /// Accept a new incoming connection from this listener.
@@ -610,16 +620,6 @@ pub struct Socket {
 }
 
 impl Socket {
-    pub fn send(&self, buf: &[u8], flags: c_int) -> io::Result<usize> {
-        let n = syscall!(send(
-            self.fd,
-            buf.as_ptr() as *const c_void,
-            cmp::min(buf.len(), max_len()),
-            flags,
-        ))?;
-        Ok(n as usize)
-    }
-
     pub fn send_to(&self, buf: &[u8], flags: c_int, addr: &SockAddr) -> io::Result<usize> {
         let n = syscall!(sendto(
             self.fd,
@@ -1039,7 +1039,7 @@ impl Write for Socket {
 
 impl<'a> Write for &'a Socket {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.send(buf, 0)
+        send(self.fd, buf, 0)
     }
 
     fn flush(&mut self) -> io::Result<()> {

src/sys/windows.rs

@@ -407,6 +407,20 @@ pub(crate) fn recv_from_vectored(
     }
 }
 
+pub(crate) fn send(socket: SysSocket, buf: &[u8], flags: c_int) -> io::Result<usize> {
+    syscall!(
+        send(
+            socket,
+            buf.as_ptr().cast(),
+            min(buf.len(), MAX_BUF_LEN) as c_int,
+            flags,
+        ),
+        PartialEq::eq,
+        sock::SOCKET_ERROR
+    )
+    .map(|n| n as usize)
+}
+
 /// Caller must ensure `T` is the correct type for `opt` and `val`.
 unsafe fn getsockopt<T>(socket: SysSocket, opt: c_int, val: c_int) -> io::Result<T> {
     let mut payload: MaybeUninit<T> = MaybeUninit::uninit();
@@ -460,24 +474,6 @@ pub struct Socket {
 }
 
 impl Socket {
-    pub fn send(&self, buf: &[u8], flags: c_int) -> io::Result<usize> {
-        unsafe {
-            let n = {
-                sock::send(
-                    self.socket,
-                    buf.as_ptr() as *const c_char,
-                    clamp(buf.len()),
-                    flags,
-                )
-            };
-            if n == sock::SOCKET_ERROR {
-                Err(last_error())
-            } else {
-                Ok(n as usize)
-            }
-        }
-    }
-
     pub fn send_to(&self, buf: &[u8], flags: c_int, addr: &SockAddr) -> io::Result<usize> {
         unsafe {
             let n = {
@@ -896,7 +892,7 @@ impl Write for Socket {
 
 impl<'a> Write for &'a Socket {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.send(buf, 0)
+        send(self.socket, buf, 0)
     }
 
     fn flush(&mut self) -> io::Result<()> {