diff options
Diffstat (limited to 'vendor/rustix/tests/net/connect_bind_send.rs')
-rw-r--r-- | vendor/rustix/tests/net/connect_bind_send.rs | 487 |
1 files changed, 487 insertions, 0 deletions
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(()) +} |