Refactor Socket::send_to

Author: Thomasdezeeuw

src/socket.rs

@@ -452,18 +452,17 @@ impl Socket {
     /// Sends data on the socket to the given address. On success, returns the
     /// number of bytes written.
     ///
-    /// This is typically used on UDP or datagram-oriented sockets. On success
-    /// returns the number of bytes that were sent.
+    /// This is typically used on UDP or datagram-oriented sockets.
     pub fn send_to(&self, buf: &[u8], addr: &SockAddr) -> io::Result<usize> {
-        self.inner().send_to(buf, 0, addr)
+        self.send_to_with_flags(buf, addr, 0)
     }
 
-    /// Identical to [`send_to`] but allows for specification of arbitrary flags to the underlying
-    /// `sendto` call.
+    /// Identical to [`send_to`] but allows for specification of arbitrary flags
+    /// to the underlying `sendto` call.
     ///
-    /// [`send_to`]: #method.send_to
+    /// [`send_to`]: Socket::send_to
     pub fn send_to_with_flags(&self, buf: &[u8], addr: &SockAddr, flags: i32) -> io::Result<usize> {
-        self.inner().send_to(buf, flags, addr)
+        sys::send_to(self.inner, buf, addr, flags)
     }
 
     /// Identical to [`send_with_flags`] but writes from a slice of buffers.

src/sys/unix.rs

@@ -20,9 +20,11 @@ use std::os::unix::net::{UnixDatagram, UnixListener, UnixStream};
 #[cfg(feature = "all")]
 use std::path::Path;
 use std::time::Duration;
-use std::{cmp, fmt, io, ptr};
+use std::{fmt, io, ptr};
 
-use libc::{self, c_void, in6_addr, in_addr, ssize_t};
+#[cfg(not(target_vendor = "apple"))]
+use libc::ssize_t;
+use libc::{c_void, in6_addr, in_addr};
 
 #[cfg(not(target_os = "redox"))]
 use crate::RecvFlags;
@@ -507,6 +509,23 @@ pub(crate) fn send_vectored(
     syscall!(sendmsg(fd, &mut msg, flags)).map(|n| n as usize)
 }
 
+pub(crate) fn send_to(
+    fd: SysSocket,
+    buf: &[u8],
+    addr: &SockAddr,
+    flags: c_int,
+) -> io::Result<usize> {
+    syscall!(sendto(
+        fd,
+        buf.as_ptr().cast(),
+        min(buf.len(), MAX_BUF_LEN),
+        flags,
+        addr.as_ptr(),
+        addr.len(),
+    ))
+    .map(|n| n as usize)
+}
+
 /// Unix only API.
 impl crate::Socket {
     /// Accept a new incoming connection from this listener.
@@ -642,18 +661,6 @@ pub struct Socket {
 }
 
 impl Socket {
-    pub fn send_to(&self, buf: &[u8], flags: c_int, addr: &SockAddr) -> io::Result<usize> {
-        let n = syscall!(sendto(
-            self.fd,
-            buf.as_ptr() as *const c_void,
-            cmp::min(buf.len(), max_len()),
-            flags,
-            addr.as_ptr(),
-            addr.len(),
-        ))?;
-        Ok(n as usize)
-    }
-
     #[cfg(not(target_os = "redox"))]
     pub fn send_to_vectored(
         &self,
@@ -1187,22 +1194,6 @@ pub(crate) fn close(fd: SysSocket) {
     }
 }
 
-fn max_len() -> usize {
-    // The maximum read limit on most posix-like systems is `SSIZE_MAX`,
-    // with the man page quoting that if the count of bytes to read is
-    // greater than `SSIZE_MAX` the result is "unspecified".
-    //
-    // On macOS, however, apparently the 64-bit libc is either buggy or
-    // intentionally showing odd behavior by rejecting any read with a size
-    // larger than or equal to INT_MAX. To handle both of these the read
-    // size is capped on both platforms.
-    if cfg!(target_os = "macos") {
-        <c_int>::max_value() as usize - 1
-    } else {
-        <ssize_t>::max_value() as usize
-    }
-}
-
 fn dur2timeval(dur: Option<Duration>) -> io::Result<libc::timeval> {
     match dur {
         Some(dur) => {

src/sys/windows.rs

@@ -6,17 +6,14 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::cmp::{self, min};
-use std::fmt;
-use std::io;
-use std::io::{IoSlice, IoSliceMut, Write};
+use std::cmp::min;
+use std::io::{self, IoSlice, IoSliceMut, Write};
 use std::mem::{self, size_of, size_of_val, MaybeUninit};
-use std::net::Shutdown;
-use std::net::{self, Ipv4Addr, Ipv6Addr};
+use std::net::{self, Ipv4Addr, Ipv6Addr, Shutdown};
 use std::os::windows::prelude::*;
-use std::ptr;
 use std::sync::Once;
 use std::time::Duration;
+use std::{fmt, ptr};
 
 use winapi::ctypes::{c_char, c_long, c_ulong};
 use winapi::shared::in6addr::*;
@@ -39,8 +36,8 @@ pub use winapi::ctypes::c_int;
 
 /// Fake MSG_TRUNC flag for the [`RecvFlags`] struct.
 ///
-/// The flag is enabled when a `WSARecv[From]` call returns `WSAEMSGSIZE`.
-/// The value of the flag is defined by us.
+/// The flag is enabled when a `WSARecv[From]` call returns `WSAEMSGSIZE`. The
+/// value of the flag is defined by us.
 pub(crate) const MSG_TRUNC: c_int = 0x01;
 
 // Used in `Domain`.
@@ -454,6 +451,27 @@ pub(crate) fn send_vectored(
     .map(|_| nsent as usize)
 }
 
+pub(crate) fn send_to(
+    socket: SysSocket,
+    buf: &[u8],
+    addr: &SockAddr,
+    flags: c_int,
+) -> io::Result<usize> {
+    syscall!(
+        sendto(
+            socket,
+            buf.as_ptr().cast(),
+            min(buf.len(), MAX_BUF_LEN) as c_int,
+            flags,
+            addr.as_ptr(),
+            addr.len(),
+        ),
+        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();
@@ -507,26 +525,6 @@ pub struct Socket {
 }
 
 impl Socket {
-    pub fn send_to(&self, buf: &[u8], flags: c_int, addr: &SockAddr) -> io::Result<usize> {
-        unsafe {
-            let n = {
-                sock::sendto(
-                    self.socket,
-                    buf.as_ptr() as *const c_char,
-                    clamp(buf.len()),
-                    flags,
-                    addr.as_ptr(),
-                    addr.len(),
-                )
-            };
-            if n == sock::SOCKET_ERROR {
-                Err(last_error())
-            } else {
-                Ok(n as usize)
-            }
-        }
-    }
-
     pub fn send_to_vectored(
         &self,
         bufs: &[IoSlice<'_>],
@@ -1014,10 +1012,6 @@ pub(crate) fn close(socket: SysSocket) {
     }
 }
 
-fn clamp(input: usize) -> c_int {
-    cmp::min(input, <c_int>::max_value() as usize) as c_int
-}
-
 fn dur2ms(dur: Option<Duration>) -> io::Result<DWORD> {
     match dur {
         Some(dur) => {