8 files changed, 1216 insertions, 0 deletions
diff --git a/vendor/rustix/tests/net/addr.rs b/vendor/rustix/tests/net/addr.rs
new file mode 100644
index 000000000..124413132
--- /dev/null
+++ b/vendor/rustix/tests/net/addr.rs
@@ -0,0 +1,92 @@
+#[test]
+fn encode_decode() {
+    #[cfg(unix)]
+    use rustix::net::SocketAddrUnix;
+    use rustix::net::{
+        Ipv4Addr, Ipv6Addr, SocketAddrAny, SocketAddrStorage, SocketAddrV4, SocketAddrV6,
+    };
+
+    unsafe {
+        let orig = SocketAddrV4::new(Ipv4Addr::new(2, 3, 5, 6), 33);
+        let mut encoded = std::mem::MaybeUninit::<SocketAddrStorage>::uninit();
+        let len = SocketAddrAny::V4(orig).write(encoded.as_mut_ptr());
+        let decoded = SocketAddrAny::read(encoded.as_ptr(), len).unwrap();
+        assert_eq!(decoded, SocketAddrAny::V4(orig));
+
+        let orig = SocketAddrV6::new(Ipv6Addr::new(2, 3, 5, 6, 8, 9, 11, 12), 33, 34, 36);
+        let mut encoded = std::mem::MaybeUninit::<SocketAddrStorage>::uninit();
+        let len = SocketAddrAny::V6(orig).write(encoded.as_mut_ptr());
+        let decoded = SocketAddrAny::read(encoded.as_ptr(), len).unwrap();
+        assert_eq!(decoded, SocketAddrAny::V6(orig));
+
+        #[cfg(not(windows))]
+        {
+            let orig = SocketAddrUnix::new("/path/to/socket").unwrap();
+            let mut encoded = std::mem::MaybeUninit::<SocketAddrStorage>::uninit();
+            let len = SocketAddrAny::Unix(orig.clone()).write(encoded.as_mut_ptr());
+            let decoded = SocketAddrAny::read(encoded.as_ptr(), len).unwrap();
+            assert_eq!(decoded, SocketAddrAny::Unix(orig));
+        }
+    }
+}
+
+#[cfg(not(windows))]
+#[test]
+fn test_unix_addr() {
+    use rustix::cstr;
+    use rustix::net::SocketAddrUnix;
+
+    assert_eq!(
+        SocketAddrUnix::new("/").unwrap().path().unwrap(),
+        cstr!("/")
+    );
+    assert_eq!(
+        SocketAddrUnix::new("//").unwrap().path().unwrap(),
+        cstr!("//")
+    );
+    assert_eq!(
+        SocketAddrUnix::new("/foo/bar").unwrap().path().unwrap(),
+        cstr!("/foo/bar")
+    );
+    assert_eq!(
+        SocketAddrUnix::new("foo").unwrap().path().unwrap(),
+        cstr!("foo")
+    );
+    SocketAddrUnix::new("/foo\0/bar").unwrap_err();
+    assert!(SocketAddrUnix::new("").unwrap().path().is_none());
+
+    #[cfg(any(target_os = "android", target_os = "linux"))]
+    {
+        assert!(SocketAddrUnix::new("foo")
+            .unwrap()
+            .abstract_name()
+            .is_none());
+
+        assert_eq!(
+            SocketAddrUnix::new_abstract_name(b"test")
+                .unwrap()
+                .abstract_name()
+                .unwrap(),
+            b"test"
+        );
+        assert_eq!(
+            SocketAddrUnix::new_abstract_name(b"")
+                .unwrap()
+                .abstract_name()
+                .unwrap(),
+            b""
+        );
+        assert_eq!(
+            SocketAddrUnix::new_abstract_name(b"this\0that")
+                .unwrap()
+                .abstract_name()
+                .unwrap(),
+            b"this\0that"
+        );
+        SocketAddrUnix::new_abstract_name(&[b'a'; 500]).unwrap_err();
+        assert!(SocketAddrUnix::new_abstract_name(b"test")
+            .unwrap()
+            .path()
+            .is_none());
+    }
+}
diff --git a/vendor/rustix/tests/net/connect_bind_send.rs b/vendor/rustix/tests/net/connect_bind_send.rs
new file mode 100644
index 000000000..84720975f
--- /dev/null
+++ b/vendor/rustix/tests/net/connect_bind_send.rs
@@ -0,0 +1,487 @@
+use rustix::net::{
+    AddressFamily, Ipv6Addr, Protocol, RecvFlags, SendFlags, SocketAddrAny, SocketAddrV4,
+    SocketAddrV6, SocketType,
+};
+use std::net::{IpAddr, Ipv4Addr, SocketAddr};
+
+/// Test `connect_any`.
+#[test]
+fn net_v4_connect_any() -> std::io::Result<()> {
+    let localhost = IpAddr::V4(Ipv4Addr::LOCALHOST);
+    let addr = SocketAddr::new(localhost, 0);
+    let listener =
+        rustix::net::socket(AddressFamily::INET, SocketType::STREAM, Protocol::default())?;
+    rustix::net::bind(&listener, &addr).expect("bind");
+    rustix::net::listen(&listener, 1).expect("listen");
+
+    let local_addr = rustix::net::getsockname(&listener)?;
+    let sender = rustix::net::socket(AddressFamily::INET, SocketType::STREAM, Protocol::default())?;
+    rustix::net::connect_any(&sender, &local_addr).expect("connect");
+    let request = b"Hello, World!!!";
+    let n = rustix::net::send(&sender, request, SendFlags::empty()).expect("send");
+    drop(sender);
+
+    // Not strictly required, but it makes the test simpler.
+    assert_eq!(n, request.len());
+
+    let accepted = rustix::net::accept(&listener).expect("accept");
+    let mut response = [0_u8; 128];
+    let n = rustix::net::recv(&accepted, &mut response, RecvFlags::empty()).expect("recv");
+
+    // Not strictly required, but it makes the test simpler.
+    assert_eq!(n, request.len());
+
+    assert_eq!(request, &response[..n]);
+
+    Ok(())
+}
+
+/// Similar, but with V6.
+#[test]
+fn net_v6_connect_any() -> std::io::Result<()> {
+    let localhost = IpAddr::V6(Ipv6Addr::LOCALHOST);
+    let addr = SocketAddr::new(localhost, 0);
+    let listener = rustix::net::socket(
+        AddressFamily::INET6,
+        SocketType::STREAM,
+        Protocol::default(),
+    )?;
+    rustix::net::bind(&listener, &addr).expect("bind");
+    rustix::net::listen(&listener, 1).expect("listen");
+
+    let local_addr = rustix::net::getsockname(&listener)?;
+    let sender = rustix::net::socket(
+        AddressFamily::INET6,
+        SocketType::STREAM,
+        Protocol::default(),
+    )?;
+    rustix::net::connect_any(&sender, &local_addr).expect("connect");
+    let request = b"Hello, World!!!";
+    let n = rustix::net::send(&sender, request, SendFlags::empty()).expect("send");
+    drop(sender);
+
+    // Not strictly required, but it makes the test simpler.
+    assert_eq!(n, request.len());
+
+    let accepted = rustix::net::accept(&listener).expect("accept");
+    let mut response = [0_u8; 128];
+    let n = rustix::net::recv(&accepted, &mut response, RecvFlags::empty()).expect("recv");
+
+    // Not strictly required, but it makes the test simpler.
+    assert_eq!(n, request.len());
+
+    assert_eq!(request, &response[..n]);
+
+    Ok(())
+}
+
+/// Test `connect` with a `SocketAddr`.
+#[test]
+fn net_v4_connect() -> std::io::Result<()> {
+    let localhost = IpAddr::V4(Ipv4Addr::LOCALHOST);
+    let addr = SocketAddr::new(localhost, 0);
+    let listener =
+        rustix::net::socket(AddressFamily::INET, SocketType::STREAM, Protocol::default())?;
+    rustix::net::bind(&listener, &addr).expect("bind");
+    rustix::net::listen(&listener, 1).expect("listen");
+
+    let local_addr = rustix::net::getsockname(&listener)?;
+    let local_addr = match local_addr {
+        SocketAddrAny::V4(v4) => SocketAddr::V4(v4),
+        other => panic!("unexpected socket address {:?}", other),
+    };
+    let sender = rustix::net::socket(AddressFamily::INET, SocketType::STREAM, Protocol::default())?;
+    rustix::net::connect(&sender, &local_addr).expect("connect");
+    let request = b"Hello, World!!!";
+    let n = rustix::net::send(&sender, request, SendFlags::empty()).expect("send");
+    drop(sender);
+
+    // Not strictly required, but it makes the test simpler.
+    assert_eq!(n, request.len());
+
+    let accepted = rustix::net::accept(&listener).expect("accept");
+    let mut response = [0_u8; 128];
+    let n = rustix::net::recv(&accepted, &mut response, RecvFlags::empty()).expect("recv");
+
+    // Not strictly required, but it makes the test simpler.
+    assert_eq!(n, request.len());
+
+    assert_eq!(request, &response[..n]);
+
+    Ok(())
+}
+
+/// Similar, but use V6.
+#[test]
+fn net_v6_connect() -> std::io::Result<()> {
+    let localhost = IpAddr::V6(Ipv6Addr::LOCALHOST);
+    let addr = SocketAddr::new(localhost, 0);
+    let listener = rustix::net::socket(
+        AddressFamily::INET6,
+        SocketType::STREAM,
+        Protocol::default(),
+    )?;
+    rustix::net::bind(&listener, &addr).expect("bind");
+    rustix::net::listen(&listener, 1).expect("listen");
+
+    let local_addr = rustix::net::getsockname(&listener)?;
+    let local_addr = match local_addr {
+        SocketAddrAny::V6(v6) => SocketAddr::V6(v6),
+        other => panic!("unexpected socket address {:?}", other),
+    };
+    let sender = rustix::net::socket(
+        AddressFamily::INET6,
+        SocketType::STREAM,
+        Protocol::default(),
+    )?;
+    rustix::net::connect(&sender, &local_addr).expect("connect");
+    let request = b"Hello, World!!!";
+    let n = rustix::net::send(&sender, request, SendFlags::empty()).expect("send");
+    drop(sender);
+
+    // Not strictly required, but it makes the test simpler.
+    assert_eq!(n, request.len());
+
+    let accepted = rustix::net::accept(&listener).expect("accept");
+    let mut response = [0_u8; 128];
+    let n = rustix::net::recv(&accepted, &mut response, RecvFlags::empty()).expect("recv");
+
+    // Not strictly required, but it makes the test simpler.
+    assert_eq!(n, request.len());
+
+    assert_eq!(request, &response[..n]);
+
+    Ok(())
+}
+
+/// Test `bind_any`.
+#[test]
+fn net_v4_bind_any() -> std::io::Result<()> {
+    let localhost = Ipv4Addr::LOCALHOST;
+    let addr = SocketAddrAny::V4(SocketAddrV4::new(localhost, 0));
+    let listener =
+        rustix::net::socket(AddressFamily::INET, SocketType::STREAM, Protocol::default())?;
+    rustix::net::bind_any(&listener, &addr).expect("bind");
+    rustix::net::listen(&listener, 1).expect("listen");
+
+    let local_addr = rustix::net::getsockname(&listener)?;
+    let sender = rustix::net::socket(AddressFamily::INET, SocketType::STREAM, Protocol::default())?;
+    rustix::net::connect_any(&sender, &local_addr).expect("connect");
+    let request = b"Hello, World!!!";
+    let n = rustix::net::send(&sender, request, SendFlags::empty()).expect("send");
+    drop(sender);
+
+    // Not strictly required, but it makes the test simpler.
+    assert_eq!(n, request.len());
+
+    let accepted = rustix::net::accept(&listener).expect("accept");
+    let mut response = [0_u8; 128];
+    let n = rustix::net::recv(&accepted, &mut response, RecvFlags::empty()).expect("recv");
+
+    // Not strictly required, but it makes the test simpler.
+    assert_eq!(n, request.len());
+
+    assert_eq!(request, &response[..n]);
+
+    Ok(())
+}
+
+/// Similar, but use V6.
+#[test]
+fn net_v6_bind_any() -> std::io::Result<()> {
+    let localhost = Ipv6Addr::LOCALHOST;
+    let addr = SocketAddrAny::V6(SocketAddrV6::new(localhost, 0, 0, 0));
+    let listener = rustix::net::socket(
+        AddressFamily::INET6,
+        SocketType::STREAM,
+        Protocol::default(),
+    )?;
+    rustix::net::bind_any(&listener, &addr).expect("bind");
+    rustix::net::listen(&listener, 1).expect("listen");
+
+    let local_addr = rustix::net::getsockname(&listener)?;
+    let sender = rustix::net::socket(
+        AddressFamily::INET6,
+        SocketType::STREAM,
+        Protocol::default(),
+    )?;
+    rustix::net::connect_any(&sender, &local_addr).expect("connect");
+    let request = b"Hello, World!!!";
+    let n = rustix::net::send(&sender, request, SendFlags::empty()).expect("send");
+    drop(sender);
+
+    // Not strictly required, but it makes the test simpler.
+    assert_eq!(n, request.len());
+
+    let accepted = rustix::net::accept(&listener).expect("accept");
+    let mut response = [0_u8; 128];
+    let n = rustix::net::recv(&accepted, &mut response, RecvFlags::empty()).expect("recv");
+
+    // Not strictly required, but it makes the test simpler.
+    assert_eq!(n, request.len());
+
+    assert_eq!(request, &response[..n]);
+
+    Ok(())
+}
+
+/// Test `sendto`.
+#[test]
+fn net_v4_sendto() -> std::io::Result<()> {
+    let localhost = IpAddr::V4(Ipv4Addr::LOCALHOST);
+    let addr = SocketAddr::new(localhost, 0);
+    let listener =
+        rustix::net::socket(AddressFamily::INET, SocketType::STREAM, Protocol::default())?;
+    rustix::net::bind(&listener, &addr).expect("bind");
+    rustix::net::listen(&listener, 1).expect("listen");
+
+    let local_addr = rustix::net::getsockname(&listener)?;
+    let sender = rustix::net::socket(AddressFamily::INET, SocketType::STREAM, Protocol::default())?;
+    rustix::net::connect_any(&sender, &local_addr).expect("connect");
+    let request = b"Hello, World!!!";
+    let local_addr = match local_addr {
+        SocketAddrAny::V4(v4) => SocketAddr::V4(v4),
+        other => panic!("unexpected socket address {:?}", other),
+    };
+    let n = rustix::net::sendto(&sender, request, SendFlags::empty(), &local_addr).expect("send");
+    drop(sender);
+
+    // Not strictly required, but it makes the test simpler.
+    assert_eq!(n, request.len());
+
+    let accepted = rustix::net::accept(&listener).expect("accept");
+    let mut response = [0_u8; 128];
+    let (n, from) =
+        rustix::net::recvfrom(&accepted, &mut response, RecvFlags::empty()).expect("recv");
+
+    // Not strictly required, but it makes the test simpler.
+    assert_eq!(n, request.len());
+
+    assert_eq!(request, &response[..n]);
+    assert!(from.is_none());
+
+    Ok(())
+}
+
+/// Similar, but with V6.
+#[test]
+fn net_v6_sendto() -> std::io::Result<()> {
+    let localhost = IpAddr::V6(Ipv6Addr::LOCALHOST);
+    let addr = SocketAddr::new(localhost, 0);
+    let listener = rustix::net::socket(
+        AddressFamily::INET6,
+        SocketType::STREAM,
+        Protocol::default(),
+    )?;
+    rustix::net::bind(&listener, &addr).expect("bind");
+    rustix::net::listen(&listener, 1).expect("listen");
+
+    let local_addr = rustix::net::getsockname(&listener)?;
+    let sender = rustix::net::socket(
+        AddressFamily::INET6,
+        SocketType::STREAM,
+        Protocol::default(),
+    )?;
+    rustix::net::connect_any(&sender, &local_addr).expect("connect");
+    let request = b"Hello, World!!!";
+    let local_addr = match local_addr {
+        SocketAddrAny::V6(v6) => SocketAddr::V6(v6),
+        other => panic!("unexpected socket address {:?}", other),
+    };
+    let n = rustix::net::sendto(&sender, request, SendFlags::empty(), &local_addr).expect("send");
+    drop(sender);
+
+    // Not strictly required, but it makes the test simpler.
+    assert_eq!(n, request.len());
+
+    let accepted = rustix::net::accept(&listener).expect("accept");
+    let mut response = [0_u8; 128];
+    let (n, from) =
+        rustix::net::recvfrom(&accepted, &mut response, RecvFlags::empty()).expect("recv");
+
+    // Not strictly required, but it makes the test simpler.
+    assert_eq!(n, request.len());
+
+    assert_eq!(request, &response[..n]);
+    assert!(from.is_none());
+
+    Ok(())
+}
+
+/// Test `sendto_any`.
+#[test]
+fn net_v4_sendto_any() -> std::io::Result<()> {
+    let localhost = IpAddr::V4(Ipv4Addr::LOCALHOST);
+    let addr = SocketAddr::new(localhost, 0);
+    let listener =
+        rustix::net::socket(AddressFamily::INET, SocketType::STREAM, Protocol::default())?;
+    rustix::net::bind(&listener, &addr).expect("bind");
+    rustix::net::listen(&listener, 1).expect("listen");
+
+    let local_addr = rustix::net::getsockname(&listener)?;
+    let sender = rustix::net::socket(AddressFamily::INET, SocketType::STREAM, Protocol::default())?;
+    rustix::net::connect_any(&sender, &local_addr).expect("connect");
+    let request = b"Hello, World!!!";
+    let n =
+        rustix::net::sendto_any(&sender, request, SendFlags::empty(), &local_addr).expect("send");
+    drop(sender);
+
+    // Not strictly required, but it makes the test simpler.
+    assert_eq!(n, request.len());
+
+    let accepted = rustix::net::accept(&listener).expect("accept");
+    let mut response = [0_u8; 128];
+    let (n, from) =
+        rustix::net::recvfrom(&accepted, &mut response, RecvFlags::empty()).expect("recv");
+
+    // Not strictly required, but it makes the test simpler.
+    assert_eq!(n, request.len());
+
+    assert_eq!(request, &response[..n]);
+    assert!(from.is_none());
+
+    Ok(())
+}
+
+/// Test `sendto_any`.
+#[test]
+fn net_v6_sendto_any() -> std::io::Result<()> {
+    let localhost = IpAddr::V6(Ipv6Addr::LOCALHOST);
+    let addr = SocketAddr::new(localhost, 0);
+    let listener = rustix::net::socket(
+        AddressFamily::INET6,
+        SocketType::STREAM,
+        Protocol::default(),
+    )?;
+    rustix::net::bind(&listener, &addr).expect("bind");
+    rustix::net::listen(&listener, 1).expect("listen");
+
+    let local_addr = rustix::net::getsockname(&listener)?;
+    let sender = rustix::net::socket(
+        AddressFamily::INET6,
+        SocketType::STREAM,
+        Protocol::default(),
+    )?;
+    rustix::net::connect_any(&sender, &local_addr).expect("connect");
+    let request = b"Hello, World!!!";
+    let n =
+        rustix::net::sendto_any(&sender, request, SendFlags::empty(), &local_addr).expect("send");
+    drop(sender);
+
+    // Not strictly required, but it makes the test simpler.
+    assert_eq!(n, request.len());
+
+    let accepted = rustix::net::accept(&listener).expect("accept");
+    let mut response = [0_u8; 128];
+    let (n, from) =
+        rustix::net::recvfrom(&accepted, &mut response, RecvFlags::empty()).expect("recv");
+
+    // Not strictly required, but it makes the test simpler.
+    assert_eq!(n, request.len());
+
+    assert_eq!(request, &response[..n]);
+    assert!(from.is_none());
+
+    Ok(())
+}
+
+/// Test `acceptfrom`.
+#[test]
+fn net_v4_acceptfrom() -> std::io::Result<()> {
+    let localhost = IpAddr::V4(Ipv4Addr::LOCALHOST);
+    let addr = SocketAddr::new(localhost, 0);
+    let listener =
+        rustix::net::socket(AddressFamily::INET, SocketType::STREAM, Protocol::default())?;
+    rustix::net::bind(&listener, &addr).expect("bind");
+    rustix::net::listen(&listener, 1).expect("listen");
+
+    let local_addr = rustix::net::getsockname(&listener)?;
+    let sender = rustix::net::socket(AddressFamily::INET, SocketType::STREAM, Protocol::default())?;
+    rustix::net::connect_any(&sender, &local_addr).expect("connect");
+    let request = b"Hello, World!!!";
+    let n = rustix::net::send(&sender, request, SendFlags::empty()).expect("send");
+    drop(sender);
+
+    // Not strictly required, but it makes the test simpler.
+    assert_eq!(n, request.len());
+
+    let (accepted, from) = rustix::net::acceptfrom(&listener).expect("accept");
+
+    assert_ne!(from.clone().unwrap(), local_addr);
+
+    let from = match from.unwrap() {
+        SocketAddrAny::V4(v4) => v4,
+        other => panic!("unexpected socket address {:?}", other),
+    };
+    let local_addr = match local_addr {
+        SocketAddrAny::V4(v4) => v4,
+        other => panic!("unexpected socket address {:?}", other),
+    };
+
+    assert_eq!(from.clone().ip(), local_addr.ip());
+    assert_ne!(from.clone().port(), local_addr.port());
+
+    let mut response = [0_u8; 128];
+    let n = rustix::net::recv(&accepted, &mut response, RecvFlags::empty()).expect("recv");
+
+    // Not strictly required, but it makes the test simpler.
+    assert_eq!(n, request.len());
+
+    assert_eq!(request, &response[..n]);
+
+    Ok(())
+}
+
+/// Similar, but with V6.
+#[test]
+fn net_v6_acceptfrom() -> std::io::Result<()> {
+    let localhost = IpAddr::V6(Ipv6Addr::LOCALHOST);
+    let addr = SocketAddr::new(localhost, 0);
+    let listener = rustix::net::socket(
+        AddressFamily::INET6,
+        SocketType::STREAM,
+        Protocol::default(),
+    )?;
+    rustix::net::bind(&listener, &addr).expect("bind");
+    rustix::net::listen(&listener, 1).expect("listen");
+
+    let local_addr = rustix::net::getsockname(&listener)?;
+    let sender = rustix::net::socket(
+        AddressFamily::INET6,
+        SocketType::STREAM,
+        Protocol::default(),
+    )?;
+    rustix::net::connect_any(&sender, &local_addr).expect("connect");
+    let request = b"Hello, World!!!";
+    let n = rustix::net::send(&sender, request, SendFlags::empty()).expect("send");
+    drop(sender);
+
+    // Not strictly required, but it makes the test simpler.
+    assert_eq!(n, request.len());
+
+    let (accepted, from) = rustix::net::acceptfrom(&listener).expect("accept");
+
+    assert_ne!(from.clone().unwrap(), local_addr);
+
+    let from = match from.unwrap() {
+        SocketAddrAny::V6(v6) => v6,
+        other => panic!("unexpected socket address {:?}", other),
+    };
+    let local_addr = match local_addr {
+        SocketAddrAny::V6(v6) => v6,
+        other => panic!("unexpected socket address {:?}", other),
+    };
+
+    assert_eq!(from.clone().ip(), local_addr.ip());
+    assert_ne!(from.clone().port(), local_addr.port());
+
+    let mut response = [0_u8; 128];
+    let n = rustix::net::recv(&accepted, &mut response, RecvFlags::empty()).expect("recv");
+
+    // Not strictly required, but it makes the test simpler.
+    assert_eq!(n, request.len());
+
+    assert_eq!(request, &response[..n]);
+
+    Ok(())
+}
diff --git a/vendor/rustix/tests/net/main.rs b/vendor/rustix/tests/net/main.rs
new file mode 100644
index 000000000..0745282aa
--- /dev/null
+++ b/vendor/rustix/tests/net/main.rs
@@ -0,0 +1,32 @@
+//! Tests for [`rustix::net`].
+
+#![cfg(feature = "net")]
+#![cfg_attr(target_os = "wasi", feature(wasi_ext))]
+#![cfg(not(any(target_os = "redox", target_os = "wasi")))]
+#![cfg_attr(io_lifetimes_use_std, feature(io_safety))]
+#![cfg_attr(core_c_str, feature(core_c_str))]
+
+mod addr;
+mod connect_bind_send;
+mod poll;
+mod sockopt;
+#[cfg(unix)]
+mod unix;
+mod v4;
+mod v6;
+
+/// Windows requires us to call a setup function before using any of the
+/// socket APIs.
+#[cfg(windows)]
+#[ctor::ctor]
+fn windows_startup() {
+    let _ = rustix::net::wsa_startup().unwrap();
+}
+
+/// Windows requires us to call a cleanup function after using any of the
+/// socket APIs.
+#[cfg(windows)]
+#[ctor::dtor]
+fn windows_shutdown() {
+    rustix::net::wsa_cleanup().unwrap();
+}
diff --git a/vendor/rustix/tests/net/poll.rs b/vendor/rustix/tests/net/poll.rs
new file mode 100644
index 000000000..7933983f2
--- /dev/null
+++ b/vendor/rustix/tests/net/poll.rs
@@ -0,0 +1,119 @@
+//! The same as v6.rs, but with `poll` calls.
+
+#![cfg(not(any(target_os = "redox", target_os = "wasi")))]
+
+use rustix::io::{poll, PollFd, PollFlags};
+use rustix::net::{
+    accept, bind_v6, connect_v6, getsockname, listen, recv, send, socket, AddressFamily, Ipv6Addr,
+    Protocol, RecvFlags, SendFlags, SocketAddrAny, SocketAddrV6, SocketType,
+};
+use std::sync::{Arc, Condvar, Mutex};
+use std::thread;
+
+const BUFFER_SIZE: usize = 20;
+
+fn server(ready: Arc<(Mutex<u16>, Condvar)>) {
+    let connection_socket = socket(
+        AddressFamily::INET6,
+        SocketType::STREAM,
+        Protocol::default(),
+    )
+    .unwrap();
+
+    let name = SocketAddrV6::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 0, 0, 0);
+    bind_v6(&connection_socket, &name).unwrap();
+
+    let who = match getsockname(&connection_socket).unwrap() {
+        SocketAddrAny::V6(addr) => addr,
+        _ => panic!(),
+    };
+
+    listen(&connection_socket, 1).unwrap();
+
+    {
+        let (lock, cvar) = &*ready;
+        let mut port = lock.lock().unwrap();
+        *port = who.port();
+        cvar.notify_all();
+    }
+
+    let mut buffer = vec![0; BUFFER_SIZE];
+    let data_socket = accept(&connection_socket).unwrap();
+
+    let mut fds = [PollFd::new(&data_socket, PollFlags::IN)];
+    assert_eq!(poll(&mut fds, -1).unwrap(), 1);
+    assert!(fds[0].revents().intersects(PollFlags::IN));
+    assert!(!fds[0].revents().intersects(PollFlags::OUT));
+
+    let expected_nread = rustix::io::ioctl_fionread(&data_socket).unwrap();
+    let nread = recv(&data_socket, &mut buffer, RecvFlags::empty()).unwrap();
+    assert_eq!(String::from_utf8_lossy(&buffer[..nread]), "hello, world");
+    assert_eq!(expected_nread, nread as u64);
+
+    let mut fds = [PollFd::new(&data_socket, PollFlags::OUT)];
+    assert_eq!(poll(&mut fds, -1).unwrap(), 1);
+    assert!(!fds[0].revents().intersects(PollFlags::IN));
+    assert!(fds[0].revents().intersects(PollFlags::OUT));
+
+    send(&data_socket, b"goodnight, moon", SendFlags::empty()).unwrap();
+}
+
+fn client(ready: Arc<(Mutex<u16>, Condvar)>) {
+    let port = {
+        let (lock, cvar) = &*ready;
+        let mut port = lock.lock().unwrap();
+        while *port == 0 {
+            port = cvar.wait(port).unwrap();
+        }
+        *port
+    };
+
+    let addr = SocketAddrV6::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), port, 0, 0);
+    let mut buffer = vec![0; BUFFER_SIZE];
+
+    let data_socket = socket(
+        AddressFamily::INET6,
+        SocketType::STREAM,
+        Protocol::default(),
+    )
+    .unwrap();
+    connect_v6(&data_socket, &addr).unwrap();
+
+    let mut fds = [PollFd::new(&data_socket, PollFlags::OUT)];
+    assert_eq!(poll(&mut fds, -1).unwrap(), 1);
+    assert!(!fds[0].revents().intersects(PollFlags::IN));
+    assert!(fds[0].revents().intersects(PollFlags::OUT));
+
+    send(&data_socket, b"hello, world", SendFlags::empty()).unwrap();
+
+    let mut fds = [PollFd::new(&data_socket, PollFlags::IN)];
+    assert_eq!(poll(&mut fds, -1).unwrap(), 1);
+    assert!(fds[0].revents().intersects(PollFlags::IN));
+    assert!(!fds[0].revents().intersects(PollFlags::OUT));
+
+    let expected_nread = rustix::io::ioctl_fionread(&data_socket).unwrap();
+    let nread = recv(&data_socket, &mut buffer, RecvFlags::empty()).unwrap();
+    assert_eq!(String::from_utf8_lossy(&buffer[..nread]), "goodnight, moon");
+    assert_eq!(expected_nread, nread as u64);
+}
+
+#[test]
+fn test_poll() {
+    let ready = Arc::new((Mutex::new(0_u16), Condvar::new()));
+    let ready_clone = Arc::clone(&ready);
+
+    let server = thread::Builder::new()
+        .name("server".to_string())
+        .spawn(move || {
+            server(ready);
+        })
+        .unwrap();
+    let client = thread::Builder::new()
+        .name("client".to_string())
+        .spawn(move || {
+            client(ready_clone);
+        })
+        .unwrap();
+    client.join().unwrap();
+    server.join().unwrap();
+}
diff --git a/vendor/rustix/tests/net/sockopt.rs b/vendor/rustix/tests/net/sockopt.rs
new file mode 100644
index 000000000..8e4cf52e8
--- /dev/null
+++ b/vendor/rustix/tests/net/sockopt.rs
@@ -0,0 +1,158 @@
+#[test]
+fn test_sockopts() {
+    use rustix::net::{AddressFamily, Protocol, SocketType};
+    use std::time::Duration;
+
+    let s =
+        rustix::net::socket(AddressFamily::INET, SocketType::STREAM, Protocol::default()).unwrap();
+
+    // On a new socket we shouldn't have a timeout yet.
+    assert!(
+        rustix::net::sockopt::get_socket_timeout(&s, rustix::net::sockopt::Timeout::Recv)
+            .unwrap()
+            .is_none()
+    );
+    assert_eq!(
+        rustix::net::sockopt::get_socket_type(&s).unwrap(),
+        SocketType::STREAM
+    );
+    #[cfg(not(windows))]
+    assert_eq!(
+        rustix::net::sockopt::get_socket_broadcast(&s).unwrap(),
+        false
+    );
+    // On a new socket we shouldn't have a linger yet.
+    assert!(rustix::net::sockopt::get_socket_linger(&s)
+        .unwrap()
+        .is_none());
+    #[cfg(any(target_os = "android", target_os = "linux"))]
+    assert_eq!(
+        rustix::net::sockopt::get_socket_passcred(&s).unwrap(),
+        false
+    );
+    assert_ne!(rustix::net::sockopt::get_ip_ttl(&s).unwrap(), 0);
+    assert_ne!(rustix::net::sockopt::get_ip_ttl(&s).unwrap(), 77);
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    )))]
+    assert_eq!(
+        rustix::net::sockopt::get_ip_multicast_loop(&s).unwrap(),
+        true
+    );
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    )))]
+    assert_eq!(rustix::net::sockopt::get_ip_multicast_ttl(&s).unwrap(), 1);
+    assert_eq!(rustix::net::sockopt::get_tcp_nodelay(&s).unwrap(), false);
+
+    // Set a timeout.
+    rustix::net::sockopt::set_socket_timeout(
+        &s,
+        rustix::net::sockopt::Timeout::Recv,
+        Some(Duration::new(1, 1)),
+    )
+    .unwrap();
+
+    // Check that we have a timeout of at least the time we set.
+    if cfg!(not(target_os = "freebsd")) {
+        assert!(
+            rustix::net::sockopt::get_socket_timeout(&s, rustix::net::sockopt::Timeout::Recv)
+                .unwrap()
+                .unwrap()
+                >= Duration::new(1, 1)
+        );
+    } else {
+        // On FreeBSD <= 12, it appears the system rounds the timeout down.
+        assert!(
+            rustix::net::sockopt::get_socket_timeout(&s, rustix::net::sockopt::Timeout::Recv)
+                .unwrap()
+                .unwrap()
+                >= Duration::new(1, 0)
+        );
+    }
+
+    #[cfg(not(windows))]
+    {
+        // Set the broadcast flag;
+        rustix::net::sockopt::set_socket_broadcast(&s, true).unwrap();
+
+        // Check that the broadcast flag is set. This has no effect on stream
+        // sockets, and not all platforms even remember the value.
+        #[cfg(not(any(
+            target_os = "dragonfly",
+            target_os = "freebsd",
+            target_os = "ios",
+            target_os = "macos",
+            target_os = "netbsd",
+            target_os = "openbsd",
+        )))]
+        assert_eq!(
+            rustix::net::sockopt::get_socket_broadcast(&s).unwrap(),
+            true
+        );
+    }
+
+    // Set a linger.
+    rustix::net::sockopt::set_socket_linger(&s, Some(Duration::new(1, 1))).unwrap();
+
+    // Check that we have a linger of at least the time we set.
+    assert!(
+        dbg!(rustix::net::sockopt::get_socket_linger(&s)
+            .unwrap()
+            .unwrap())
+            >= Duration::new(1, 1)
+    );
+
+    #[cfg(any(target_os = "android", target_os = "linux"))]
+    {
+        // Set the passcred flag;
+        rustix::net::sockopt::set_socket_passcred(&s, true).unwrap();
+
+        // Check that the passcred flag is set.
+        assert_eq!(rustix::net::sockopt::get_socket_passcred(&s).unwrap(), true);
+    }
+
+    // Set the ip ttl.
+    rustix::net::sockopt::set_ip_ttl(&s, 77).unwrap();
+
+    // Check the ip ttl.
+    assert_eq!(rustix::net::sockopt::get_ip_ttl(&s).unwrap(), 77);
+
+    #[cfg(not(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    )))]
+    {
+        // Set the multicast loop flag;
+        rustix::net::sockopt::set_ip_multicast_loop(&s, false).unwrap();
+
+        // Check that the multicast loop flag is set.
+        assert_eq!(
+            rustix::net::sockopt::get_ip_multicast_loop(&s).unwrap(),
+            false
+        );
+    }
+
+    // Set the nodelay flag;
+    rustix::net::sockopt::set_tcp_nodelay(&s, true).unwrap();
+
+    // Check that the nodelay flag is set.
+    assert_eq!(rustix::net::sockopt::get_tcp_nodelay(&s).unwrap(), true);
+}
diff --git a/vendor/rustix/tests/net/unix.rs b/vendor/rustix/tests/net/unix.rs
new file mode 100644
index 000000000..21a6542f8
--- /dev/null
+++ b/vendor/rustix/tests/net/unix.rs
@@ -0,0 +1,147 @@
+//! Test a simple Unix-domain socket server and client.
+//!
+//! The client sends lists of integers and the server sends back sums.
+
+// This test uses `AF_UNIX` with `SOCK_SEQPACKET` which is unsupported on macOS.
+#![cfg(not(any(
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "redox",
+    target_os = "wasi",
+)))]
+// This test uses `DecInt`.
+#![cfg(feature = "itoa")]
+#![cfg(feature = "fs")]
+
+use rustix::fs::{cwd, unlinkat, AtFlags};
+use rustix::io::{read, write};
+use rustix::net::{
+    accept, bind_unix, connect_unix, listen, socket, AddressFamily, Protocol, SocketAddrUnix,
+    SocketType,
+};
+use rustix::path::DecInt;
+use std::path::Path;
+use std::str::FromStr;
+use std::sync::{Arc, Condvar, Mutex};
+use std::thread;
+
+const BUFFER_SIZE: usize = 20;
+
+fn server(ready: Arc<(Mutex<bool>, Condvar)>, path: &Path) {
+    let connection_socket = socket(
+        AddressFamily::UNIX,
+        SocketType::SEQPACKET,
+        Protocol::default(),
+    )
+    .unwrap();
+
+    let name = SocketAddrUnix::new(path).unwrap();
+    bind_unix(&connection_socket, &name).unwrap();
+    listen(&connection_socket, 1).unwrap();
+
+    {
+        let (lock, cvar) = &*ready;
+        let mut started = lock.lock().unwrap();
+        *started = true;
+        cvar.notify_all();
+    }
+
+    let mut buffer = vec![0; BUFFER_SIZE];
+    'exit: loop {
+        let data_socket = accept(&connection_socket).unwrap();
+        let mut sum = 0;
+        loop {
+            let nread = read(&data_socket, &mut buffer).unwrap();
+
+            if &buffer[..nread] == b"exit" {
+                break 'exit;
+            }
+            if &buffer[..nread] == b"sum" {
+                break;
+            }
+
+            sum += i32::from_str(&String::from_utf8_lossy(&buffer[..nread])).unwrap();
+        }
+
+        write(&data_socket, DecInt::new(sum).as_bytes()).unwrap();
+    }
+
+    unlinkat(cwd(), path, AtFlags::empty()).unwrap();
+}
+
+fn client(ready: Arc<(Mutex<bool>, Condvar)>, path: &Path, runs: &[(&[&str], i32)]) {
+    {
+        let (lock, cvar) = &*ready;
+        let mut started = lock.lock().unwrap();
+        while !*started {
+            started = cvar.wait(started).unwrap();
+        }
+    }
+
+    let addr = SocketAddrUnix::new(path).unwrap();
+    let mut buffer = vec![0; BUFFER_SIZE];
+
+    for (args, sum) in runs {
+        let data_socket = socket(
+            AddressFamily::UNIX,
+            SocketType::SEQPACKET,
+            Protocol::default(),
+        )
+        .unwrap();
+        connect_unix(&data_socket, &addr).unwrap();
+
+        for arg in *args {
+            write(&data_socket, arg.as_bytes()).unwrap();
+        }
+        write(&data_socket, b"sum").unwrap();
+
+        let nread = read(&data_socket, &mut buffer).unwrap();
+        assert_eq!(
+            i32::from_str(&String::from_utf8_lossy(&buffer[..nread])).unwrap(),
+            *sum
+        );
+    }
+
+    let data_socket = socket(
+        AddressFamily::UNIX,
+        SocketType::SEQPACKET,
+        Protocol::default(),
+    )
+    .unwrap();
+    connect_unix(&data_socket, &addr).unwrap();
+    write(&data_socket, b"exit").unwrap();
+}
+
+#[test]
+fn test_unix() {
+    let ready = Arc::new((Mutex::new(false), Condvar::new()));
+    let ready_clone = Arc::clone(&ready);
+
+    let tmp = tempfile::tempdir().unwrap();
+    let path = tmp.path().join("soccer");
+    let send_path = path.to_owned();
+    let server = thread::Builder::new()
+        .name("server".to_string())
+        .spawn(move || {
+            server(ready, &send_path);
+        })
+        .unwrap();
+    let send_path = path.to_owned();
+    let client = thread::Builder::new()
+        .name("client".to_string())
+        .spawn(move || {
+            client(
+                ready_clone,
+                &send_path,
+                &[
+                    (&["1", "2"], 3),
+                    (&["4", "77", "103"], 184),
+                    (&["5", "78", "104"], 187),
+                    (&[], 0),
+                ],
+            );
+        })
+        .unwrap();
+    client.join().unwrap();
+    server.join().unwrap();
+}
diff --git a/vendor/rustix/tests/net/v4.rs b/vendor/rustix/tests/net/v4.rs
new file mode 100644
index 000000000..0908057be
--- /dev/null
+++ b/vendor/rustix/tests/net/v4.rs
@@ -0,0 +1,86 @@
+//! Test a simple IPv4 socket server and client.
+//!
+//! The client send a message and the server sends one back.
+
+#![cfg(not(any(target_os = "redox", target_os = "wasi")))]
+
+use rustix::net::{
+    accept, bind_v4, connect_v4, getsockname, listen, recv, send, socket, AddressFamily, Ipv4Addr,
+    Protocol, RecvFlags, SendFlags, SocketAddrAny, SocketAddrV4, SocketType,
+};
+use std::sync::{Arc, Condvar, Mutex};
+use std::thread;
+
+const BUFFER_SIZE: usize = 20;
+
+fn server(ready: Arc<(Mutex<u16>, Condvar)>) {
+    let connection_socket =
+        socket(AddressFamily::INET, SocketType::STREAM, Protocol::default()).unwrap();
+
+    let name = SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 0);
+    bind_v4(&connection_socket, &name).unwrap();
+
+    let who = match getsockname(&connection_socket).unwrap() {
+        SocketAddrAny::V4(addr) => addr,
+        _ => panic!(),
+    };
+
+    listen(&connection_socket, 1).unwrap();
+
+    {
+        let (lock, cvar) = &*ready;
+        let mut port = lock.lock().unwrap();
+        *port = who.port();
+        cvar.notify_all();
+    }
+
+    let mut buffer = vec![0; BUFFER_SIZE];
+    let data_socket = accept(&connection_socket).unwrap();
+    let nread = recv(&data_socket, &mut buffer, RecvFlags::empty()).unwrap();
+    assert_eq!(String::from_utf8_lossy(&buffer[..nread]), "hello, world");
+
+    send(&data_socket, b"goodnight, moon", SendFlags::empty()).unwrap();
+}
+
+fn client(ready: Arc<(Mutex<u16>, Condvar)>) {
+    let port = {
+        let (lock, cvar) = &*ready;
+        let mut port = lock.lock().unwrap();
+        while *port == 0 {
+            port = cvar.wait(port).unwrap();
+        }
+        *port
+    };
+
+    let addr = SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), port);
+    let mut buffer = vec![0; BUFFER_SIZE];
+
+    let data_socket = socket(AddressFamily::INET, SocketType::STREAM, Protocol::default()).unwrap();
+    connect_v4(&data_socket, &addr).unwrap();
+
+    send(&data_socket, b"hello, world", SendFlags::empty()).unwrap();
+
+    let nread = recv(&data_socket, &mut buffer, RecvFlags::empty()).unwrap();
+    assert_eq!(String::from_utf8_lossy(&buffer[..nread]), "goodnight, moon");
+}
+
+#[test]
+fn test_v4() {
+    let ready = Arc::new((Mutex::new(0_u16), Condvar::new()));
+    let ready_clone = Arc::clone(&ready);
+
+    let server = thread::Builder::new()
+        .name("server".to_string())
+        .spawn(move || {
+            server(ready);
+        })
+        .unwrap();
+    let client = thread::Builder::new()
+        .name("client".to_string())
+        .spawn(move || {
+            client(ready_clone);
+        })
+        .unwrap();
+    client.join().unwrap();
+    server.join().unwrap();
+}
diff --git a/vendor/rustix/tests/net/v6.rs b/vendor/rustix/tests/net/v6.rs
new file mode 100644
index 000000000..07205be89
--- /dev/null
+++ b/vendor/rustix/tests/net/v6.rs
@@ -0,0 +1,95 @@
+//! Test a simple IPv6 socket server and client.
+//!
+//! The client send a message and the server sends one back.
+
+#![cfg(not(any(target_os = "redox", target_os = "wasi")))]
+
+use rustix::net::{
+    accept, bind_v6, connect_v6, getsockname, listen, recv, send, socket, AddressFamily, Ipv6Addr,
+    Protocol, RecvFlags, SendFlags, SocketAddrAny, SocketAddrV6, SocketType,
+};
+use std::sync::{Arc, Condvar, Mutex};
+use std::thread;
+
+const BUFFER_SIZE: usize = 20;
+
+fn server(ready: Arc<(Mutex<u16>, Condvar)>) {
+    let connection_socket = socket(
+        AddressFamily::INET6,
+        SocketType::STREAM,
+        Protocol::default(),
+    )
+    .unwrap();
+
+    let name = SocketAddrV6::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 0, 0, 0);
+    bind_v6(&connection_socket, &name).unwrap();
+
+    let who = match getsockname(&connection_socket).unwrap() {
+        SocketAddrAny::V6(addr) => addr,
+        _ => panic!(),
+    };
+
+    listen(&connection_socket, 1).unwrap();
+
+    {
+        let (lock, cvar) = &*ready;
+        let mut port = lock.lock().unwrap();
+        *port = who.port();
+        cvar.notify_all();
+    }
+
+    let mut buffer = vec![0; BUFFER_SIZE];
+    let data_socket = accept(&connection_socket).unwrap();
+    let nread = recv(&data_socket, &mut buffer, RecvFlags::empty()).unwrap();
+    assert_eq!(String::from_utf8_lossy(&buffer[..nread]), "hello, world");
+
+    send(&data_socket, b"goodnight, moon", SendFlags::empty()).unwrap();
+}
+
+fn client(ready: Arc<(Mutex<u16>, Condvar)>) {
+    let port = {
+        let (lock, cvar) = &*ready;
+        let mut port = lock.lock().unwrap();
+        while *port == 0 {
+            port = cvar.wait(port).unwrap();
+        }
+        *port
+    };
+
+    let addr = SocketAddrV6::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), port, 0, 0);
+    let mut buffer = vec![0; BUFFER_SIZE];
+
+    let data_socket = socket(
+        AddressFamily::INET6,
+        SocketType::STREAM,
+        Protocol::default(),
+    )
+    .unwrap();
+    connect_v6(&data_socket, &addr).unwrap();
+
+    send(&data_socket, b"hello, world", SendFlags::empty()).unwrap();
+
+    let nread = recv(&data_socket, &mut buffer, RecvFlags::empty()).unwrap();
+    assert_eq!(String::from_utf8_lossy(&buffer[..nread]), "goodnight, moon");
+}
+
+#[test]
+fn test_v6() {
+    let ready = Arc::new((Mutex::new(0_u16), Condvar::new()));
+    let ready_clone = Arc::clone(&ready);
+
+    let server = thread::Builder::new()
+        .name("server".to_string())
+        .spawn(move || {
+            server(ready);
+        })
+        .unwrap();
+    let client = thread::Builder::new()
+        .name("client".to_string())
+        .spawn(move || {
+            client(ready_clone);
+        })
+        .unwrap();
+    client.join().unwrap();
+    server.join().unwrap();
+}