Replace Unix SocketAddr with std version

src/net/mod.rs

@@ -36,4 +36,4 @@ pub use self::udp::UdpSocket;
 #[cfg(unix)]
 mod uds;
 #[cfg(unix)]
-pub use self::uds::{SocketAddr, UnixDatagram, UnixListener, UnixStream};
+pub use self::uds::{UnixDatagram, UnixListener, UnixStream};

src/net/uds/datagram.rs

@@ -3,7 +3,7 @@ use crate::{event, sys, Interest, Registry, Token};
 
 use std::net::Shutdown;
 use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
-use std::os::unix::net;
+use std::os::unix::net::{self, SocketAddr};
 use std::path::Path;
 use std::{fmt, io};
 
@@ -15,7 +15,13 @@ pub struct UnixDatagram {
 impl UnixDatagram {
     /// Creates a Unix datagram socket bound to the given path.
     pub fn bind<P: AsRef<Path>>(path: P) -> io::Result<UnixDatagram> {
-        sys::uds::datagram::bind(path.as_ref()).map(UnixDatagram::from_std)
+        let addr = SocketAddr::from_pathname(path)?;
+        UnixDatagram::bind_addr(&addr)
+    }
+
+    /// Creates a new `UnixDatagram` bound to the specified socket `address`.
+    pub fn bind_addr(address: &SocketAddr) -> io::Result<UnixDatagram> {
+        sys::uds::datagram::bind_addr(address).map(UnixDatagram::from_std)
     }
 
     /// Creates a new `UnixDatagram` from a standard `net::UnixDatagram`.
@@ -54,24 +60,23 @@ impl UnixDatagram {
     }
 
     /// Returns the address of this socket.
-    pub fn local_addr(&self) -> io::Result<sys::SocketAddr> {
-        sys::uds::datagram::local_addr(&self.inner)
+    pub fn local_addr(&self) -> io::Result<SocketAddr> {
+        self.inner.local_addr()
     }
 
     /// Returns the address of this socket's peer.
     ///
     /// The `connect` method will connect the socket to a peer.
-    pub fn peer_addr(&self) -> io::Result<sys::SocketAddr> {
-        sys::uds::datagram::peer_addr(&self.inner)
+    pub fn peer_addr(&self) -> io::Result<SocketAddr> {
+        self.inner.peer_addr()
     }
 
     /// Receives data from the socket.
     ///
     /// On success, returns the number of bytes read and the address from
     /// whence the data came.
-    pub fn recv_from(&self, buf: &mut [u8]) -> io::Result<(usize, sys::SocketAddr)> {
-        self.inner
-            .do_io(|inner| sys::uds::datagram::recv_from(inner, buf))
+    pub fn recv_from(&self, buf: &mut [u8]) -> io::Result<(usize, SocketAddr)> {
+        self.inner.do_io(|inner| inner.recv_from(buf))
     }
 
     /// Receives data from the socket.

src/net/uds/listener.rs

@@ -1,12 +1,12 @@
-use crate::io_source::IoSource;
-use crate::net::{SocketAddr, UnixStream};
-use crate::{event, sys, Interest, Registry, Token};
-
 use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
-use std::os::unix::net;
+use std::os::unix::net::{self, SocketAddr};
 use std::path::Path;
 use std::{fmt, io};
 
+use crate::io_source::IoSource;
+use crate::net::UnixStream;
+use crate::{event, sys, Interest, Registry, Token};
+
 /// A non-blocking Unix domain socket server.
 pub struct UnixListener {
     inner: IoSource<net::UnixListener>,
@@ -15,7 +15,8 @@ pub struct UnixListener {
 impl UnixListener {
     /// Creates a new `UnixListener` bound to the specified socket `path`.
     pub fn bind<P: AsRef<Path>>(path: P) -> io::Result<UnixListener> {
-        sys::uds::listener::bind(path.as_ref()).map(UnixListener::from_std)
+        let addr = SocketAddr::from_pathname(path)?;
+        UnixListener::bind_addr(&addr)
     }
 
     /// Creates a new `UnixListener` bound to the specified socket `address`.
@@ -44,8 +45,8 @@ impl UnixListener {
     }
 
     /// Returns the local socket address of this listener.
-    pub fn local_addr(&self) -> io::Result<sys::SocketAddr> {
-        sys::uds::listener::local_addr(&self.inner)
+    pub fn local_addr(&self) -> io::Result<SocketAddr> {
+        self.inner.local_addr()
     }
 
     /// Returns the value of the `SO_ERROR` option.

src/net/uds/mod.rs

@@ -6,5 +6,3 @@ pub use self::listener::UnixListener;
 
 mod stream;
 pub use self::stream::UnixStream;
-
-pub use crate::sys::SocketAddr;

src/net/uds/stream.rs

@@ -1,12 +1,11 @@
 use crate::io_source::IoSource;
-use crate::net::SocketAddr;
 use crate::{event, sys, Interest, Registry, Token};
 
 use std::fmt;
 use std::io::{self, IoSlice, IoSliceMut, Read, Write};
 use std::net::Shutdown;
 use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
-use std::os::unix::net;
+use std::os::unix::net::{self, SocketAddr};
 use std::path::Path;
 
 /// A non-blocking Unix stream socket.
@@ -20,7 +19,8 @@ impl UnixStream {
     /// This may return a `WouldBlock` in which case the socket connection
     /// cannot be completed immediately. Usually it means the backlog is full.
     pub fn connect<P: AsRef<Path>>(path: P) -> io::Result<UnixStream> {
-        sys::uds::stream::connect(path.as_ref()).map(UnixStream::from_std)
+        let addr = SocketAddr::from_pathname(path)?;
+        UnixStream::connect_addr(&addr)
     }
 
     /// Connects to the socket named by `address`.
@@ -59,13 +59,13 @@ impl UnixStream {
     }
 
     /// Returns the socket address of the local half of this connection.
-    pub fn local_addr(&self) -> io::Result<sys::SocketAddr> {
-        sys::uds::stream::local_addr(&self.inner)
+    pub fn local_addr(&self) -> io::Result<SocketAddr> {
+        self.inner.local_addr()
     }
 
     /// Returns the socket address of the remote half of this connection.
-    pub fn peer_addr(&self) -> io::Result<sys::SocketAddr> {
-        sys::uds::stream::peer_addr(&self.inner)
+    pub fn peer_addr(&self) -> io::Result<SocketAddr> {
+        self.inner.peer_addr()
     }
 
     /// Returns the value of the `SO_ERROR` option.

src/sys/mod.rs

@@ -80,9 +80,4 @@ cfg_not_os_poll! {
         #[cfg(feature = "os-ext")]
         pub use self::unix::SourceFd;
     }
-
-    #[cfg(unix)]
-    cfg_net! {
-        pub use self::unix::SocketAddr;
-    }
 }

src/sys/shell/uds.rs

@@ -1,10 +1,8 @@
 pub(crate) mod datagram {
-    use crate::net::SocketAddr;
     use std::io;
-    use std::os::unix::net;
-    use std::path::Path;
+    use std::os::unix::net::{self, SocketAddr};
 
-    pub(crate) fn bind(_: &Path) -> io::Result<net::UnixDatagram> {
+    pub(crate) fn bind_addr(_: &SocketAddr) -> io::Result<net::UnixDatagram> {
         os_required!()
     }
 
@@ -15,32 +13,13 @@ pub(crate) mod datagram {
     pub(crate) fn pair() -> io::Result<(net::UnixDatagram, net::UnixDatagram)> {
         os_required!()
     }
-
-    pub(crate) fn local_addr(_: &net::UnixDatagram) -> io::Result<SocketAddr> {
-        os_required!()
-    }
-
-    pub(crate) fn peer_addr(_: &net::UnixDatagram) -> io::Result<SocketAddr> {
-        os_required!()
-    }
-
-    pub(crate) fn recv_from(
-        _: &net::UnixDatagram,
-        _: &mut [u8],
-    ) -> io::Result<(usize, SocketAddr)> {
-        os_required!()
-    }
 }
 
 pub(crate) mod listener {
-    use crate::net::{SocketAddr, UnixStream};
     use std::io;
-    use std::os::unix::net;
-    use std::path::Path;
+    use std::os::unix::net::{self, SocketAddr};
 
-    pub(crate) fn bind(_: &Path) -> io::Result<net::UnixListener> {
-        os_required!()
-    }
+    use crate::net::UnixStream;
 
     pub(crate) fn bind_addr(_: &SocketAddr) -> io::Result<net::UnixListener> {
         os_required!()
@@ -49,21 +28,11 @@ pub(crate) mod listener {
     pub(crate) fn accept(_: &net::UnixListener) -> io::Result<(UnixStream, SocketAddr)> {
         os_required!()
     }
-
-    pub(crate) fn local_addr(_: &net::UnixListener) -> io::Result<SocketAddr> {
-        os_required!()
-    }
 }
 
 pub(crate) mod stream {
-    use crate::net::SocketAddr;
     use std::io;
-    use std::os::unix::net;
-    use std::path::Path;
-
-    pub(crate) fn connect(_: &Path) -> io::Result<net::UnixStream> {
-        os_required!()
-    }
+    use std::os::unix::net::{self, SocketAddr};
 
     pub(crate) fn connect_addr(_: &SocketAddr) -> io::Result<net::UnixStream> {
         os_required!()
@@ -72,12 +41,4 @@ pub(crate) mod stream {
     pub(crate) fn pair() -> io::Result<(net::UnixStream, net::UnixStream)> {
         os_required!()
     }
-
-    pub(crate) fn local_addr(_: &net::UnixStream) -> io::Result<SocketAddr> {
-        os_required!()
-    }
-
-    pub(crate) fn peer_addr(_: &net::UnixStream) -> io::Result<SocketAddr> {
-        os_required!()
-    }
 }

src/sys/unix/mod.rs

@@ -31,8 +31,6 @@ cfg_os_poll! {
         pub(crate) mod udp;
         #[cfg(not(target_os = "hermit"))]
         pub(crate) mod uds;
-        #[cfg(not(target_os = "hermit"))]
-        pub use self::uds::SocketAddr;
     }
 
     cfg_io_source! {
@@ -118,11 +116,6 @@ cfg_os_poll! {
 }
 
 cfg_not_os_poll! {
-    cfg_net! {
-        mod uds;
-        pub use self::uds::SocketAddr;
-    }
-
     cfg_any_os_ext! {
         mod sourcefd;
         #[cfg(feature = "os-ext")]

src/sys/unix/uds/datagram.rs

@@ -1,18 +1,16 @@
-use super::{socket_addr, SocketAddr};
-use crate::sys::unix::net::new_socket;
-
 use std::io;
-use std::os::unix::ffi::OsStrExt;
 use std::os::unix::io::{AsRawFd, FromRawFd};
-use std::os::unix::net;
-use std::path::Path;
+use std::os::unix::net::{self, SocketAddr};
 
-pub(crate) fn bind(path: &Path) -> io::Result<net::UnixDatagram> {
-    let (sockaddr, socklen) = socket_addr(path.as_os_str().as_bytes())?;
-    let sockaddr = &sockaddr as *const libc::sockaddr_un as *const _;
+use crate::sys::unix::net::new_socket;
+use crate::sys::unix::uds::unix_addr;
 
+pub(crate) fn bind_addr(address: &SocketAddr) -> io::Result<net::UnixDatagram> {
     let socket = unbound()?;
-    syscall!(bind(socket.as_raw_fd(), sockaddr, socklen))?;
+
+    let (unix_address, addrlen) = unix_addr(address);
+    let sockaddr = &unix_address as *const libc::sockaddr_un as *const libc::sockaddr;
+    syscall!(bind(socket.as_raw_fd(), sockaddr, addrlen))?;
 
     Ok(socket)
 }
@@ -25,33 +23,3 @@ pub(crate) fn unbound() -> io::Result<net::UnixDatagram> {
 pub(crate) fn pair() -> io::Result<(net::UnixDatagram, net::UnixDatagram)> {
     super::pair(libc::SOCK_DGRAM)
 }
-
-pub(crate) fn local_addr(socket: &net::UnixDatagram) -> io::Result<SocketAddr> {
-    super::local_addr(socket.as_raw_fd())
-}
-
-pub(crate) fn peer_addr(socket: &net::UnixDatagram) -> io::Result<SocketAddr> {
-    super::peer_addr(socket.as_raw_fd())
-}
-
-pub(crate) fn recv_from(
-    socket: &net::UnixDatagram,
-    dst: &mut [u8],
-) -> io::Result<(usize, SocketAddr)> {
-    let mut count = 0;
-    let socketaddr = SocketAddr::new(|sockaddr, socklen| {
-        syscall!(recvfrom(
-            socket.as_raw_fd(),
-            dst.as_mut_ptr() as *mut _,
-            dst.len(),
-            0,
-            sockaddr,
-            socklen,
-        ))
-        .map(|c| {
-            count = c;
-            c as libc::c_int
-        })
-    })?;
-    Ok((count as usize, socketaddr))
-}