Nuke deprecated net APIs

Signed-off-by: Alex Saveau <saveau.alexandre@gmail.com>

2 files changed, 12 insertions, 747 deletions

diff --git a/src/sys/socket/addr.rs b/src/sys/socket/addr.rs
index 55a7b2ff..970e8381 100644
--- a/src/sys/socket/addr.rs
+++ b/src/sys/socket/addr.rs
@@ -33,8 +33,6 @@ use std::convert::TryInto;
 use std::ffi::OsStr;
 use std::hash::{Hash, Hasher};
 use std::os::unix::ffi::OsStrExt;
-#[cfg(any(target_os = "ios", target_os = "macos"))]
-use std::os::unix::io::RawFd;
 use std::path::Path;
 use std::{fmt, mem, net, ptr, slice};
 
@@ -445,308 +443,6 @@ impl AddressFamily {
     }
 }
 
-feature! {
-#![feature = "net"]
-
-#[deprecated(
-    since = "0.24.0",
-    note = "use SockaddrIn, SockaddrIn6, or SockaddrStorage instead"
-)]
-#[allow(missing_docs)]  // Since they're all deprecated anyway
-#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
-pub enum InetAddr {
-    V4(libc::sockaddr_in),
-    V6(libc::sockaddr_in6),
-}
-
-#[allow(missing_docs)]  // It's deprecated anyway
-#[allow(deprecated)]
-impl InetAddr {
-    #[allow(clippy::needless_update)]   // It isn't needless on all OSes
-    pub fn from_std(std: &net::SocketAddr) -> InetAddr {
-        match *std {
-            net::SocketAddr::V4(ref addr) => {
-                InetAddr::V4(libc::sockaddr_in {
-                    #[cfg(any(target_os = "dragonfly", target_os = "freebsd",
-                              target_os = "haiku", target_os = "hermit",
-                              target_os = "ios", target_os = "macos",
-                              target_os = "netbsd", target_os = "openbsd"))]
-                    sin_len: mem::size_of::<libc::sockaddr_in>() as u8,
-                    sin_family: AddressFamily::Inet as sa_family_t,
-                    sin_port: addr.port().to_be(),  // network byte order
-                    sin_addr: Ipv4Addr::from_std(addr.ip()).0,
-                    .. unsafe { mem::zeroed() }
-                })
-            }
-            net::SocketAddr::V6(ref addr) => {
-                InetAddr::V6(libc::sockaddr_in6 {
-                    #[cfg(any(target_os = "dragonfly", target_os = "freebsd",
-                              target_os = "haiku", target_os = "hermit",
-                              target_os = "ios", target_os = "macos",
-                              target_os = "netbsd", target_os = "openbsd"))]
-                    sin6_len: mem::size_of::<libc::sockaddr_in6>() as u8,
-                    sin6_family: AddressFamily::Inet6 as sa_family_t,
-                    sin6_port: addr.port().to_be(),  // network byte order
-                    sin6_addr: Ipv6Addr::from_std(addr.ip()).0,
-                    sin6_flowinfo: addr.flowinfo(),  // host byte order
-                    sin6_scope_id: addr.scope_id(),  // host byte order
-                    .. unsafe { mem::zeroed() }
-                })
-            }
-        }
-    }
-
-    #[allow(clippy::needless_update)]   // It isn't needless on all OSes
-    pub fn new(ip: IpAddr, port: u16) -> InetAddr {
-        match ip {
-            IpAddr::V4(ref ip) => {
-                InetAddr::V4(libc::sockaddr_in {
-                    sin_family: AddressFamily::Inet as sa_family_t,
-                    sin_port: port.to_be(),
-                    sin_addr: ip.0,
-                    .. unsafe { mem::zeroed() }
-                })
-            }
-            IpAddr::V6(ref ip) => {
-                InetAddr::V6(libc::sockaddr_in6 {
-                    sin6_family: AddressFamily::Inet6 as sa_family_t,
-                    sin6_port: port.to_be(),
-                    sin6_addr: ip.0,
-                    .. unsafe { mem::zeroed() }
-                })
-            }
-        }
-    }
-    /// Gets the IP address associated with this socket address.
-    pub const fn ip(&self) -> IpAddr {
-        match *self {
-            InetAddr::V4(ref sa) => IpAddr::V4(Ipv4Addr(sa.sin_addr)),
-            InetAddr::V6(ref sa) => IpAddr::V6(Ipv6Addr(sa.sin6_addr)),
-        }
-    }
-
-    /// Gets the port number associated with this socket address
-    pub const fn port(&self) -> u16 {
-        match *self {
-            InetAddr::V6(ref sa) => u16::from_be(sa.sin6_port),
-            InetAddr::V4(ref sa) => u16::from_be(sa.sin_port),
-        }
-    }
-
-    pub fn to_std(&self) -> net::SocketAddr {
-        match *self {
-            InetAddr::V4(ref sa) => net::SocketAddr::V4(
-                net::SocketAddrV4::new(
-                    Ipv4Addr(sa.sin_addr).to_std(),
-                    self.port())),
-            InetAddr::V6(ref sa) => net::SocketAddr::V6(
-                net::SocketAddrV6::new(
-                    Ipv6Addr(sa.sin6_addr).to_std(),
-                    self.port(),
-                    sa.sin6_flowinfo,
-                    sa.sin6_scope_id)),
-        }
-    }
-
-    #[deprecated(since = "0.23.0", note = "use .to_string() instead")]
-    pub fn to_str(&self) -> String {
-        format!("{}", self)
-    }
-}
-
-#[allow(deprecated)]
-impl fmt::Display for InetAddr {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            InetAddr::V4(_) => write!(f, "{}:{}", self.ip(), self.port()),
-            InetAddr::V6(_) => write!(f, "[{}]:{}", self.ip(), self.port()),
-        }
-    }
-}
-
-/*
- *
- * ===== IpAddr =====
- *
- */
-#[allow(missing_docs)]  // Since they're all deprecated anyway
-#[allow(deprecated)]
-#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
-#[deprecated(
-    since = "0.24.0",
-    note = "Use std::net::IpAddr instead"
-)]
-pub enum IpAddr {
-    V4(Ipv4Addr),
-    V6(Ipv6Addr),
-}
-
-#[allow(deprecated)]
-#[allow(missing_docs)]  // Since they're all deprecated anyway
-impl IpAddr {
-    /// Create a new IpAddr that contains an IPv4 address.
-    ///
-    /// The result will represent the IP address a.b.c.d
-    pub const fn new_v4(a: u8, b: u8, c: u8, d: u8) -> IpAddr {
-        IpAddr::V4(Ipv4Addr::new(a, b, c, d))
-    }
-
-    /// Create a new IpAddr that contains an IPv6 address.
-    ///
-    /// The result will represent the IP address a:b:c:d:e:f
-    #[allow(clippy::many_single_char_names)]
-    #[allow(clippy::too_many_arguments)]
-    pub const fn new_v6(a: u16, b: u16, c: u16, d: u16, e: u16, f: u16, g: u16, h: u16) -> IpAddr {
-        IpAddr::V6(Ipv6Addr::new(a, b, c, d, e, f, g, h))
-    }
-
-    pub fn from_std(std: &net::IpAddr) -> IpAddr {
-        match *std {
-            net::IpAddr::V4(ref std) => IpAddr::V4(Ipv4Addr::from_std(std)),
-            net::IpAddr::V6(ref std) => IpAddr::V6(Ipv6Addr::from_std(std)),
-        }
-    }
-
-    pub const fn to_std(&self) -> net::IpAddr {
-        match *self {
-            IpAddr::V4(ref ip) => net::IpAddr::V4(ip.to_std()),
-            IpAddr::V6(ref ip) => net::IpAddr::V6(ip.to_std()),
-        }
-    }
-}
-
-#[allow(deprecated)]
-impl fmt::Display for IpAddr {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            IpAddr::V4(ref v4) => v4.fmt(f),
-            IpAddr::V6(ref v6) => v6.fmt(f)
-        }
-    }
-}
-
-/*
- *
- * ===== Ipv4Addr =====
- *
- */
-
-#[deprecated(
-    since = "0.24.0",
-    note = "Use std::net::Ipv4Addr instead"
-)]
-#[allow(missing_docs)]  // Since they're all deprecated anyway
-#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
-#[repr(transparent)]
-pub struct Ipv4Addr(pub libc::in_addr);
-
-#[allow(deprecated)]
-#[allow(missing_docs)]  // Since they're all deprecated anyway
-impl Ipv4Addr {
-    #[allow(clippy::identity_op)]   // More readable this way
-    pub const fn new(a: u8, b: u8, c: u8, d: u8) -> Ipv4Addr {
-        let ip = (((a as u32) << 24) |
-                  ((b as u32) << 16) |
-                  ((c as u32) <<  8) |
-                  ((d as u32) <<  0)).to_be();
-
-        Ipv4Addr(libc::in_addr { s_addr: ip })
-    }
-
-    // Use pass by reference for symmetry with Ipv6Addr::from_std
-    #[allow(clippy::trivially_copy_pass_by_ref)]
-    pub fn from_std(std: &net::Ipv4Addr) -> Ipv4Addr {
-        let bits = std.octets();
-        Ipv4Addr::new(bits[0], bits[1], bits[2], bits[3])
-    }
-
-    pub const fn any() -> Ipv4Addr {
-        Ipv4Addr(libc::in_addr { s_addr: libc::INADDR_ANY })
-    }
-
-    pub const fn octets(self) -> [u8; 4] {
-        let bits = u32::from_be(self.0.s_addr);
-        [(bits >> 24) as u8, (bits >> 16) as u8, (bits >> 8) as u8, bits as u8]
-    }
-
-    pub const fn to_std(self) -> net::Ipv4Addr {
-        let bits = self.octets();
-        net::Ipv4Addr::new(bits[0], bits[1], bits[2], bits[3])
-    }
-}
-
-#[allow(deprecated)]
-impl fmt::Display for Ipv4Addr {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        let octets = self.octets();
-        write!(fmt, "{}.{}.{}.{}", octets[0], octets[1], octets[2], octets[3])
-    }
-}
-
-/*
- *
- * ===== Ipv6Addr =====
- *
- */
-
-#[deprecated(
-    since = "0.24.0",
-    note = "Use std::net::Ipv6Addr instead"
-)]
-#[allow(missing_docs)]  // Since they're all deprecated anyway
-#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
-#[repr(transparent)]
-pub struct Ipv6Addr(pub libc::in6_addr);
-
-// Note that IPv6 addresses are stored in big endian order on all architectures.
-// See https://tools.ietf.org/html/rfc1700 or consult your favorite search
-// engine.
-
-macro_rules! to_u8_array {
-    ($($num:ident),*) => {
-        [ $(($num>>8) as u8, ($num&0xff) as u8,)* ]
-    }
-}
-
-macro_rules! to_u16_array {
-    ($slf:ident, $($first:expr, $second:expr),*) => {
-        [$( (($slf.0.s6_addr[$first] as u16) << 8) + $slf.0.s6_addr[$second] as u16,)*]
-    }
-}
-
-#[allow(deprecated)]
-#[allow(missing_docs)]  // Since they're all deprecated anyway
-impl Ipv6Addr {
-    #[allow(clippy::many_single_char_names)]
-    #[allow(clippy::too_many_arguments)]
-    pub const fn new(a: u16, b: u16, c: u16, d: u16, e: u16, f: u16, g: u16, h: u16) -> Ipv6Addr {
-        Ipv6Addr(libc::in6_addr{s6_addr: to_u8_array!(a,b,c,d,e,f,g,h)})
-    }
-
-    pub fn from_std(std: &net::Ipv6Addr) -> Ipv6Addr {
-        let s = std.segments();
-        Ipv6Addr::new(s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7])
-    }
-
-    /// Return the eight 16-bit segments that make up this address
-    pub const fn segments(&self) -> [u16; 8] {
-        to_u16_array!(self, 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15)
-    }
-
-    pub const fn to_std(&self) -> net::Ipv6Addr {
-        let s = self.segments();
-        net::Ipv6Addr::new(s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7])
-    }
-}
-
-#[allow(deprecated)]
-impl fmt::Display for Ipv6Addr {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        self.to_std().fmt(fmt)
-    }
-}
-}
-
 /// A wrapper around `sockaddr_un`.
 #[derive(Clone, Copy, Debug)]
 #[repr(C)]
@@ -1982,358 +1678,6 @@ mod private {
     }
 }
 
-/// Represents a socket address
-#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
-#[deprecated(
-    since = "0.24.0",
-    note = "use SockaddrLike or SockaddrStorage instead"
-)]
-#[allow(missing_docs)] // Since they're all deprecated anyway
-#[allow(deprecated)]
-#[non_exhaustive]
-pub enum SockAddr {
-    #[cfg(feature = "net")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
-    Inet(InetAddr),
-    Unix(UnixAddr),
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    #[cfg_attr(docsrs, doc(cfg(all())))]
-    Netlink(NetlinkAddr),
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    #[cfg_attr(docsrs, doc(cfg(all())))]
-    Alg(AlgAddr),
-    #[cfg(all(
-        feature = "ioctl",
-        any(target_os = "ios", target_os = "macos")
-    ))]
-    #[cfg_attr(docsrs, doc(cfg(feature = "ioctl")))]
-    SysControl(SysControlAddr),
-    /// Datalink address (MAC)
-    #[cfg(any(
-        target_os = "android",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "ios",
-        target_os = "linux",
-        target_os = "macos",
-        target_os = "illumos",
-        target_os = "netbsd",
-        target_os = "openbsd"
-    ))]
-    #[cfg(feature = "net")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
-    Link(LinkAddr),
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    #[cfg_attr(docsrs, doc(cfg(all())))]
-    Vsock(VsockAddr),
-}
-
-#[allow(missing_docs)] // Since they're all deprecated anyway
-#[allow(deprecated)]
-impl SockAddr {
-    feature! {
-    #![feature = "net"]
-    pub fn new_inet(addr: InetAddr) -> SockAddr {
-        SockAddr::Inet(addr)
-    }
-    }
-
-    pub fn new_unix<P: ?Sized + NixPath>(path: &P) -> Result<SockAddr> {
-        Ok(SockAddr::Unix(UnixAddr::new(path)?))
-    }
-
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    #[cfg_attr(docsrs, doc(cfg(all())))]
-    pub fn new_netlink(pid: u32, groups: u32) -> SockAddr {
-        SockAddr::Netlink(NetlinkAddr::new(pid, groups))
-    }
-
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    #[cfg_attr(docsrs, doc(cfg(all())))]
-    pub fn new_alg(alg_type: &str, alg_name: &str) -> SockAddr {
-        SockAddr::Alg(AlgAddr::new(alg_type, alg_name))
-    }
-
-    feature! {
-    #![feature = "ioctl"]
-    #[cfg(any(target_os = "ios", target_os = "macos"))]
-    pub fn new_sys_control(sockfd: RawFd, name: &str, unit: u32) -> Result<SockAddr> {
-        SysControlAddr::from_name(sockfd, name, unit).map(SockAddr::SysControl)
-    }
-    }
-
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    #[cfg_attr(docsrs, doc(cfg(all())))]
-    pub fn new_vsock(cid: u32, port: u32) -> SockAddr {
-        SockAddr::Vsock(VsockAddr::new(cid, port))
-    }
-
-    pub fn family(&self) -> AddressFamily {
-        match *self {
-            #[cfg(feature = "net")]
-            SockAddr::Inet(InetAddr::V4(..)) => AddressFamily::Inet,
-            #[cfg(feature = "net")]
-            SockAddr::Inet(InetAddr::V6(..)) => AddressFamily::Inet6,
-            SockAddr::Unix(..) => AddressFamily::Unix,
-            #[cfg(any(target_os = "android", target_os = "linux"))]
-            SockAddr::Netlink(..) => AddressFamily::Netlink,
-            #[cfg(any(target_os = "android", target_os = "linux"))]
-            SockAddr::Alg(..) => AddressFamily::Alg,
-            #[cfg(all(
-                feature = "ioctl",
-                any(target_os = "ios", target_os = "macos")
-            ))]
-            SockAddr::SysControl(..) => AddressFamily::System,
-            #[cfg(any(target_os = "android", target_os = "linux"))]
-            #[cfg(feature = "net")]
-            SockAddr::Link(..) => AddressFamily::Packet,
-            #[cfg(any(
-                target_os = "dragonfly",
-                target_os = "freebsd",
-                target_os = "ios",
-                target_os = "macos",
-                target_os = "netbsd",
-                target_os = "illumos",
-                target_os = "openbsd"
-            ))]
-            #[cfg(feature = "net")]
-            SockAddr::Link(..) => AddressFamily::Link,
-            #[cfg(any(target_os = "android", target_os = "linux"))]
-            SockAddr::Vsock(..) => AddressFamily::Vsock,
-        }
-    }
-
-    #[deprecated(since = "0.23.0", note = "use .to_string() instead")]
-    pub fn to_str(&self) -> String {
-        format!("{}", self)
-    }
-
-    /// Creates a `SockAddr` struct from libc's sockaddr.
-    ///
-    /// Supports only the following address families: Unix, Inet (v4 & v6), Netlink and System.
-    /// Returns None for unsupported families.
-    ///
-    /// # Safety
-    ///
-    /// unsafe because it takes a raw pointer as argument.  The caller must
-    /// ensure that the pointer is valid.
-    #[cfg(not(target_os = "fuchsia"))]
-    #[cfg(feature = "net")]
-    pub(crate) unsafe fn from_libc_sockaddr(
-        addr: *const libc::sockaddr,
-    ) -> Option<SockAddr> {
-        if addr.is_null() {
-            None
-        } else {
-            match AddressFamily::from_i32(i32::from((*addr).sa_family)) {
-                Some(AddressFamily::Unix) => None,
-                #[cfg(feature = "net")]
-                Some(AddressFamily::Inet) => Some(SockAddr::Inet(
-                    InetAddr::V4(ptr::read_unaligned(addr as *const _)),
-                )),
-                #[cfg(feature = "net")]
-                Some(AddressFamily::Inet6) => Some(SockAddr::Inet(
-                    InetAddr::V6(ptr::read_unaligned(addr as *const _)),
-                )),
-                #[cfg(any(target_os = "android", target_os = "linux"))]
-                Some(AddressFamily::Netlink) => Some(SockAddr::Netlink(
-                    NetlinkAddr(ptr::read_unaligned(addr as *const _)),
-                )),
-                #[cfg(all(
-                    feature = "ioctl",
-                    any(target_os = "ios", target_os = "macos")
-                ))]
-                Some(AddressFamily::System) => Some(SockAddr::SysControl(
-                    SysControlAddr(ptr::read_unaligned(addr as *const _)),
-                )),
-                #[cfg(any(target_os = "android", target_os = "linux"))]
-                #[cfg(feature = "net")]
-                Some(AddressFamily::Packet) => Some(SockAddr::Link(LinkAddr(
-                    ptr::read_unaligned(addr as *const _),
-                ))),
-                #[cfg(any(
-                    target_os = "dragonfly",
-                    target_os = "freebsd",
-                    target_os = "ios",
-                    target_os = "macos",
-                    target_os = "netbsd",
-                    target_os = "illumos",
-                    target_os = "openbsd"
-                ))]
-                #[cfg(feature = "net")]
-                Some(AddressFamily::Link) => {
-                    let ether_addr =
-                        LinkAddr(ptr::read_unaligned(addr as *const _));
-                    if ether_addr.is_empty() {
-                        None
-                    } else {
-                        Some(SockAddr::Link(ether_addr))
-                    }
-                }
-                #[cfg(any(target_os = "android", target_os = "linux"))]
-                Some(AddressFamily::Vsock) => Some(SockAddr::Vsock(VsockAddr(
-                    ptr::read_unaligned(addr as *const _),
-                ))),
-                // Other address families are currently not supported and simply yield a None
-                // entry instead of a proper conversion to a `SockAddr`.
-                Some(_) | None => None,
-            }
-        }
-    }
-
-    /// Conversion from nix's SockAddr type to the underlying libc sockaddr type.
-    ///
-    /// This is useful for interfacing with other libc functions that don't yet have nix wrappers.
-    /// Returns a reference to the underlying data type (as a sockaddr reference) along
-    /// with the size of the actual data type. sockaddr is commonly used as a proxy for
-    /// a superclass as C doesn't support inheritance, so many functions that take
-    /// a sockaddr * need to take the size of the underlying type as well and then internally cast it back.
-    pub fn as_ffi_pair(&self) -> (&libc::sockaddr, libc::socklen_t) {
-        match *self {
-            #[cfg(feature = "net")]
-            SockAddr::Inet(InetAddr::V4(ref addr)) => (
-                // This cast is always allowed in C
-                unsafe {
-                    &*(addr as *const libc::sockaddr_in
-                        as *const libc::sockaddr)
-                },
-                mem::size_of_val(addr) as libc::socklen_t,
-            ),
-            #[cfg(feature = "net")]
-            SockAddr::Inet(InetAddr::V6(ref addr)) => (
-                // This cast is always allowed in C
-                unsafe {
-                    &*(addr as *const libc::sockaddr_in6
-                        as *const libc::sockaddr)
-                },
-                mem::size_of_val(addr) as libc::socklen_t,
-            ),
-            SockAddr::Unix(ref unix_addr) => (
-                // This cast is always allowed in C
-                unsafe {
-                    &*(&unix_addr.sun as *const libc::sockaddr_un
-                        as *const libc::sockaddr)
-                },
-                unix_addr.sun_len() as libc::socklen_t,
-            ),
-            #[cfg(any(target_os = "android", target_os = "linux"))]
-            SockAddr::Netlink(NetlinkAddr(ref sa)) => (
-                // This cast is always allowed in C
-                unsafe {
-                    &*(sa as *const libc::sockaddr_nl as *const libc::sockaddr)
-                },
-                mem::size_of_val(sa) as libc::socklen_t,
-            ),
-            #[cfg(any(target_os = "android", target_os = "linux"))]
-            SockAddr::Alg(AlgAddr(ref sa)) => (
-                // This cast is always allowed in C
-                unsafe {
-                    &*(sa as *const libc::sockaddr_alg as *const libc::sockaddr)
-                },
-                mem::size_of_val(sa) as libc::socklen_t,
-            ),
-            #[cfg(all(
-                feature = "ioctl",
-                any(target_os = "ios", target_os = "macos")
-            ))]
-            SockAddr::SysControl(SysControlAddr(ref sa)) => (
-                // This cast is always allowed in C
-                unsafe {
-                    &*(sa as *const libc::sockaddr_ctl as *const libc::sockaddr)
-                },
-                mem::size_of_val(sa) as libc::socklen_t,
-            ),
-            #[cfg(any(target_os = "android", target_os = "linux"))]
-            #[cfg(feature = "net")]
-            SockAddr::Link(LinkAddr(ref addr)) => (
-                // This cast is always allowed in C
-                unsafe {
-                    &*(addr as *const libc::sockaddr_ll
-                        as *const libc::sockaddr)
-                },
-                mem::size_of_val(addr) as libc::socklen_t,
-            ),
-            #[cfg(any(
-                target_os = "dragonfly",
-                target_os = "freebsd",
-                target_os = "ios",
-                target_os = "macos",
-                target_os = "illumos",
-                target_os = "netbsd",
-                target_os = "openbsd"
-            ))]
-            #[cfg(feature = "net")]
-            SockAddr::Link(LinkAddr(ref addr)) => (
-                // This cast is always allowed in C
-                unsafe {
-                    &*(addr as *const libc::sockaddr_dl
-                        as *const libc::sockaddr)
-                },
-                mem::size_of_val(addr) as libc::socklen_t,
-            ),
-            #[cfg(any(target_os = "android", target_os = "linux"))]
-            SockAddr::Vsock(VsockAddr(ref sa)) => (
-                // This cast is always allowed in C
-                unsafe {
-                    &*(sa as *const libc::sockaddr_vm as *const libc::sockaddr)
-                },
-                mem::size_of_val(sa) as libc::socklen_t,
-            ),
-        }
-    }
-}
-
-#[allow(deprecated)]
-impl fmt::Display for SockAddr {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            #[cfg(feature = "net")]
-            SockAddr::Inet(ref inet) => inet.fmt(f),
-            SockAddr::Unix(ref unix) => unix.fmt(f),
-            #[cfg(any(target_os = "android", target_os = "linux"))]
-            SockAddr::Netlink(ref nl) => nl.fmt(f),
-            #[cfg(any(target_os = "android", target_os = "linux"))]
-            SockAddr::Alg(ref nl) => nl.fmt(f),
-            #[cfg(all(
-                feature = "ioctl",
-                any(target_os = "ios", target_os = "macos")
-            ))]
-            SockAddr::SysControl(ref sc) => sc.fmt(f),
-            #[cfg(any(
-                target_os = "android",
-                target_os = "dragonfly",
-                target_os = "freebsd",
-                target_os = "ios",
-                target_os = "linux",
-                target_os = "macos",
-                target_os = "netbsd",
-                target_os = "illumos",
-                target_os = "openbsd"
-            ))]
-            #[cfg(feature = "net")]
-            SockAddr::Link(ref ether_addr) => ether_addr.fmt(f),
-            #[cfg(any(target_os = "android", target_os = "linux"))]
-            SockAddr::Vsock(ref svm) => svm.fmt(f),
-        }
-    }
-}
-
-#[cfg(not(target_os = "fuchsia"))]
-#[cfg(feature = "net")]
-#[allow(deprecated)]
-impl private::SockaddrLikePriv for SockAddr {}
-#[cfg(not(target_os = "fuchsia"))]
-#[cfg(feature = "net")]
-#[allow(deprecated)]
-impl SockaddrLike for SockAddr {
-    unsafe fn from_raw(
-        addr: *const libc::sockaddr,
-        _len: Option<libc::socklen_t>,
-    ) -> Option<Self> {
-        Self::from_libc_sockaddr(addr)
-    }
-}
-
 #[cfg(any(target_os = "android", target_os = "linux"))]
 #[cfg_attr(docsrs, doc(cfg(all())))]
 pub mod netlink {
diff --git a/src/sys/socket/mod.rs b/src/sys/socket/mod.rs
index 154403c5..5a164171 100644
--- a/src/sys/socket/mod.rs
+++ b/src/sys/socket/mod.rs
@@ -12,7 +12,7 @@ use libc::{
     self, c_int, c_void, iovec, size_t, socklen_t, CMSG_DATA, CMSG_FIRSTHDR,
     CMSG_LEN, CMSG_NXTHDR,
 };
-use std::convert::{TryFrom, TryInto};
+use std::convert::TryFrom;
 use std::io::{IoSlice, IoSliceMut};
 #[cfg(feature = "net")]
 use std::net;
@@ -32,32 +32,24 @@ pub mod sockopt;
 
 pub use self::addr::{SockaddrLike, SockaddrStorage};
 
-#[cfg(not(any(target_os = "illumos", target_os = "solaris")))]
-#[allow(deprecated)]
-pub use self::addr::{AddressFamily, SockAddr, UnixAddr};
 #[cfg(any(target_os = "illumos", target_os = "solaris"))]
-#[allow(deprecated)]
-pub use self::addr::{AddressFamily, SockAddr, UnixAddr};
-#[allow(deprecated)]
+pub use self::addr::{AddressFamily, UnixAddr};
+#[cfg(not(any(target_os = "illumos", target_os = "solaris")))]
+pub use self::addr::{AddressFamily, UnixAddr};
 #[cfg(not(any(
     target_os = "illumos",
     target_os = "solaris",
     target_os = "haiku"
 )))]
 #[cfg(feature = "net")]
-pub use self::addr::{
-    InetAddr, IpAddr, Ipv4Addr, Ipv6Addr, LinkAddr, SockaddrIn, SockaddrIn6,
-};
-#[allow(deprecated)]
+pub use self::addr::{LinkAddr, SockaddrIn, SockaddrIn6};
 #[cfg(any(
     target_os = "illumos",
     target_os = "solaris",
     target_os = "haiku"
 ))]
 #[cfg(feature = "net")]
-pub use self::addr::{
-    InetAddr, IpAddr, Ipv4Addr, Ipv6Addr, SockaddrIn, SockaddrIn6,
-};
+pub use self::addr::{SockaddrIn, SockaddrIn6};
 
 #[cfg(any(target_os = "android", target_os = "linux"))]
 pub use crate::sys::socket::addr::alg::AlgAddr;
@@ -121,7 +113,7 @@ impl TryFrom<i32> for SockType {
             libc::SOCK_RAW => Ok(Self::Raw),
             #[cfg(not(any(target_os = "haiku")))]
             libc::SOCK_RDM => Ok(Self::Rdm),
-            _ => Err(Errno::EINVAL)
+            _ => Err(Errno::EINVAL),
         }
     }
 }
@@ -2376,81 +2368,6 @@ pub fn getsockname<T: SockaddrLike>(fd: RawFd) -> Result<T> {
     }
 }
 
-/// Return the appropriate `SockAddr` type from a `sockaddr_storage` of a
-/// certain size.
-///
-/// In C this would usually be done by casting.  The `len` argument
-/// should be the number of bytes in the `sockaddr_storage` that are actually
-/// allocated and valid.  It must be at least as large as all the useful parts
-/// of the structure.  Note that in the case of a `sockaddr_un`, `len` need not
-/// include the terminating null.
-#[deprecated(
-    since = "0.24.0",
-    note = "use SockaddrLike or SockaddrStorage instead"
-)]
-#[allow(deprecated)]
-pub fn sockaddr_storage_to_addr(
-    addr: &sockaddr_storage,
-    len: usize,
-) -> Result<SockAddr> {
-    assert!(len <= mem::size_of::<sockaddr_storage>());
-    if len < mem::size_of_val(&addr.ss_family) {
-        return Err(Errno::ENOTCONN);
-    }
-
-    match c_int::from(addr.ss_family) {
-        #[cfg(feature = "net")]
-        libc::AF_INET => {
-            assert!(len >= mem::size_of::<sockaddr_in>());
-            let sin = unsafe {
-                *(addr as *const sockaddr_storage as *const sockaddr_in)
-            };
-            Ok(SockAddr::Inet(InetAddr::V4(sin)))
-        }
-        #[cfg(feature = "net")]
-        libc::AF_INET6 => {
-            assert!(len >= mem::size_of::<sockaddr_in6>());
-            let sin6 = unsafe { *(addr as *const _ as *const sockaddr_in6) };
-            Ok(SockAddr::Inet(InetAddr::V6(sin6)))
-        }
-        libc::AF_UNIX => unsafe {
-            let sun = *(addr as *const _ as *const sockaddr_un);
-            let sun_len = len.try_into().unwrap();
-            Ok(SockAddr::Unix(UnixAddr::from_raw_parts(sun, sun_len)))
-        },
-        #[cfg(any(target_os = "android", target_os = "linux"))]
-        #[cfg(feature = "net")]
-        libc::AF_PACKET => {
-            use libc::sockaddr_ll;
-            // Don't assert anything about the size.
-            // Apparently the Linux kernel can return smaller sizes when
-            // the value in the last element of sockaddr_ll (`sll_addr`) is
-            // smaller than the declared size of that field
-            let sll = unsafe { *(addr as *const _ as *const sockaddr_ll) };
-            Ok(SockAddr::Link(LinkAddr(sll)))
-        }
-        #[cfg(any(target_os = "android", target_os = "linux"))]
-        libc::AF_NETLINK => {
-            use libc::sockaddr_nl;
-            let snl = unsafe { *(addr as *const _ as *const sockaddr_nl) };
-            Ok(SockAddr::Netlink(NetlinkAddr(snl)))
-        }
-        #[cfg(any(target_os = "android", target_os = "linux"))]
-        libc::AF_ALG => {
-            use libc::sockaddr_alg;
-            let salg = unsafe { *(addr as *const _ as *const sockaddr_alg) };
-            Ok(SockAddr::Alg(AlgAddr(salg)))
-        }
-        #[cfg(any(target_os = "android", target_os = "linux"))]
-        libc::AF_VSOCK => {
-            use libc::sockaddr_vm;
-            let svm = unsafe { *(addr as *const _ as *const sockaddr_vm) };
-            Ok(SockAddr::Vsock(VsockAddr(svm)))
-        }
-        af => panic!("unexpected address family {}", af),
-    }
-}
-
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
 pub enum Shutdown {
     /// Further receptions will be disallowed.
@@ -2485,7 +2402,11 @@ mod tests {
         let _ = cmsg_space!(u8);
     }
 
-    #[cfg(not(any(target_os = "redox", target_os = "linux", target_os = "android")))]
+    #[cfg(not(any(
+        target_os = "redox",
+        target_os = "linux",
+        target_os = "android"
+    )))]
     #[test]
     fn can_open_routing_socket() {
         let _ = super::socket(