Merging upstream version 1.67.1+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

8 files changed, 2560 insertions, 0 deletions

diff --git a/vendor/rustix/src/backend/libc/net/addr.rs b/vendor/rustix/src/backend/libc/net/addr.rs
new file mode 100644
index 000000000..ba64ed279
--- /dev/null
+++ b/vendor/rustix/src/backend/libc/net/addr.rs
@@ -0,0 +1,330 @@
+//! IPv4, IPv6, and Socket addresses.
+
+use super::super::c;
+#[cfg(unix)]
+use crate::ffi::CStr;
+#[cfg(unix)]
+use crate::io;
+#[cfg(unix)]
+use crate::path;
+#[cfg(not(windows))]
+use core::convert::TryInto;
+#[cfg(unix)]
+use core::fmt;
+#[cfg(unix)]
+use core::slice;
+
+/// `struct sockaddr_un`
+#[cfg(unix)]
+#[derive(Clone)]
+#[doc(alias = "sockaddr_un")]
+pub struct SocketAddrUnix {
+    pub(crate) unix: c::sockaddr_un,
+    #[cfg(not(any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    )))]
+    len: c::socklen_t,
+}
+
+#[cfg(unix)]
+impl SocketAddrUnix {
+    /// Construct a new Unix-domain address from a filesystem path.
+    #[inline]
+    pub fn new<P: path::Arg>(path: P) -> io::Result<Self> {
+        path.into_with_c_str(Self::_new)
+    }
+
+    #[inline]
+    fn _new(path: &CStr) -> io::Result<Self> {
+        let mut unix = Self::init();
+        let bytes = path.to_bytes_with_nul();
+        if bytes.len() > unix.sun_path.len() {
+            return Err(io::Errno::NAMETOOLONG);
+        }
+        for (i, b) in bytes.iter().enumerate() {
+            unix.sun_path[i] = *b as c::c_char;
+        }
+
+        #[cfg(any(
+            target_os = "dragonfly",
+            target_os = "freebsd",
+            target_os = "ios",
+            target_os = "macos",
+            target_os = "netbsd",
+            target_os = "openbsd",
+        ))]
+        {
+            unix.sun_len = (offsetof_sun_path() + bytes.len()).try_into().unwrap();
+        }
+
+        Ok(Self {
+            unix,
+            #[cfg(not(any(
+                target_os = "dragonfly",
+                target_os = "freebsd",
+                target_os = "ios",
+                target_os = "macos",
+                target_os = "netbsd",
+                target_os = "openbsd",
+            )))]
+            len: (offsetof_sun_path() + bytes.len()).try_into().unwrap(),
+        })
+    }
+
+    /// Construct a new abstract Unix-domain address from a byte slice.
+    #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[inline]
+    pub fn new_abstract_name(name: &[u8]) -> io::Result<Self> {
+        let mut unix = Self::init();
+        if 1 + name.len() > unix.sun_path.len() {
+            return Err(io::Errno::NAMETOOLONG);
+        }
+        unix.sun_path[0] = b'\0' as c::c_char;
+        for (i, b) in name.iter().enumerate() {
+            unix.sun_path[1 + i] = *b as c::c_char;
+        }
+        let len = offsetof_sun_path() + 1 + name.len();
+        let len = len.try_into().unwrap();
+        Ok(Self {
+            unix,
+            #[cfg(not(any(
+                target_os = "dragonfly",
+                target_os = "freebsd",
+                target_os = "ios",
+                target_os = "macos",
+                target_os = "netbsd",
+                target_os = "openbsd",
+            )))]
+            len,
+        })
+    }
+
+    fn init() -> c::sockaddr_un {
+        c::sockaddr_un {
+            #[cfg(any(
+                target_os = "dragonfly",
+                target_os = "freebsd",
+                target_os = "haiku",
+                target_os = "ios",
+                target_os = "macos",
+                target_os = "netbsd",
+                target_os = "openbsd",
+            ))]
+            sun_len: 0,
+            sun_family: c::AF_UNIX as _,
+            #[cfg(any(
+                target_os = "dragonfly",
+                target_os = "freebsd",
+                target_os = "ios",
+                target_os = "macos",
+                target_os = "netbsd",
+                target_os = "openbsd",
+            ))]
+            sun_path: [0; 104],
+            #[cfg(not(any(
+                target_os = "dragonfly",
+                target_os = "freebsd",
+                target_os = "haiku",
+                target_os = "ios",
+                target_os = "macos",
+                target_os = "netbsd",
+                target_os = "openbsd",
+            )))]
+            sun_path: [0; 108],
+            #[cfg(target_os = "haiku")]
+            sun_path: [0; 126],
+        }
+    }
+
+    /// For a filesystem path address, return the path.
+    #[inline]
+    pub fn path(&self) -> Option<&CStr> {
+        let len = self.len();
+        if len != 0 && self.unix.sun_path[0] != b'\0' as c::c_char {
+            let end = len as usize - offsetof_sun_path();
+            let bytes = &self.unix.sun_path[..end];
+            // Safety: `from_raw_parts` to convert from `&[c_char]` to `&[u8]`. And
+            // `from_bytes_with_nul_unchecked` since the string is NUL-terminated.
+            unsafe {
+                Some(CStr::from_bytes_with_nul_unchecked(slice::from_raw_parts(
+                    bytes.as_ptr().cast(),
+                    bytes.len(),
+                )))
+            }
+        } else {
+            None
+        }
+    }
+
+    /// For an abstract address, return the identifier.
+    #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[inline]
+    pub fn abstract_name(&self) -> Option<&[u8]> {
+        let len = self.len();
+        if len != 0 && self.unix.sun_path[0] == b'\0' as c::c_char {
+            let end = len as usize - offsetof_sun_path();
+            let bytes = &self.unix.sun_path[1..end];
+            // Safety: `from_raw_parts` to convert from `&[c_char]` to `&[u8]`.
+            unsafe { Some(slice::from_raw_parts(bytes.as_ptr().cast(), bytes.len())) }
+        } else {
+            None
+        }
+    }
+
+    #[inline]
+    pub(crate) fn addr_len(&self) -> c::socklen_t {
+        #[cfg(not(any(
+            target_os = "dragonfly",
+            target_os = "freebsd",
+            target_os = "ios",
+            target_os = "macos",
+            target_os = "netbsd",
+            target_os = "openbsd",
+        )))]
+        {
+            self.len
+        }
+        #[cfg(any(
+            target_os = "dragonfly",
+            target_os = "freebsd",
+            target_os = "ios",
+            target_os = "macos",
+            target_os = "netbsd",
+            target_os = "openbsd",
+        ))]
+        {
+            c::socklen_t::from(self.unix.sun_len)
+        }
+    }
+
+    #[inline]
+    pub(crate) fn len(&self) -> usize {
+        self.addr_len() as usize
+    }
+}
+
+#[cfg(unix)]
+impl PartialEq for SocketAddrUnix {
+    #[inline]
+    fn eq(&self, other: &Self) -> bool {
+        let self_len = self.len() - offsetof_sun_path();
+        let other_len = other.len() - offsetof_sun_path();
+        self.unix.sun_path[..self_len].eq(&other.unix.sun_path[..other_len])
+    }
+}
+
+#[cfg(unix)]
+impl Eq for SocketAddrUnix {}
+
+#[cfg(unix)]
+impl PartialOrd for SocketAddrUnix {
+    #[inline]
+    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
+        let self_len = self.len() - offsetof_sun_path();
+        let other_len = other.len() - offsetof_sun_path();
+        self.unix.sun_path[..self_len].partial_cmp(&other.unix.sun_path[..other_len])
+    }
+}
+
+#[cfg(unix)]
+impl Ord for SocketAddrUnix {
+    #[inline]
+    fn cmp(&self, other: &Self) -> core::cmp::Ordering {
+        let self_len = self.len() - offsetof_sun_path();
+        let other_len = other.len() - offsetof_sun_path();
+        self.unix.sun_path[..self_len].cmp(&other.unix.sun_path[..other_len])
+    }
+}
+
+#[cfg(unix)]
+impl core::hash::Hash for SocketAddrUnix {
+    #[inline]
+    fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
+        let self_len = self.len() - offsetof_sun_path();
+        self.unix.sun_path[..self_len].hash(state)
+    }
+}
+
+#[cfg(unix)]
+impl fmt::Debug for SocketAddrUnix {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if let Some(path) = self.path() {
+            path.fmt(fmt)
+        } else {
+            #[cfg(any(target_os = "android", target_os = "linux"))]
+            if let Some(name) = self.abstract_name() {
+                return name.fmt(fmt);
+            }
+
+            "(unnamed)".fmt(fmt)
+        }
+    }
+}
+
+/// `struct sockaddr_storage` as a raw struct.
+pub type SocketAddrStorage = c::sockaddr_storage;
+
+/// Return the offset of the `sun_path` field of `sockaddr_un`.
+#[cfg(not(windows))]
+#[inline]
+pub(crate) fn offsetof_sun_path() -> usize {
+    let z = c::sockaddr_un {
+        #[cfg(any(
+            target_os = "dragonfly",
+            target_os = "freebsd",
+            target_os = "haiku",
+            target_os = "ios",
+            target_os = "macos",
+            target_os = "netbsd",
+            target_os = "openbsd",
+        ))]
+        sun_len: 0_u8,
+        #[cfg(any(
+            target_os = "dragonfly",
+            target_os = "freebsd",
+            target_os = "haiku",
+            target_os = "ios",
+            target_os = "macos",
+            target_os = "netbsd",
+            target_os = "openbsd",
+        ))]
+        sun_family: 0_u8,
+        #[cfg(not(any(
+            target_os = "dragonfly",
+            target_os = "freebsd",
+            target_os = "haiku",
+            target_os = "ios",
+            target_os = "macos",
+            target_os = "netbsd",
+            target_os = "openbsd",
+        )))]
+        sun_family: 0_u16,
+        #[cfg(any(
+            target_os = "dragonfly",
+            target_os = "freebsd",
+            target_os = "ios",
+            target_os = "macos",
+            target_os = "netbsd",
+            target_os = "openbsd",
+        ))]
+        sun_path: [0; 104],
+        #[cfg(not(any(
+            target_os = "dragonfly",
+            target_os = "freebsd",
+            target_os = "haiku",
+            target_os = "ios",
+            target_os = "macos",
+            target_os = "netbsd",
+            target_os = "openbsd",
+        )))]
+        sun_path: [0; 108],
+        #[cfg(target_os = "haiku")]
+        sun_path: [0; 126],
+    };
+    (crate::utils::as_ptr(&z.sun_path) as usize) - (crate::utils::as_ptr(&z) as usize)
+}
diff --git a/vendor/rustix/src/backend/libc/net/ext.rs b/vendor/rustix/src/backend/libc/net/ext.rs
new file mode 100644
index 000000000..1c8f9f65c
--- /dev/null
+++ b/vendor/rustix/src/backend/libc/net/ext.rs
@@ -0,0 +1,210 @@
+use super::super::c;
+
+/// The windows `sockaddr_in6` type is a union with accessor functions which
+/// are not `const fn`. Define our own layout-compatible version so that we
+/// can transmute in and out of it.
+#[cfg(windows)]
+#[repr(C)]
+struct sockaddr_in6 {
+    sin6_family: u16,
+    sin6_port: u16,
+    sin6_flowinfo: u32,
+    sin6_addr: c::in6_addr,
+    sin6_scope_id: u32,
+}
+
+#[cfg(not(windows))]
+#[inline]
+pub(crate) const fn in_addr_s_addr(addr: c::in_addr) -> u32 {
+    addr.s_addr
+}
+
+#[cfg(not(feature = "std"))]
+#[cfg(windows)]
+#[inline]
+pub(crate) const fn in_addr_s_addr(addr: c::in_addr) -> u32 {
+    // This should be `*addr.S_un.S_addr()`, except that isn't a `const fn`.
+    unsafe { core::mem::transmute(addr) }
+}
+
+// TODO: With Rust 1.55, we can use the above `in_addr_s_addr` definition that
+// uses a const-fn transmute.
+#[cfg(feature = "std")]
+#[cfg(windows)]
+#[inline]
+pub(crate) fn in_addr_s_addr(addr: c::in_addr) -> u32 {
+    // This should be `*addr.S_un.S_addr()`, except that isn't a `const fn`.
+    unsafe { core::mem::transmute(addr) }
+}
+
+#[cfg(not(windows))]
+#[inline]
+pub(crate) const fn in_addr_new(s_addr: u32) -> c::in_addr {
+    c::in_addr { s_addr }
+}
+
+#[cfg(not(feature = "std"))]
+#[cfg(windows)]
+#[inline]
+pub(crate) const fn in_addr_new(s_addr: u32) -> c::in_addr {
+    unsafe { core::mem::transmute(s_addr) }
+}
+
+// TODO: With Rust 1.55, we can use the above `in_addr_new` definition that
+// uses a const-fn transmute.
+#[cfg(feature = "std")]
+#[cfg(windows)]
+#[inline]
+pub(crate) fn in_addr_new(s_addr: u32) -> c::in_addr {
+    unsafe { core::mem::transmute(s_addr) }
+}
+
+#[cfg(not(windows))]
+#[inline]
+pub(crate) const fn in6_addr_s6_addr(addr: c::in6_addr) -> [u8; 16] {
+    addr.s6_addr
+}
+
+#[cfg(not(feature = "std"))]
+#[cfg(windows)]
+#[inline]
+pub(crate) const fn in6_addr_s6_addr(addr: c::in6_addr) -> [u8; 16] {
+    unsafe { core::mem::transmute(addr) }
+}
+
+// TODO: With Rust 1.55, we can use the above `in6_addr_s6_addr` definition
+// that uses a const-fn transmute.
+#[cfg(feature = "std")]
+#[cfg(windows)]
+#[inline]
+pub(crate) fn in6_addr_s6_addr(addr: c::in6_addr) -> [u8; 16] {
+    unsafe { core::mem::transmute(addr) }
+}
+
+#[cfg(not(windows))]
+#[inline]
+pub(crate) const fn in6_addr_new(s6_addr: [u8; 16]) -> c::in6_addr {
+    c::in6_addr { s6_addr }
+}
+
+#[cfg(not(feature = "std"))]
+#[cfg(windows)]
+#[inline]
+pub(crate) const fn in6_addr_new(s6_addr: [u8; 16]) -> c::in6_addr {
+    unsafe { core::mem::transmute(s6_addr) }
+}
+
+// TODO: With Rust 1.55, we can use the above `in6_addr_new` definition that
+// uses a const-fn transmute.
+#[cfg(feature = "std")]
+#[cfg(windows)]
+#[inline]
+pub(crate) fn in6_addr_new(s6_addr: [u8; 16]) -> c::in6_addr {
+    unsafe { core::mem::transmute(s6_addr) }
+}
+
+#[cfg(not(windows))]
+#[inline]
+pub(crate) const fn sockaddr_in6_sin6_scope_id(addr: c::sockaddr_in6) -> u32 {
+    addr.sin6_scope_id
+}
+
+#[cfg(not(feature = "std"))]
+#[cfg(windows)]
+#[inline]
+pub(crate) const fn sockaddr_in6_sin6_scope_id(addr: c::sockaddr_in6) -> u32 {
+    let addr: sockaddr_in6 = unsafe { core::mem::transmute(addr) };
+    addr.sin6_scope_id
+}
+
+// TODO: With Rust 1.55, we can use the above `sockaddr_in6_sin6_scope_id`
+// definition that uses a const-fn transmute.
+#[cfg(feature = "std")]
+#[cfg(windows)]
+#[inline]
+pub(crate) fn sockaddr_in6_sin6_scope_id(addr: c::sockaddr_in6) -> u32 {
+    let addr: sockaddr_in6 = unsafe { core::mem::transmute(addr) };
+    addr.sin6_scope_id
+}
+
+#[cfg(not(windows))]
+#[inline]
+pub(crate) const fn sockaddr_in6_new(
+    #[cfg(any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "haiku",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    ))]
+    sin6_len: u8,
+    sin6_family: c::sa_family_t,
+    sin6_port: u16,
+    sin6_flowinfo: u32,
+    sin6_addr: c::in6_addr,
+    sin6_scope_id: u32,
+) -> c::sockaddr_in6 {
+    c::sockaddr_in6 {
+        #[cfg(any(
+            target_os = "dragonfly",
+            target_os = "freebsd",
+            target_os = "haiku",
+            target_os = "ios",
+            target_os = "macos",
+            target_os = "netbsd",
+            target_os = "openbsd",
+        ))]
+        sin6_len,
+        sin6_family,
+        sin6_port,
+        sin6_flowinfo,
+        sin6_addr,
+        sin6_scope_id,
+        #[cfg(any(target_os = "illumos", target_os = "solaris"))]
+        __sin6_src_id: 0,
+    }
+}
+
+#[cfg(not(feature = "std"))]
+#[cfg(windows)]
+#[inline]
+pub(crate) const fn sockaddr_in6_new(
+    sin6_family: u16,
+    sin6_port: u16,
+    sin6_flowinfo: u32,
+    sin6_addr: c::in6_addr,
+    sin6_scope_id: u32,
+) -> c::sockaddr_in6 {
+    let addr = sockaddr_in6 {
+        sin6_family,
+        sin6_port,
+        sin6_flowinfo,
+        sin6_addr,
+        sin6_scope_id,
+    };
+    unsafe { core::mem::transmute(addr) }
+}
+
+// TODO: With Rust 1.55, we can use the above `sockaddr_in6_new` definition
+// that uses a const-fn transmute.
+#[cfg(feature = "std")]
+#[cfg(windows)]
+#[inline]
+pub(crate) fn sockaddr_in6_new(
+    sin6_family: u16,
+    sin6_port: u16,
+    sin6_flowinfo: u32,
+    sin6_addr: c::in6_addr,
+    sin6_scope_id: u32,
+) -> c::sockaddr_in6 {
+    let addr = sockaddr_in6 {
+        sin6_family,
+        sin6_port,
+        sin6_flowinfo,
+        sin6_addr,
+        sin6_scope_id,
+    };
+    unsafe { core::mem::transmute(addr) }
+}
diff --git a/vendor/rustix/src/backend/libc/net/mod.rs b/vendor/rustix/src/backend/libc/net/mod.rs
new file mode 100644
index 000000000..f7196ae4f
--- /dev/null
+++ b/vendor/rustix/src/backend/libc/net/mod.rs
@@ -0,0 +1,7 @@
+pub(crate) mod addr;
+pub(crate) mod ext;
+pub(crate) mod read_sockaddr;
+pub(crate) mod send_recv;
+pub(crate) mod syscalls;
+pub(crate) mod types;
+pub(crate) mod write_sockaddr;
diff --git a/vendor/rustix/src/backend/libc/net/read_sockaddr.rs b/vendor/rustix/src/backend/libc/net/read_sockaddr.rs
new file mode 100644
index 000000000..5a946fbeb
--- /dev/null
+++ b/vendor/rustix/src/backend/libc/net/read_sockaddr.rs
@@ -0,0 +1,255 @@
+use super::super::c;
+#[cfg(unix)]
+use super::addr::SocketAddrUnix;
+use super::ext::{in6_addr_s6_addr, in_addr_s_addr, sockaddr_in6_sin6_scope_id};
+#[cfg(not(windows))]
+use crate::ffi::CStr;
+use crate::io;
+use crate::net::{Ipv4Addr, Ipv6Addr, SocketAddrAny, SocketAddrV4, SocketAddrV6};
+#[cfg(not(windows))]
+use alloc::vec::Vec;
+use core::mem::size_of;
+
+// This must match the header of `sockaddr`.
+#[repr(C)]
+struct sockaddr_header {
+    #[cfg(any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    ))]
+    sa_len: u8,
+    #[cfg(any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    ))]
+    ss_family: u8,
+    #[cfg(not(any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    )))]
+    ss_family: u16,
+}
+
+#[inline]
+unsafe fn read_ss_family(storage: *const c::sockaddr_storage) -> u16 {
+    // Assert that we know the layout of `sockaddr`.
+    let _ = c::sockaddr {
+        #[cfg(any(
+            target_os = "dragonfly",
+            target_os = "freebsd",
+            target_os = "haiku",
+            target_os = "ios",
+            target_os = "macos",
+            target_os = "netbsd",
+            target_os = "openbsd",
+        ))]
+        sa_len: 0_u8,
+        #[cfg(any(
+            target_os = "dragonfly",
+            target_os = "freebsd",
+            target_os = "haiku",
+            target_os = "ios",
+            target_os = "macos",
+            target_os = "netbsd",
+            target_os = "openbsd",
+        ))]
+        sa_family: 0_u8,
+        #[cfg(not(any(
+            target_os = "dragonfly",
+            target_os = "freebsd",
+            target_os = "haiku",
+            target_os = "ios",
+            target_os = "macos",
+            target_os = "netbsd",
+            target_os = "openbsd",
+        )))]
+        sa_family: 0_u16,
+        #[cfg(not(target_os = "haiku"))]
+        sa_data: [0; 14],
+        #[cfg(target_os = "haiku")]
+        sa_data: [0; 30],
+    };
+
+    (*storage.cast::<sockaddr_header>()).ss_family.into()
+}
+
+/// Set the `ss_family` field of a socket address to `AF_UNSPEC`, so that we
+/// can test for `AF_UNSPEC` to test whether it was stored to.
+pub(crate) unsafe fn initialize_family_to_unspec(storage: *mut c::sockaddr_storage) {
+    (*storage.cast::<sockaddr_header>()).ss_family = c::AF_UNSPEC as _;
+}
+
+pub(crate) unsafe fn read_sockaddr(
+    storage: *const c::sockaddr_storage,
+    len: usize,
+) -> io::Result<SocketAddrAny> {
+    #[cfg(unix)]
+    let offsetof_sun_path = super::addr::offsetof_sun_path();
+
+    if len < size_of::<c::sa_family_t>() {
+        return Err(io::Errno::INVAL);
+    }
+    match read_ss_family(storage).into() {
+        c::AF_INET => {
+            if len < size_of::<c::sockaddr_in>() {
+                return Err(io::Errno::INVAL);
+            }
+            let decode = *storage.cast::<c::sockaddr_in>();
+            Ok(SocketAddrAny::V4(SocketAddrV4::new(
+                Ipv4Addr::from(u32::from_be(in_addr_s_addr(decode.sin_addr))),
+                u16::from_be(decode.sin_port),
+            )))
+        }
+        c::AF_INET6 => {
+            if len < size_of::<c::sockaddr_in6>() {
+                return Err(io::Errno::INVAL);
+            }
+            let decode = *storage.cast::<c::sockaddr_in6>();
+            #[cfg(not(windows))]
+            let s6_addr = decode.sin6_addr.s6_addr;
+            #[cfg(windows)]
+            let s6_addr = decode.sin6_addr.u.Byte;
+            #[cfg(not(windows))]
+            let sin6_scope_id = decode.sin6_scope_id;
+            #[cfg(windows)]
+            let sin6_scope_id = decode.Anonymous.sin6_scope_id;
+            Ok(SocketAddrAny::V6(SocketAddrV6::new(
+                Ipv6Addr::from(s6_addr),
+                u16::from_be(decode.sin6_port),
+                u32::from_be(decode.sin6_flowinfo),
+                sin6_scope_id,
+            )))
+        }
+        #[cfg(unix)]
+        c::AF_UNIX => {
+            if len < offsetof_sun_path {
+                return Err(io::Errno::INVAL);
+            }
+            if len == offsetof_sun_path {
+                Ok(SocketAddrAny::Unix(SocketAddrUnix::new(&[][..]).unwrap()))
+            } else {
+                let decode = *storage.cast::<c::sockaddr_un>();
+
+                // Trim off unused bytes from the end of `path_bytes`.
+                let path_bytes = if cfg!(target_os = "freebsd") {
+                    // FreeBSD sometimes sets the length to longer than the length
+                    // of the NUL-terminated string. Find the NUL and truncate the
+                    // string accordingly.
+                    &decode.sun_path[..decode.sun_path.iter().position(|b| *b == 0).unwrap()]
+                } else {
+                    // Otherwise, use the provided length.
+                    let provided_len = len - 1 - offsetof_sun_path;
+                    if decode.sun_path[provided_len] != b'\0' as c::c_char {
+                        return Err(io::Errno::INVAL);
+                    }
+                    debug_assert_eq!(
+                        CStr::from_ptr(decode.sun_path.as_ptr()).to_bytes().len(),
+                        provided_len
+                    );
+                    &decode.sun_path[..provided_len]
+                };
+
+                Ok(SocketAddrAny::Unix(
+                    SocketAddrUnix::new(path_bytes.iter().map(|c| *c as u8).collect::<Vec<u8>>())
+                        .unwrap(),
+                ))
+            }
+        }
+        _ => Err(io::Errno::INVAL),
+    }
+}
+
+pub(crate) unsafe fn maybe_read_sockaddr_os(
+    storage: *const c::sockaddr_storage,
+    len: usize,
+) -> Option<SocketAddrAny> {
+    if len == 0 {
+        return None;
+    }
+
+    assert!(len >= size_of::<c::sa_family_t>());
+    let family = read_ss_family(storage).into();
+    if family == c::AF_UNSPEC {
+        None
+    } else {
+        Some(inner_read_sockaddr_os(family, storage, len))
+    }
+}
+
+pub(crate) unsafe fn read_sockaddr_os(
+    storage: *const c::sockaddr_storage,
+    len: usize,
+) -> SocketAddrAny {
+    assert!(len >= size_of::<c::sa_family_t>());
+    let family = read_ss_family(storage).into();
+    inner_read_sockaddr_os(family, storage, len)
+}
+
+unsafe fn inner_read_sockaddr_os(
+    family: c::c_int,
+    storage: *const c::sockaddr_storage,
+    len: usize,
+) -> SocketAddrAny {
+    #[cfg(unix)]
+    let offsetof_sun_path = super::addr::offsetof_sun_path();
+
+    assert!(len >= size_of::<c::sa_family_t>());
+    match family {
+        c::AF_INET => {
+            assert!(len >= size_of::<c::sockaddr_in>());
+            let decode = *storage.cast::<c::sockaddr_in>();
+            SocketAddrAny::V4(SocketAddrV4::new(
+                Ipv4Addr::from(u32::from_be(in_addr_s_addr(decode.sin_addr))),
+                u16::from_be(decode.sin_port),
+            ))
+        }
+        c::AF_INET6 => {
+            assert!(len >= size_of::<c::sockaddr_in6>());
+            let decode = *storage.cast::<c::sockaddr_in6>();
+            SocketAddrAny::V6(SocketAddrV6::new(
+                Ipv6Addr::from(in6_addr_s6_addr(decode.sin6_addr)),
+                u16::from_be(decode.sin6_port),
+                u32::from_be(decode.sin6_flowinfo),
+                sockaddr_in6_sin6_scope_id(decode),
+            ))
+        }
+        #[cfg(unix)]
+        c::AF_UNIX => {
+            assert!(len >= offsetof_sun_path);
+            if len == offsetof_sun_path {
+                SocketAddrAny::Unix(SocketAddrUnix::new(&[][..]).unwrap())
+            } else {
+                let decode = *storage.cast::<c::sockaddr_un>();
+                assert_eq!(
+                    decode.sun_path[len - 1 - offsetof_sun_path],
+                    b'\0' as c::c_char
+                );
+                let path_bytes = &decode.sun_path[..len - 1 - offsetof_sun_path];
+
+                // FreeBSD sometimes sets the length to longer than the length
+                // of the NUL-terminated string. Find the NUL and truncate the
+                // string accordingly.
+                #[cfg(target_os = "freebsd")]
+                let path_bytes = &path_bytes[..path_bytes.iter().position(|b| *b == 0).unwrap()];
+
+                SocketAddrAny::Unix(
+                    SocketAddrUnix::new(path_bytes.iter().map(|c| *c as u8).collect::<Vec<u8>>())
+                        .unwrap(),
+                )
+            }
+        }
+        other => unimplemented!("{:?}", other),
+    }
+}
diff --git a/vendor/rustix/src/backend/libc/net/send_recv.rs b/vendor/rustix/src/backend/libc/net/send_recv.rs
new file mode 100644
index 000000000..8d1cc8ab7
--- /dev/null
+++ b/vendor/rustix/src/backend/libc/net/send_recv.rs
@@ -0,0 +1,83 @@
+use super::super::c;
+use bitflags::bitflags;
+
+bitflags! {
+    /// `MSG_*`
+    pub struct SendFlags: i32 {
+        /// `MSG_CONFIRM`
+        #[cfg(not(any(
+            windows,
+            target_os = "dragonfly",
+            target_os = "freebsd",
+            target_os = "haiku",
+            target_os = "illumos",
+            target_os = "ios",
+            target_os = "macos",
+            target_os = "netbsd",
+            target_os = "openbsd",
+            target_os = "solaris",
+        )))]
+        const CONFIRM = c::MSG_CONFIRM;
+        /// `MSG_DONTROUTE`
+        const DONTROUTE = c::MSG_DONTROUTE;
+        /// `MSG_DONTWAIT`
+        #[cfg(not(windows))]
+        const DONTWAIT = c::MSG_DONTWAIT;
+        /// `MSG_EOR`
+        #[cfg(not(windows))]
+        const EOT = c::MSG_EOR;
+        /// `MSG_MORE`
+        #[cfg(not(any(
+            windows,
+            target_os = "dragonfly",
+            target_os = "freebsd",
+            target_os = "haiku",
+            target_os = "illumos",
+            target_os = "ios",
+            target_os = "macos",
+            target_os = "netbsd",
+            target_os = "openbsd",
+            target_os = "solaris",
+        )))]
+        const MORE = c::MSG_MORE;
+        #[cfg(not(any(windows, target_os = "ios", target_os = "macos")))]
+        /// `MSG_NOSIGNAL`
+        const NOSIGNAL = c::MSG_NOSIGNAL;
+        /// `MSG_OOB`
+        const OOB = c::MSG_OOB;
+    }
+}
+
+bitflags! {
+    /// `MSG_*`
+    pub struct RecvFlags: i32 {
+        #[cfg(not(any(windows, target_os = "haiku", target_os = "illumos", target_os = "ios", target_os = "macos", target_os = "solaris")))]
+        /// `MSG_CMSG_CLOEXEC`
+        const CMSG_CLOEXEC = c::MSG_CMSG_CLOEXEC;
+        /// `MSG_DONTWAIT`
+        #[cfg(not(windows))]
+        const DONTWAIT = c::MSG_DONTWAIT;
+        /// `MSG_ERRQUEUE`
+        #[cfg(not(any(
+            windows,
+            target_os = "dragonfly",
+            target_os = "freebsd",
+            target_os = "haiku",
+            target_os = "illumos",
+            target_os = "ios",
+            target_os = "macos",
+            target_os = "netbsd",
+            target_os = "openbsd",
+            target_os = "solaris",
+        )))]
+        const ERRQUEUE = c::MSG_ERRQUEUE;
+        /// `MSG_OOB`
+        const OOB = c::MSG_OOB;
+        /// `MSG_PEEK`
+        const PEEK = c::MSG_PEEK;
+        /// `MSG_TRUNC`
+        const TRUNC = c::MSG_TRUNC as c::c_int;
+        /// `MSG_WAITALL`
+        const WAITALL = c::MSG_WAITALL;
+    }
+}
diff --git a/vendor/rustix/src/backend/libc/net/syscalls.rs b/vendor/rustix/src/backend/libc/net/syscalls.rs
new file mode 100644
index 000000000..3d8a849c7
--- /dev/null
+++ b/vendor/rustix/src/backend/libc/net/syscalls.rs
@@ -0,0 +1,886 @@
+//! libc syscalls supporting `rustix::net`.
+
+use super::super::c;
+use super::super::conv::{borrowed_fd, ret, ret_owned_fd, ret_send_recv, send_recv_len};
+#[cfg(unix)]
+use super::addr::SocketAddrUnix;
+use super::ext::{in6_addr_new, in_addr_new};
+#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
+use super::read_sockaddr::initialize_family_to_unspec;
+#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
+use super::read_sockaddr::{maybe_read_sockaddr_os, read_sockaddr_os};
+#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
+use super::send_recv::{RecvFlags, SendFlags};
+#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
+use super::types::{AcceptFlags, AddressFamily, Protocol, Shutdown, SocketFlags, SocketType};
+#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
+use super::write_sockaddr::{encode_sockaddr_v4, encode_sockaddr_v6};
+use crate::fd::{BorrowedFd, OwnedFd};
+use crate::io;
+use crate::net::{SocketAddrAny, SocketAddrV4, SocketAddrV6};
+use crate::utils::as_ptr;
+use core::convert::TryInto;
+use core::mem::{size_of, MaybeUninit};
+#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
+use core::ptr::null_mut;
+
+#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
+pub(crate) fn recv(fd: BorrowedFd<'_>, buf: &mut [u8], flags: RecvFlags) -> io::Result<usize> {
+    let nrecv = unsafe {
+        ret_send_recv(c::recv(
+            borrowed_fd(fd),
+            buf.as_mut_ptr().cast(),
+            send_recv_len(buf.len()),
+            flags.bits(),
+        ))?
+    };
+    Ok(nrecv as usize)
+}
+
+#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
+pub(crate) fn send(fd: BorrowedFd<'_>, buf: &[u8], flags: SendFlags) -> io::Result<usize> {
+    let nwritten = unsafe {
+        ret_send_recv(c::send(
+            borrowed_fd(fd),
+            buf.as_ptr().cast(),
+            send_recv_len(buf.len()),
+            flags.bits(),
+        ))?
+    };
+    Ok(nwritten as usize)
+}
+
+#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
+pub(crate) fn recvfrom(
+    fd: BorrowedFd<'_>,
+    buf: &mut [u8],
+    flags: RecvFlags,
+) -> io::Result<(usize, Option<SocketAddrAny>)> {
+    unsafe {
+        let mut storage = MaybeUninit::<c::sockaddr_storage>::uninit();
+        let mut len = size_of::<c::sockaddr_storage>() as c::socklen_t;
+
+        // `recvfrom` does not write to the storage if the socket is
+        // connection-oriented sockets, so we initialize the family field to
+        // `AF_UNSPEC` so that we can detect this case.
+        initialize_family_to_unspec(storage.as_mut_ptr());
+
+        let nread = ret_send_recv(c::recvfrom(
+            borrowed_fd(fd),
+            buf.as_mut_ptr().cast(),
+            send_recv_len(buf.len()),
+            flags.bits(),
+            storage.as_mut_ptr().cast(),
+            &mut len,
+        ))?;
+        Ok((
+            nread as usize,
+            maybe_read_sockaddr_os(storage.as_ptr(), len.try_into().unwrap()),
+        ))
+    }
+}
+
+#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
+pub(crate) fn sendto_v4(
+    fd: BorrowedFd<'_>,
+    buf: &[u8],
+    flags: SendFlags,
+    addr: &SocketAddrV4,
+) -> io::Result<usize> {
+    let nwritten = unsafe {
+        ret_send_recv(c::sendto(
+            borrowed_fd(fd),
+            buf.as_ptr().cast(),
+            send_recv_len(buf.len()),
+            flags.bits(),
+            as_ptr(&encode_sockaddr_v4(addr)).cast::<c::sockaddr>(),
+            size_of::<SocketAddrV4>() as _,
+        ))?
+    };
+    Ok(nwritten as usize)
+}
+
+#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
+pub(crate) fn sendto_v6(
+    fd: BorrowedFd<'_>,
+    buf: &[u8],
+    flags: SendFlags,
+    addr: &SocketAddrV6,
+) -> io::Result<usize> {
+    let nwritten = unsafe {
+        ret_send_recv(c::sendto(
+            borrowed_fd(fd),
+            buf.as_ptr().cast(),
+            send_recv_len(buf.len()),
+            flags.bits(),
+            as_ptr(&encode_sockaddr_v6(addr)).cast::<c::sockaddr>(),
+            size_of::<SocketAddrV6>() as _,
+        ))?
+    };
+    Ok(nwritten as usize)
+}
+
+#[cfg(not(any(windows, target_os = "redox", target_os = "wasi")))]
+pub(crate) fn sendto_unix(
+    fd: BorrowedFd<'_>,
+    buf: &[u8],
+    flags: SendFlags,
+    addr: &SocketAddrUnix,
+) -> io::Result<usize> {
+    let nwritten = unsafe {
+        ret_send_recv(c::sendto(
+            borrowed_fd(fd),
+            buf.as_ptr().cast(),
+            send_recv_len(buf.len()),
+            flags.bits(),
+            as_ptr(&addr.unix).cast(),
+            addr.addr_len(),
+        ))?
+    };
+    Ok(nwritten as usize)
+}
+
+#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
+pub(crate) fn socket(
+    domain: AddressFamily,
+    type_: SocketType,
+    protocol: Protocol,
+) -> io::Result<OwnedFd> {
+    unsafe {
+        ret_owned_fd(c::socket(
+            domain.0 as c::c_int,
+            type_.0 as c::c_int,
+            protocol.0,
+        ))
+    }
+}
+
+#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
+pub(crate) fn socket_with(
+    domain: AddressFamily,
+    type_: SocketType,
+    flags: SocketFlags,
+    protocol: Protocol,
+) -> io::Result<OwnedFd> {
+    unsafe {
+        ret_owned_fd(c::socket(
+            domain.0 as c::c_int,
+            type_.0 as c::c_int | flags.bits(),
+            protocol.0,
+        ))
+    }
+}
+
+#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
+pub(crate) fn bind_v4(sockfd: BorrowedFd<'_>, addr: &SocketAddrV4) -> io::Result<()> {
+    unsafe {
+        ret(c::bind(
+            borrowed_fd(sockfd),
+            as_ptr(&encode_sockaddr_v4(addr)).cast(),
+            size_of::<c::sockaddr_in>() as c::socklen_t,
+        ))
+    }
+}
+
+#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
+pub(crate) fn bind_v6(sockfd: BorrowedFd<'_>, addr: &SocketAddrV6) -> io::Result<()> {
+    unsafe {
+        ret(c::bind(
+            borrowed_fd(sockfd),
+            as_ptr(&encode_sockaddr_v6(addr)).cast(),
+            size_of::<c::sockaddr_in6>() as c::socklen_t,
+        ))
+    }
+}
+
+#[cfg(not(any(windows, target_os = "redox", target_os = "wasi")))]
+pub(crate) fn bind_unix(sockfd: BorrowedFd<'_>, addr: &SocketAddrUnix) -> io::Result<()> {
+    unsafe {
+        ret(c::bind(
+            borrowed_fd(sockfd),
+            as_ptr(&addr.unix).cast(),
+            addr.addr_len(),
+        ))
+    }
+}
+
+#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
+pub(crate) fn connect_v4(sockfd: BorrowedFd<'_>, addr: &SocketAddrV4) -> io::Result<()> {
+    unsafe {
+        ret(c::connect(
+            borrowed_fd(sockfd),
+            as_ptr(&encode_sockaddr_v4(addr)).cast(),
+            size_of::<c::sockaddr_in>() as c::socklen_t,
+        ))
+    }
+}
+
+#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
+pub(crate) fn connect_v6(sockfd: BorrowedFd<'_>, addr: &SocketAddrV6) -> io::Result<()> {
+    unsafe {
+        ret(c::connect(
+            borrowed_fd(sockfd),
+            as_ptr(&encode_sockaddr_v6(addr)).cast(),
+            size_of::<c::sockaddr_in6>() as c::socklen_t,
+        ))
+    }
+}
+
+#[cfg(not(any(windows, target_os = "redox", target_os = "wasi")))]
+pub(crate) fn connect_unix(sockfd: BorrowedFd<'_>, addr: &SocketAddrUnix) -> io::Result<()> {
+    unsafe {
+        ret(c::connect(
+            borrowed_fd(sockfd),
+            as_ptr(&addr.unix).cast(),
+            addr.addr_len(),
+        ))
+    }
+}
+
+#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
+pub(crate) fn listen(sockfd: BorrowedFd<'_>, backlog: c::c_int) -> io::Result<()> {
+    unsafe { ret(c::listen(borrowed_fd(sockfd), backlog)) }
+}
+
+#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
+pub(crate) fn accept(sockfd: BorrowedFd<'_>) -> io::Result<OwnedFd> {
+    unsafe {
+        let owned_fd = ret_owned_fd(c::accept(borrowed_fd(sockfd), null_mut(), null_mut()))?;
+        Ok(owned_fd)
+    }
+}
+
+#[cfg(not(any(
+    windows,
+    target_os = "haiku",
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "redox",
+    target_os = "wasi",
+)))]
+pub(crate) fn accept_with(sockfd: BorrowedFd<'_>, flags: AcceptFlags) -> io::Result<OwnedFd> {
+    unsafe {
+        let owned_fd = ret_owned_fd(c::accept4(
+            borrowed_fd(sockfd),
+            null_mut(),
+            null_mut(),
+            flags.bits(),
+        ))?;
+        Ok(owned_fd)
+    }
+}
+
+#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
+pub(crate) fn acceptfrom(sockfd: BorrowedFd<'_>) -> io::Result<(OwnedFd, Option<SocketAddrAny>)> {
+    unsafe {
+        let mut storage = MaybeUninit::<c::sockaddr_storage>::uninit();
+        let mut len = size_of::<c::sockaddr_storage>() as c::socklen_t;
+        let owned_fd = ret_owned_fd(c::accept(
+            borrowed_fd(sockfd),
+            storage.as_mut_ptr().cast(),
+            &mut len,
+        ))?;
+        Ok((
+            owned_fd,
+            maybe_read_sockaddr_os(storage.as_ptr(), len.try_into().unwrap()),
+        ))
+    }
+}
+
+#[cfg(not(any(
+    windows,
+    target_os = "haiku",
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "redox",
+    target_os = "wasi",
+)))]
+pub(crate) fn acceptfrom_with(
+    sockfd: BorrowedFd<'_>,
+    flags: AcceptFlags,
+) -> io::Result<(OwnedFd, Option<SocketAddrAny>)> {
+    unsafe {
+        let mut storage = MaybeUninit::<c::sockaddr_storage>::uninit();
+        let mut len = size_of::<c::sockaddr_storage>() as c::socklen_t;
+        let owned_fd = ret_owned_fd(c::accept4(
+            borrowed_fd(sockfd),
+            storage.as_mut_ptr().cast(),
+            &mut len,
+            flags.bits(),
+        ))?;
+        Ok((
+            owned_fd,
+            maybe_read_sockaddr_os(storage.as_ptr(), len.try_into().unwrap()),
+        ))
+    }
+}
+
+/// Darwin lacks `accept4`, but does have `accept`. We define
+/// `AcceptFlags` to have no flags, so we can discard it here.
+#[cfg(any(windows, target_os = "haiku", target_os = "ios", target_os = "macos"))]
+pub(crate) fn accept_with(sockfd: BorrowedFd<'_>, _flags: AcceptFlags) -> io::Result<OwnedFd> {
+    accept(sockfd)
+}
+
+/// Darwin lacks `accept4`, but does have `accept`. We define
+/// `AcceptFlags` to have no flags, so we can discard it here.
+#[cfg(any(windows, target_os = "haiku", target_os = "ios", target_os = "macos"))]
+pub(crate) fn acceptfrom_with(
+    sockfd: BorrowedFd<'_>,
+    _flags: AcceptFlags,
+) -> io::Result<(OwnedFd, Option<SocketAddrAny>)> {
+    acceptfrom(sockfd)
+}
+
+#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
+pub(crate) fn shutdown(sockfd: BorrowedFd<'_>, how: Shutdown) -> io::Result<()> {
+    unsafe { ret(c::shutdown(borrowed_fd(sockfd), how as c::c_int)) }
+}
+
+#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
+pub(crate) fn getsockname(sockfd: BorrowedFd<'_>) -> io::Result<SocketAddrAny> {
+    unsafe {
+        let mut storage = MaybeUninit::<c::sockaddr_storage>::uninit();
+        let mut len = size_of::<c::sockaddr_storage>() as c::socklen_t;
+        ret(c::getsockname(
+            borrowed_fd(sockfd),
+            storage.as_mut_ptr().cast(),
+            &mut len,
+        ))?;
+        Ok(read_sockaddr_os(storage.as_ptr(), len.try_into().unwrap()))
+    }
+}
+
+#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
+pub(crate) fn getpeername(sockfd: BorrowedFd<'_>) -> io::Result<Option<SocketAddrAny>> {
+    unsafe {
+        let mut storage = MaybeUninit::<c::sockaddr_storage>::uninit();
+        let mut len = size_of::<c::sockaddr_storage>() as c::socklen_t;
+        ret(c::getpeername(
+            borrowed_fd(sockfd),
+            storage.as_mut_ptr().cast(),
+            &mut len,
+        ))?;
+        Ok(maybe_read_sockaddr_os(
+            storage.as_ptr(),
+            len.try_into().unwrap(),
+        ))
+    }
+}
+
+#[cfg(not(any(windows, target_os = "redox", target_os = "wasi")))]
+pub(crate) fn socketpair(
+    domain: AddressFamily,
+    type_: SocketType,
+    flags: SocketFlags,
+    protocol: Protocol,
+) -> io::Result<(OwnedFd, OwnedFd)> {
+    unsafe {
+        let mut fds = MaybeUninit::<[OwnedFd; 2]>::uninit();
+        ret(c::socketpair(
+            c::c_int::from(domain.0),
+            type_.0 as c::c_int | flags.bits(),
+            protocol.0,
+            fds.as_mut_ptr().cast::<c::c_int>(),
+        ))?;
+
+        let [fd0, fd1] = fds.assume_init();
+        Ok((fd0, fd1))
+    }
+}
+
+#[cfg(not(any(target_os = "redox", target_os = "wasi")))]
+pub(crate) mod sockopt {
+    use super::{c, in6_addr_new, in_addr_new, BorrowedFd};
+    use crate::io;
+    use crate::net::sockopt::Timeout;
+    use crate::net::{Ipv4Addr, Ipv6Addr, SocketType};
+    use crate::utils::as_mut_ptr;
+    use core::convert::TryInto;
+    use core::time::Duration;
+    #[cfg(windows)]
+    use windows_sys::Win32::Foundation::BOOL;
+
+    // TODO: With Rust 1.53 we can use `Duration::ZERO` instead.
+    const DURATION_ZERO: Duration = Duration::from_secs(0);
+
+    #[inline]
+    fn getsockopt<T: Copy>(fd: BorrowedFd<'_>, level: i32, optname: i32) -> io::Result<T> {
+        use super::*;
+
+        let mut optlen = core::mem::size_of::<T>().try_into().unwrap();
+        debug_assert!(
+            optlen as usize >= core::mem::size_of::<c::c_int>(),
+            "Socket APIs don't ever use `bool` directly"
+        );
+
+        unsafe {
+            let mut value = core::mem::zeroed::<T>();
+            ret(c::getsockopt(
+                borrowed_fd(fd),
+                level,
+                optname,
+                as_mut_ptr(&mut value).cast(),
+                &mut optlen,
+            ))?;
+            // On Windows at least, `getsockopt` has been observed writing 1
+            // byte on at least (`IPPROTO_TCP`, `TCP_NODELAY`), even though
+            // Windows' documentation says that should write a 4-byte `BOOL`.
+            // So, we initialize the memory to zeros above, and just assert
+            // that `getsockopt` doesn't write too many bytes here.
+            assert!(
+                optlen as usize <= size_of::<T>(),
+                "unexpected getsockopt size"
+            );
+            Ok(value)
+        }
+    }
+
+    #[inline]
+    fn setsockopt<T: Copy>(
+        fd: BorrowedFd<'_>,
+        level: i32,
+        optname: i32,
+        value: T,
+    ) -> io::Result<()> {
+        use super::*;
+
+        let optlen = core::mem::size_of::<T>().try_into().unwrap();
+        debug_assert!(
+            optlen as usize >= core::mem::size_of::<c::c_int>(),
+            "Socket APIs don't ever use `bool` directly"
+        );
+
+        unsafe {
+            ret(c::setsockopt(
+                borrowed_fd(fd),
+                level,
+                optname,
+                as_ptr(&value).cast(),
+                optlen,
+            ))
+        }
+    }
+
+    #[inline]
+    pub(crate) fn get_socket_type(fd: BorrowedFd<'_>) -> io::Result<SocketType> {
+        getsockopt(fd, c::SOL_SOCKET as _, c::SO_TYPE)
+    }
+
+    #[inline]
+    pub(crate) fn set_socket_reuseaddr(fd: BorrowedFd<'_>, reuseaddr: bool) -> io::Result<()> {
+        setsockopt(
+            fd,
+            c::SOL_SOCKET as _,
+            c::SO_REUSEADDR,
+            from_bool(reuseaddr),
+        )
+    }
+
+    #[inline]
+    pub(crate) fn set_socket_broadcast(fd: BorrowedFd<'_>, broadcast: bool) -> io::Result<()> {
+        setsockopt(
+            fd,
+            c::SOL_SOCKET as _,
+            c::SO_BROADCAST,
+            from_bool(broadcast),
+        )
+    }
+
+    #[inline]
+    pub(crate) fn get_socket_broadcast(fd: BorrowedFd<'_>) -> io::Result<bool> {
+        getsockopt(fd, c::SOL_SOCKET as _, c::SO_BROADCAST).map(to_bool)
+    }
+
+    #[inline]
+    pub(crate) fn set_socket_linger(
+        fd: BorrowedFd<'_>,
+        linger: Option<Duration>,
+    ) -> io::Result<()> {
+        // Convert `linger` to seconds, rounding up.
+        let l_linger = if let Some(linger) = linger {
+            let mut l_linger = linger.as_secs();
+            if linger.subsec_nanos() != 0 {
+                l_linger = l_linger.checked_add(1).ok_or(io::Errno::INVAL)?;
+            }
+            l_linger.try_into().map_err(|_e| io::Errno::INVAL)?
+        } else {
+            0
+        };
+        let linger = c::linger {
+            l_onoff: linger.is_some() as _,
+            l_linger,
+        };
+        setsockopt(fd, c::SOL_SOCKET as _, c::SO_LINGER, linger)
+    }
+
+    #[inline]
+    pub(crate) fn get_socket_linger(fd: BorrowedFd<'_>) -> io::Result<Option<Duration>> {
+        let linger: c::linger = getsockopt(fd, c::SOL_SOCKET as _, c::SO_LINGER)?;
+        // TODO: With Rust 1.50, this could use `.then`.
+        Ok(if linger.l_onoff != 0 {
+            Some(Duration::from_secs(linger.l_linger as u64))
+        } else {
+            None
+        })
+    }
+
+    #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[inline]
+    pub(crate) fn set_socket_passcred(fd: BorrowedFd<'_>, passcred: bool) -> io::Result<()> {
+        setsockopt(fd, c::SOL_SOCKET as _, c::SO_PASSCRED, from_bool(passcred))
+    }
+
+    #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[inline]
+    pub(crate) fn get_socket_passcred(fd: BorrowedFd<'_>) -> io::Result<bool> {
+        getsockopt(fd, c::SOL_SOCKET as _, c::SO_PASSCRED).map(to_bool)
+    }
+
+    #[inline]
+    pub(crate) fn set_socket_timeout(
+        fd: BorrowedFd<'_>,
+        id: Timeout,
+        timeout: Option<Duration>,
+    ) -> io::Result<()> {
+        let optname = match id {
+            Timeout::Recv => c::SO_RCVTIMEO,
+            Timeout::Send => c::SO_SNDTIMEO,
+        };
+
+        #[cfg(not(windows))]
+        let timeout = match timeout {
+            Some(timeout) => {
+                if timeout == DURATION_ZERO {
+                    return Err(io::Errno::INVAL);
+                }
+
+                let tv_sec = timeout.as_secs().try_into();
+                #[cfg(not(all(target_arch = "x86_64", target_pointer_width = "32")))]
+                let tv_sec = tv_sec.unwrap_or(c::c_long::MAX);
+                #[cfg(all(target_arch = "x86_64", target_pointer_width = "32"))]
+                let tv_sec = tv_sec.unwrap_or(i64::MAX);
+
+                // `subsec_micros` rounds down, so we use `subsec_nanos` and
+                // manually round up.
+                let mut timeout = c::timeval {
+                    tv_sec,
+                    tv_usec: ((timeout.subsec_nanos() + 999) / 1000) as _,
+                };
+                if timeout.tv_sec == 0 && timeout.tv_usec == 0 {
+                    timeout.tv_usec = 1;
+                }
+                timeout
+            }
+            None => c::timeval {
+                tv_sec: 0,
+                tv_usec: 0,
+            },
+        };
+
+        #[cfg(windows)]
+        let timeout: u32 = match timeout {
+            Some(timeout) => {
+                if timeout == DURATION_ZERO {
+                    return Err(io::Errno::INVAL);
+                }
+
+                // `as_millis` rounds down, so we use `as_nanos` and
+                // manually round up.
+                let mut timeout: u32 = ((timeout.as_nanos() + 999_999) / 1_000_000)
+                    .try_into()
+                    .map_err(|_convert_err| io::Errno::INVAL)?;
+                if timeout == 0 {
+                    timeout = 1;
+                }
+                timeout
+            }
+            None => 0,
+        };
+
+        setsockopt(fd, c::SOL_SOCKET, optname, timeout)
+    }
+
+    #[inline]
+    pub(crate) fn get_socket_timeout(
+        fd: BorrowedFd<'_>,
+        id: Timeout,
+    ) -> io::Result<Option<Duration>> {
+        let optname = match id {
+            Timeout::Recv => c::SO_RCVTIMEO,
+            Timeout::Send => c::SO_SNDTIMEO,
+        };
+
+        #[cfg(not(windows))]
+        {
+            let timeout: c::timeval = getsockopt(fd, c::SOL_SOCKET, optname)?;
+            if timeout.tv_sec == 0 && timeout.tv_usec == 0 {
+                Ok(None)
+            } else {
+                Ok(Some(
+                    Duration::from_secs(timeout.tv_sec as u64)
+                        + Duration::from_micros(timeout.tv_usec as u64),
+                ))
+            }
+        }
+
+        #[cfg(windows)]
+        {
+            let timeout: u32 = getsockopt(fd, c::SOL_SOCKET, optname)?;
+            if timeout == 0 {
+                Ok(None)
+            } else {
+                Ok(Some(Duration::from_millis(timeout as u64)))
+            }
+        }
+    }
+
+    #[inline]
+    pub(crate) fn set_ip_ttl(fd: BorrowedFd<'_>, ttl: u32) -> io::Result<()> {
+        setsockopt(fd, c::IPPROTO_IP as _, c::IP_TTL, ttl)
+    }
+
+    #[inline]
+    pub(crate) fn get_ip_ttl(fd: BorrowedFd<'_>) -> io::Result<u32> {
+        getsockopt(fd, c::IPPROTO_IP as _, c::IP_TTL)
+    }
+
+    #[inline]
+    pub(crate) fn set_ipv6_v6only(fd: BorrowedFd<'_>, only_v6: bool) -> io::Result<()> {
+        setsockopt(fd, c::IPPROTO_IPV6 as _, c::IPV6_V6ONLY, from_bool(only_v6))
+    }
+
+    #[inline]
+    pub(crate) fn get_ipv6_v6only(fd: BorrowedFd<'_>) -> io::Result<bool> {
+        getsockopt(fd, c::IPPROTO_IPV6 as _, c::IPV6_V6ONLY).map(to_bool)
+    }
+
+    #[inline]
+    pub(crate) fn set_ip_multicast_loop(
+        fd: BorrowedFd<'_>,
+        multicast_loop: bool,
+    ) -> io::Result<()> {
+        setsockopt(
+            fd,
+            c::IPPROTO_IP as _,
+            c::IP_MULTICAST_LOOP,
+            from_bool(multicast_loop),
+        )
+    }
+
+    #[inline]
+    pub(crate) fn get_ip_multicast_loop(fd: BorrowedFd<'_>) -> io::Result<bool> {
+        getsockopt(fd, c::IPPROTO_IP as _, c::IP_MULTICAST_LOOP).map(to_bool)
+    }
+
+    #[inline]
+    pub(crate) fn set_ip_multicast_ttl(fd: BorrowedFd<'_>, multicast_ttl: u32) -> io::Result<()> {
+        setsockopt(fd, c::IPPROTO_IP as _, c::IP_MULTICAST_TTL, multicast_ttl)
+    }
+
+    #[inline]
+    pub(crate) fn get_ip_multicast_ttl(fd: BorrowedFd<'_>) -> io::Result<u32> {
+        getsockopt(fd, c::IPPROTO_IP as _, c::IP_MULTICAST_TTL)
+    }
+
+    #[inline]
+    pub(crate) fn set_ipv6_multicast_loop(
+        fd: BorrowedFd<'_>,
+        multicast_loop: bool,
+    ) -> io::Result<()> {
+        setsockopt(
+            fd,
+            c::IPPROTO_IPV6 as _,
+            c::IPV6_MULTICAST_LOOP,
+            from_bool(multicast_loop),
+        )
+    }
+
+    #[inline]
+    pub(crate) fn get_ipv6_multicast_loop(fd: BorrowedFd<'_>) -> io::Result<bool> {
+        getsockopt(fd, c::IPPROTO_IPV6 as _, c::IPV6_MULTICAST_LOOP).map(to_bool)
+    }
+
+    #[inline]
+    pub(crate) fn set_ipv6_multicast_hops(
+        fd: BorrowedFd<'_>,
+        multicast_hops: u32,
+    ) -> io::Result<()> {
+        setsockopt(
+            fd,
+            c::IPPROTO_IP as _,
+            c::IPV6_MULTICAST_LOOP,
+            multicast_hops,
+        )
+    }
+
+    #[inline]
+    pub(crate) fn get_ipv6_multicast_hops(fd: BorrowedFd<'_>) -> io::Result<u32> {
+        getsockopt(fd, c::IPPROTO_IP as _, c::IPV6_MULTICAST_LOOP)
+    }
+
+    #[inline]
+    pub(crate) fn set_ip_add_membership(
+        fd: BorrowedFd<'_>,
+        multiaddr: &Ipv4Addr,
+        interface: &Ipv4Addr,
+    ) -> io::Result<()> {
+        let mreq = to_imr(multiaddr, interface);
+        setsockopt(fd, c::IPPROTO_IP as _, c::IP_ADD_MEMBERSHIP, mreq)
+    }
+
+    #[inline]
+    pub(crate) fn set_ipv6_add_membership(
+        fd: BorrowedFd<'_>,
+        multiaddr: &Ipv6Addr,
+        interface: u32,
+    ) -> io::Result<()> {
+        #[cfg(not(any(
+            target_os = "dragonfly",
+            target_os = "freebsd",
+            target_os = "haiku",
+            target_os = "illumos",
+            target_os = "ios",
+            target_os = "l4re",
+            target_os = "macos",
+            target_os = "netbsd",
+            target_os = "openbsd",
+            target_os = "solaris",
+        )))]
+        use c::IPV6_ADD_MEMBERSHIP;
+        #[cfg(any(
+            target_os = "dragonfly",
+            target_os = "freebsd",
+            target_os = "haiku",
+            target_os = "illumos",
+            target_os = "ios",
+            target_os = "l4re",
+            target_os = "macos",
+            target_os = "netbsd",
+            target_os = "openbsd",
+            target_os = "solaris",
+        ))]
+        use c::IPV6_JOIN_GROUP as IPV6_ADD_MEMBERSHIP;
+
+        let mreq = to_ipv6mr(multiaddr, interface);
+        setsockopt(fd, c::IPPROTO_IPV6 as _, IPV6_ADD_MEMBERSHIP, mreq)
+    }
+
+    #[inline]
+    pub(crate) fn set_ip_drop_membership(
+        fd: BorrowedFd<'_>,
+        multiaddr: &Ipv4Addr,
+        interface: &Ipv4Addr,
+    ) -> io::Result<()> {
+        let mreq = to_imr(multiaddr, interface);
+        setsockopt(fd, c::IPPROTO_IP as _, c::IP_DROP_MEMBERSHIP, mreq)
+    }
+
+    #[inline]
+    pub(crate) fn set_ipv6_drop_membership(
+        fd: BorrowedFd<'_>,
+        multiaddr: &Ipv6Addr,
+        interface: u32,
+    ) -> io::Result<()> {
+        #[cfg(not(any(
+            target_os = "dragonfly",
+            target_os = "freebsd",
+            target_os = "haiku",
+            target_os = "illumos",
+            target_os = "ios",
+            target_os = "l4re",
+            target_os = "macos",
+            target_os = "netbsd",
+            target_os = "openbsd",
+            target_os = "solaris",
+        )))]
+        use c::IPV6_DROP_MEMBERSHIP;
+        #[cfg(any(
+            target_os = "dragonfly",
+            target_os = "freebsd",
+            target_os = "haiku",
+            target_os = "illumos",
+            target_os = "ios",
+            target_os = "l4re",
+            target_os = "macos",
+            target_os = "netbsd",
+            target_os = "openbsd",
+            target_os = "solaris",
+        ))]
+        use c::IPV6_LEAVE_GROUP as IPV6_DROP_MEMBERSHIP;
+
+        let mreq = to_ipv6mr(multiaddr, interface);
+        setsockopt(fd, c::IPPROTO_IPV6 as _, IPV6_DROP_MEMBERSHIP, mreq)
+    }
+
+    #[inline]
+    pub(crate) fn set_tcp_nodelay(fd: BorrowedFd<'_>, nodelay: bool) -> io::Result<()> {
+        setsockopt(fd, c::IPPROTO_TCP as _, c::TCP_NODELAY, from_bool(nodelay))
+    }
+
+    #[inline]
+    pub(crate) fn get_tcp_nodelay(fd: BorrowedFd<'_>) -> io::Result<bool> {
+        getsockopt(fd, c::IPPROTO_TCP as _, c::TCP_NODELAY).map(to_bool)
+    }
+
+    #[inline]
+    fn to_imr(multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> c::ip_mreq {
+        c::ip_mreq {
+            imr_multiaddr: to_imr_addr(multiaddr),
+            imr_interface: to_imr_addr(interface),
+        }
+    }
+
+    #[inline]
+    fn to_imr_addr(addr: &Ipv4Addr) -> c::in_addr {
+        in_addr_new(u32::from_ne_bytes(addr.octets()))
+    }
+
+    #[inline]
+    fn to_ipv6mr(multiaddr: &Ipv6Addr, interface: u32) -> c::ipv6_mreq {
+        c::ipv6_mreq {
+            ipv6mr_multiaddr: to_ipv6mr_multiaddr(multiaddr),
+            ipv6mr_interface: to_ipv6mr_interface(interface),
+        }
+    }
+
+    #[inline]
+    fn to_ipv6mr_multiaddr(multiaddr: &Ipv6Addr) -> c::in6_addr {
+        in6_addr_new(multiaddr.octets())
+    }
+
+    #[cfg(target_os = "android")]
+    #[inline]
+    fn to_ipv6mr_interface(interface: u32) -> c::c_int {
+        interface as c::c_int
+    }
+
+    #[cfg(not(target_os = "android"))]
+    #[inline]
+    fn to_ipv6mr_interface(interface: u32) -> c::c_uint {
+        interface as c::c_uint
+    }
+
+    // `getsockopt` and `setsockopt` represent boolean values as integers.
+    #[cfg(not(windows))]
+    type RawSocketBool = c::c_int;
+    #[cfg(windows)]
+    type RawSocketBool = BOOL;
+
+    // Wrap `RawSocketBool` in a newtype to discourage misuse.
+    #[repr(transparent)]
+    #[derive(Copy, Clone)]
+    struct SocketBool(RawSocketBool);
+
+    // Convert from a `bool` to a `SocketBool`.
+    #[inline]
+    fn from_bool(value: bool) -> SocketBool {
+        SocketBool(value as _)
+    }
+
+    // Convert from a `SocketBool` to a `bool`.
+    #[inline]
+    fn to_bool(value: SocketBool) -> bool {
+        value.0 != 0
+    }
+}
diff --git a/vendor/rustix/src/backend/libc/net/types.rs b/vendor/rustix/src/backend/libc/net/types.rs
new file mode 100644
index 000000000..19d97e7c7
--- /dev/null
+++ b/vendor/rustix/src/backend/libc/net/types.rs
@@ -0,0 +1,687 @@
+use super::super::c;
+use bitflags::bitflags;
+
+/// A type for holding raw integer socket types.
+#[doc(hidden)]
+pub type RawSocketType = u32;
+
+/// `SOCK_*` constants for use with [`socket`].
+///
+/// [`socket`]: crate::net::socket
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
+#[repr(transparent)]
+pub struct SocketType(pub(crate) RawSocketType);
+
+#[rustfmt::skip]
+impl SocketType {
+    /// `SOCK_STREAM`
+    pub const STREAM: Self = Self(c::SOCK_STREAM as u32);
+
+    /// `SOCK_DGRAM`
+    pub const DGRAM: Self = Self(c::SOCK_DGRAM as u32);
+
+    /// `SOCK_SEQPACKET`
+    pub const SEQPACKET: Self = Self(c::SOCK_SEQPACKET as u32);
+
+    /// `SOCK_RAW`
+    pub const RAW: Self = Self(c::SOCK_RAW as u32);
+
+    /// `SOCK_RDM`
+    #[cfg(not(target_os = "haiku"))]
+    pub const RDM: Self = Self(c::SOCK_RDM as u32);
+
+    /// Constructs a `SocketType` from a raw integer.
+    #[inline]
+    pub const fn from_raw(raw: RawSocketType) -> Self {
+        Self(raw)
+    }
+
+    /// Returns the raw integer for this `SocketType`.
+    #[inline]
+    pub const fn as_raw(self) -> RawSocketType {
+        self.0
+    }
+}
+
+/// A type for holding raw integer address families.
+#[doc(hidden)]
+pub type RawAddressFamily = c::sa_family_t;
+
+/// `AF_*` constants.
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
+#[repr(transparent)]
+pub struct AddressFamily(pub(crate) RawAddressFamily);
+
+#[rustfmt::skip]
+impl AddressFamily {
+    /// `AF_UNSPEC`
+    pub const UNSPEC: Self = Self(c::AF_UNSPEC as _);
+    /// `AF_INET`
+    pub const INET: Self = Self(c::AF_INET as _);
+    /// `AF_INET6`
+    pub const INET6: Self = Self(c::AF_INET6 as _);
+    /// `AF_NETLINK`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "haiku",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "solaris",
+    )))]
+    pub const NETLINK: Self = Self(c::AF_NETLINK as _);
+    /// `AF_UNIX`, aka `AF_LOCAL`
+    #[doc(alias = "LOCAL")]
+    pub const UNIX: Self = Self(c::AF_UNIX as _);
+    /// `AF_AX25`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "haiku",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "solaris",
+    )))]
+    pub const AX25: Self = Self(c::AF_AX25 as _);
+    /// `AF_IPX`
+    pub const IPX: Self = Self(c::AF_IPX as _);
+    /// `AF_APPLETALK`
+    pub const APPLETALK: Self = Self(c::AF_APPLETALK as _);
+    /// `AF_NETROM`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "haiku",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "solaris",
+    )))]
+    pub const NETROM: Self = Self(c::AF_NETROM as _);
+    /// `AF_BRIDGE`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "haiku",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "solaris",
+    )))]
+    pub const BRIDGE: Self = Self(c::AF_BRIDGE as _);
+    /// `AF_ATMPVC`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "haiku",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "solaris",
+    )))]
+    pub const ATMPVC: Self = Self(c::AF_ATMPVC as _);
+    /// `AF_X25`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "haiku",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    )))]
+    pub const X25: Self = Self(c::AF_X25 as _);
+    /// `AF_ROSE`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "haiku",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "solaris",
+    )))]
+    pub const ROSE: Self = Self(c::AF_ROSE as _);
+    /// `AF_DECnet`
+    #[allow(non_upper_case_globals)]
+    #[cfg(not(target_os = "haiku"))]
+    pub const DECnet: Self = Self(c::AF_DECnet as _);
+    /// `AF_NETBEUI`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "haiku",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "solaris",
+    )))]
+    pub const NETBEUI: Self = Self(c::AF_NETBEUI as _);
+    /// `AF_SECURITY`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "haiku",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "solaris",
+    )))]
+    pub const SECURITY: Self = Self(c::AF_SECURITY as _);
+    /// `AF_KEY`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "haiku",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    )))]
+    pub const KEY: Self = Self(c::AF_KEY as _);
+    /// `AF_PACKET`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "haiku",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    )))]
+    pub const PACKET: Self = Self(c::AF_PACKET as _);
+    /// `AF_ASH`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "haiku",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "solaris",
+    )))]
+    pub const ASH: Self = Self(c::AF_ASH as _);
+    /// `AF_ECONET`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "haiku",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "solaris",
+    )))]
+    pub const ECONET: Self = Self(c::AF_ECONET as _);
+    /// `AF_ATMSVC`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "haiku",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "solaris",
+    )))]
+    pub const ATMSVC: Self = Self(c::AF_ATMSVC as _);
+    /// `AF_RDS`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "haiku",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "solaris",
+    )))]
+    pub const RDS: Self = Self(c::AF_RDS as _);
+    /// `AF_SNA`
+    #[cfg(not(target_os = "haiku"))]
+    pub const SNA: Self = Self(c::AF_SNA as _);
+    /// `AF_IRDA`
+    #[cfg(not(any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "haiku",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "solaris",
+    )))]
+    pub const IRDA: Self = Self(c::AF_IRDA as _);
+    /// `AF_PPPOX`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "haiku",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "solaris",
+    )))]
+    pub const PPPOX: Self = Self(c::AF_PPPOX as _);
+    /// `AF_WANPIPE`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "haiku",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "solaris",
+    )))]
+    pub const WANPIPE: Self = Self(c::AF_WANPIPE as _);
+    /// `AF_LLC`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "haiku",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "solaris",
+    )))]
+    pub const LLC: Self = Self(c::AF_LLC as _);
+    /// `AF_CAN`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "haiku",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "solaris",
+    )))]
+    pub const CAN: Self = Self(c::AF_CAN as _);
+    /// `AF_TIPC`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "haiku",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "solaris",
+    )))]
+    pub const TIPC: Self = Self(c::AF_TIPC as _);
+    /// `AF_BLUETOOTH`
+    #[cfg(not(any(windows, target_os = "illumos", target_os = "ios", target_os = "macos", target_os = "solaris")))]
+    pub const BLUETOOTH: Self = Self(c::AF_BLUETOOTH as _);
+    /// `AF_IUCV`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "haiku",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "solaris",
+    )))]
+    pub const IUCV: Self = Self(c::AF_IUCV as _);
+    /// `AF_RXRPC`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "haiku",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "solaris",
+    )))]
+    pub const RXRPC: Self = Self(c::AF_RXRPC as _);
+    /// `AF_ISDN`
+    #[cfg(not(any(windows, target_os = "haiku", target_os = "illumos", target_os = "solaris")))]
+    pub const ISDN: Self = Self(c::AF_ISDN as _);
+    /// `AF_PHONET`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "haiku",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "solaris",
+    )))]
+    pub const PHONET: Self = Self(c::AF_PHONET as _);
+    /// `AF_IEEE802154`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "haiku",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "solaris",
+    )))]
+    pub const IEEE802154: Self = Self(c::AF_IEEE802154 as _);
+
+    /// Constructs a `AddressFamily` from a raw integer.
+    #[inline]
+    pub const fn from_raw(raw: RawAddressFamily) -> Self {
+        Self(raw)
+    }
+
+    /// Returns the raw integer for this `AddressFamily`.
+    #[inline]
+    pub const fn as_raw(self) -> RawAddressFamily {
+        self.0
+    }
+}
+
+/// A type for holding raw integer protocols.
+#[doc(hidden)]
+pub type RawProtocol = i32;
+
+/// `IPPROTO_*`
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
+#[repr(transparent)]
+pub struct Protocol(pub(crate) RawProtocol);
+
+#[rustfmt::skip]
+impl Protocol {
+    /// `IPPROTO_IP`
+    pub const IP: Self = Self(c::IPPROTO_IP as _);
+    /// `IPPROTO_ICMP`
+    pub const ICMP: Self = Self(c::IPPROTO_ICMP as _);
+    /// `IPPROTO_IGMP`
+    #[cfg(not(any(target_os = "haiku", target_os = "illumos", target_os = "solaris")))]
+    pub const IGMP: Self = Self(c::IPPROTO_IGMP as _);
+    /// `IPPROTO_IPIP`
+    #[cfg(not(any(windows, target_os = "haiku", target_os = "illumos", target_os = "solaris")))]
+    pub const IPIP: Self = Self(c::IPPROTO_IPIP as _);
+    /// `IPPROTO_TCP`
+    pub const TCP: Self = Self(c::IPPROTO_TCP as _);
+    /// `IPPROTO_EGP`
+    #[cfg(not(any(target_os = "haiku", target_os = "illumos", target_os = "solaris")))]
+    pub const EGP: Self = Self(c::IPPROTO_EGP as _);
+    /// `IPPROTO_PUP`
+    #[cfg(not(any(target_os = "haiku", target_os = "illumos", target_os = "solaris")))]
+    pub const PUP: Self = Self(c::IPPROTO_PUP as _);
+    /// `IPPROTO_UDP`
+    pub const UDP: Self = Self(c::IPPROTO_UDP as _);
+    /// `IPPROTO_IDP`
+    #[cfg(not(any(target_os = "haiku", target_os = "illumos", target_os = "solaris")))]
+    pub const IDP: Self = Self(c::IPPROTO_IDP as _);
+    /// `IPPROTO_TP`
+    #[cfg(not(any(windows, target_os = "haiku", target_os = "illumos", target_os = "solaris")))]
+    pub const TP: Self = Self(c::IPPROTO_TP as _);
+    /// `IPPROTO_DCCP`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "haiku",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "openbsd",
+        target_os = "solaris",
+    )))]
+    pub const DCCP: Self = Self(c::IPPROTO_DCCP as _);
+    /// `IPPROTO_IPV6`
+    pub const IPV6: Self = Self(c::IPPROTO_IPV6 as _);
+    /// `IPPROTO_RSVP`
+    #[cfg(not(any(windows, target_os = "haiku", target_os = "illumos", target_os = "solaris")))]
+    pub const RSVP: Self = Self(c::IPPROTO_RSVP as _);
+    /// `IPPROTO_GRE`
+    #[cfg(not(any(windows, target_os = "haiku", target_os = "illumos", target_os = "solaris")))]
+    pub const GRE: Self = Self(c::IPPROTO_GRE as _);
+    /// `IPPROTO_ESP`
+    #[cfg(not(any(target_os = "haiku", target_os = "illumos", target_os = "solaris")))]
+    pub const ESP: Self = Self(c::IPPROTO_ESP as _);
+    /// `IPPROTO_AH`
+    #[cfg(not(any(target_os = "haiku", target_os = "illumos", target_os = "solaris")))]
+    pub const AH: Self = Self(c::IPPROTO_AH as _);
+    /// `IPPROTO_MTP`
+    #[cfg(not(any(
+        windows,
+        target_os = "haiku",
+        target_os = "illumos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "solaris",
+    )))]
+    pub const MTP: Self = Self(c::IPPROTO_MTP as _);
+    /// `IPPROTO_BEETPH`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "haiku",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "solaris",
+    )))]
+    pub const BEETPH: Self = Self(c::IPPROTO_BEETPH as _);
+    /// `IPPROTO_ENCAP`
+    #[cfg(not(any(windows, target_os = "haiku", target_os = "illumos", target_os = "solaris")))]
+    pub const ENCAP: Self = Self(c::IPPROTO_ENCAP as _);
+    /// `IPPROTO_PIM`
+    #[cfg(not(any(target_os = "haiku", target_os = "illumos", target_os = "solaris")))]
+    pub const PIM: Self = Self(c::IPPROTO_PIM as _);
+    /// `IPPROTO_COMP`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "haiku",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "solaris",
+    )))]
+    pub const COMP: Self = Self(c::IPPROTO_COMP as _);
+    /// `IPPROTO_SCTP`
+    #[cfg(not(any(target_os = "dragonfly", target_os = "haiku", target_os = "illumos", target_os = "openbsd", target_os = "solaris")))]
+    pub const SCTP: Self = Self(c::IPPROTO_SCTP as _);
+    /// `IPPROTO_UDPLITE`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "haiku",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "solaris",
+    )))]
+    pub const UDPLITE: Self = Self(c::IPPROTO_UDPLITE as _);
+    /// `IPPROTO_MPLS`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "haiku",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "solaris",
+    )))]
+    pub const MPLS: Self = Self(c::IPPROTO_MPLS as _);
+    /// `IPPROTO_RAW`
+    pub const RAW: Self = Self(c::IPPROTO_RAW as _);
+    /// `IPPROTO_MPTCP`
+    #[cfg(not(any(
+        windows,
+        target_os = "android",
+        target_os = "dragonfly",
+        target_os = "emscripten",
+        target_os = "freebsd",
+        target_os = "fuchsia",
+        target_os = "haiku",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "solaris",
+    )))]
+    pub const MPTCP: Self = Self(c::IPPROTO_MPTCP as _);
+    /// `IPPROTO_FRAGMENT`
+    #[cfg(not(any(target_os = "haiku", target_os = "illumos", target_os = "solaris")))]
+    pub const FRAGMENT: Self = Self(c::IPPROTO_FRAGMENT as _);
+    /// `IPPROTO_ICMPV6`
+    pub const ICMPV6: Self = Self(c::IPPROTO_ICMPV6 as _);
+    /// `IPPROTO_MH`
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "haiku",
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "solaris",
+    )))]
+    pub const MH: Self = Self(c::IPPROTO_MH as _);
+    /// `IPPROTO_ROUTING`
+    #[cfg(not(any(target_os = "haiku", target_os = "illumos", target_os = "solaris")))]
+    pub const ROUTING: Self = Self(c::IPPROTO_ROUTING as _);
+
+    /// Constructs a `Protocol` from a raw integer.
+    #[inline]
+    pub const fn from_raw(raw: RawProtocol) -> Self {
+        Self(raw)
+    }
+
+    /// Returns the raw integer for this `Protocol`.
+    #[inline]
+    pub const fn as_raw(self) -> RawProtocol {
+        self.0
+    }
+}
+
+/// `SHUT_*` constants for use with [`shutdown`].
+///
+/// [`shutdown`]: crate::net::shutdown
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
+#[repr(i32)]
+pub enum Shutdown {
+    /// `SHUT_RD`—Disable further read operations.
+    Read = c::SHUT_RD,
+    /// `SHUT_WR`—Disable further write operations.
+    Write = c::SHUT_WR,
+    /// `SHUT_RDWR`—Disable further read and write operations.
+    ReadWrite = c::SHUT_RDWR,
+}
+
+bitflags! {
+    /// `SOCK_*` constants for use with [`accept_with`] and [`acceptfrom_with`].
+    ///
+    /// [`accept_with`]: crate::net::accept_with
+    /// [`acceptfrom_with`]: crate::net::acceptfrom_with
+    pub struct AcceptFlags: c::c_int {
+        /// `SOCK_NONBLOCK`
+        #[cfg(not(any(windows, target_os = "haiku", target_os = "ios", target_os = "macos")))]
+        const NONBLOCK = c::SOCK_NONBLOCK;
+
+        /// `SOCK_CLOEXEC`
+        #[cfg(not(any(windows, target_os = "haiku", target_os = "ios", target_os = "macos")))]
+        const CLOEXEC = c::SOCK_CLOEXEC;
+    }
+}
+
+bitflags! {
+    /// `SOCK_*` constants for use with [`socket`].
+    ///
+    /// [`socket`]: crate::net::socket
+    pub struct SocketFlags: c::c_int {
+        /// `SOCK_NONBLOCK`
+        #[cfg(not(any(windows, target_os = "haiku", target_os = "ios", target_os = "macos")))]
+        const NONBLOCK = c::SOCK_NONBLOCK;
+
+        /// `SOCK_CLOEXEC`
+        #[cfg(not(any(windows, target_os = "haiku", target_os = "ios", target_os = "macos")))]
+        const CLOEXEC = c::SOCK_CLOEXEC;
+    }
+}
+
+/// Timeout identifier for use with [`set_socket_timeout`] and
+/// [`get_socket_timeout`].
+///
+/// [`set_socket_timeout`]: crate::net::sockopt::set_socket_timeout.
+/// [`get_socket_timeout`]: crate::net::sockopt::get_socket_timeout.
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
+#[repr(i32)]
+pub enum Timeout {
+    /// `SO_RCVTIMEO`—Timeout for receiving.
+    Recv = c::SO_RCVTIMEO,
+
+    /// `SO_SNDTIMEO`—Timeout for sending.
+    Send = c::SO_SNDTIMEO,
+}
diff --git a/vendor/rustix/src/backend/libc/net/write_sockaddr.rs b/vendor/rustix/src/backend/libc/net/write_sockaddr.rs
new file mode 100644
index 000000000..f44284a0b
--- /dev/null
+++ b/vendor/rustix/src/backend/libc/net/write_sockaddr.rs
@@ -0,0 +1,102 @@
+//! The BSD sockets API requires us to read the `ss_family` field before
+//! we can interpret the rest of a `sockaddr` produced by the kernel.
+
+use super::super::c;
+use super::addr::SocketAddrStorage;
+#[cfg(unix)]
+use super::addr::SocketAddrUnix;
+use super::ext::{in6_addr_new, in_addr_new, sockaddr_in6_new};
+use crate::net::{SocketAddrAny, SocketAddrV4, SocketAddrV6};
+use core::mem::size_of;
+
+pub(crate) unsafe fn write_sockaddr(
+    addr: &SocketAddrAny,
+    storage: *mut SocketAddrStorage,
+) -> usize {
+    match addr {
+        SocketAddrAny::V4(v4) => write_sockaddr_v4(v4, storage),
+        SocketAddrAny::V6(v6) => write_sockaddr_v6(v6, storage),
+        #[cfg(unix)]
+        SocketAddrAny::Unix(unix) => write_sockaddr_unix(unix, storage),
+    }
+}
+
+pub(crate) unsafe fn encode_sockaddr_v4(v4: &SocketAddrV4) -> c::sockaddr_in {
+    c::sockaddr_in {
+        #[cfg(any(
+            target_os = "dragonfly",
+            target_os = "freebsd",
+            target_os = "haiku",
+            target_os = "ios",
+            target_os = "macos",
+            target_os = "netbsd",
+            target_os = "openbsd",
+        ))]
+        sin_len: size_of::<c::sockaddr_in>() as _,
+        sin_family: c::AF_INET as _,
+        sin_port: u16::to_be(v4.port()),
+        sin_addr: in_addr_new(u32::from_ne_bytes(v4.ip().octets())),
+        #[cfg(not(target_os = "haiku"))]
+        sin_zero: [0; 8_usize],
+        #[cfg(target_os = "haiku")]
+        sin_zero: [0; 24_usize],
+    }
+}
+
+unsafe fn write_sockaddr_v4(v4: &SocketAddrV4, storage: *mut SocketAddrStorage) -> usize {
+    let encoded = encode_sockaddr_v4(v4);
+    core::ptr::write(storage.cast(), encoded);
+    size_of::<c::sockaddr_in>()
+}
+
+pub(crate) unsafe fn encode_sockaddr_v6(v6: &SocketAddrV6) -> c::sockaddr_in6 {
+    #[cfg(any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "haiku",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    ))]
+    {
+        sockaddr_in6_new(
+            size_of::<c::sockaddr_in6>() as _,
+            c::AF_INET6 as _,
+            u16::to_be(v6.port()),
+            u32::to_be(v6.flowinfo()),
+            in6_addr_new(v6.ip().octets()),
+            v6.scope_id(),
+        )
+    }
+    #[cfg(not(any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "haiku",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    )))]
+    {
+        sockaddr_in6_new(
+            c::AF_INET6 as _,
+            u16::to_be(v6.port()),
+            u32::to_be(v6.flowinfo()),
+            in6_addr_new(v6.ip().octets()),
+            v6.scope_id(),
+        )
+    }
+}
+
+unsafe fn write_sockaddr_v6(v6: &SocketAddrV6, storage: *mut SocketAddrStorage) -> usize {
+    let encoded = encode_sockaddr_v6(v6);
+    core::ptr::write(storage.cast(), encoded);
+    size_of::<c::sockaddr_in6>()
+}
+
+#[cfg(unix)]
+unsafe fn write_sockaddr_unix(unix: &SocketAddrUnix, storage: *mut SocketAddrStorage) -> usize {
+    core::ptr::write(storage.cast(), unix.unix);
+    unix.len()
+}