use std::net::SocketAddr;
use std::sync::{Arc, Condvar, Mutex};
use std::time::Duration;
#[cfg(unix)]
pub(crate) fn held_here(endpoint: SocketAddr) -> bool {
let Ok(descriptors) = std::fs::read_dir("/dev/fd") else {
return false;
};
descriptors
.filter_map(|entry| entry.ok()?.file_name().to_str()?.parse().ok())
.any(|fd| local_end(fd) == Some(endpoint))
}
#[cfg(unix)]
pub(crate) fn sent_here(source: SocketAddr) -> bool {
let Ok(descriptors) = std::fs::read_dir("/dev/fd") else {
return false;
};
descriptors
.filter_map(|entry| entry.ok()?.file_name().to_str()?.parse().ok())
.filter(|fd| is_datagram_socket(*fd))
.filter_map(local_end)
.any(|local| {
local.port() == source.port()
&& (local.ip().is_unspecified()
|| local.ip().to_canonical() == source.ip().to_canonical())
})
}
#[cfg(not(unix))]
pub(crate) fn sent_here(_source: SocketAddr) -> bool {
true
}
#[cfg(unix)]
fn is_datagram_socket(fd: libc::c_int) -> bool {
let mut kind: libc::c_int = 0;
let mut len = std::mem::size_of::<libc::c_int>() as libc::socklen_t;
let asked = unsafe {
libc::getsockopt(
fd,
libc::SOL_SOCKET,
libc::SO_TYPE,
(&raw mut kind).cast(),
&raw mut len,
)
};
asked == 0 && kind == libc::SOCK_DGRAM
}
#[cfg(not(unix))]
pub(crate) fn held_here(_endpoint: SocketAddr) -> bool {
true
}
#[cfg(unix)]
fn local_end(fd: libc::c_int) -> Option<SocketAddr> {
let ((), address) = unsafe {
socket2::SockAddr::try_init(|storage, len| {
match libc::getsockname(fd, storage.cast(), len) {
0 => Ok(()),
_ => Err(std::io::Error::last_os_error()),
}
})
}
.ok()?;
address.as_socket()
}
pub(crate) fn from_this_process(
listener: &std::net::TcpListener,
) -> impl Iterator<Item = std::net::TcpStream> + '_ {
listener
.incoming()
.flatten()
.filter(|sock| sock.peer_addr().is_ok_and(held_here))
}
pub(crate) async fn accept_from_this_process(
listener: &tokio::net::TcpListener,
) -> std::io::Result<tokio::net::TcpStream> {
loop {
let (sock, peer) = listener.accept().await?;
if held_here(peer) {
return Ok(sock);
}
}
}
pub(crate) async fn recv_from_this_process(
socket: &tokio::net::UdpSocket,
buf: &mut [u8],
) -> std::io::Result<(usize, SocketAddr)> {
loop {
let (len, source) = socket.recv_from(buf).await?;
if sent_here(source) {
return Ok((len, source));
}
}
}
pub(crate) fn recv_from_this_process_blocking(
socket: &std::net::UdpSocket,
buf: &mut [u8],
) -> std::io::Result<(usize, SocketAddr)> {
loop {
let (len, source) = socket.recv_from(buf)?;
if sent_here(source) {
return Ok((len, source));
}
}
}
pub(crate) fn tls_by_name(name: &str) -> tokio_rustls::TlsAcceptor {
use rustls::server::ResolvesServerCertUsingSni;
use rustls::sign::CertifiedKey;
let cert = rcgen::generate_simple_self_signed(vec![name.to_string()])
.expect("a self-signed certificate");
let key = rustls::pki_types::PrivateKeyDer::Pkcs8(rustls::pki_types::PrivatePkcs8KeyDer::from(
cert.key_pair.serialize_der(),
));
let signing = rustls::crypto::ring::sign::any_supported_type(&key).expect("a signing key");
let mut by_name = ResolvesServerCertUsingSni::new();
by_name
.add(
name,
CertifiedKey::new(vec![cert.cert.der().clone()], signing),
)
.expect("the name takes the certificate");
let config = rustls::ServerConfig::builder_with_provider(Arc::new(
rustls::crypto::ring::default_provider(),
))
.with_safe_default_protocol_versions()
.expect("ring supports the default versions")
.with_no_client_auth()
.with_cert_resolver(Arc::new(by_name));
tokio_rustls::TlsAcceptor::from(Arc::new(config))
}
pub(crate) async fn https_site(name: &str, page: fn(&str) -> Option<&'static str>) -> SocketAddr {
use tokio::io::{AsyncReadExt, AsyncWriteExt};
let acceptor = tls_by_name(name);
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
.expect("binds loopback");
let addr = listener.local_addr().expect("a local address");
let site = format!("\r\nhost: {name}:{}\r\n", addr.port());
tokio::spawn(async move {
while let Ok(stream) = accept_from_this_process(&listener).await {
let (acceptor, site) = (acceptor.clone(), site.clone());
tokio::spawn(async move {
let Ok(mut tls) = acceptor.accept(stream).await else {
return;
};
let mut buffer = [0u8; 4096];
let read = tls.read(&mut buffer).await.unwrap_or(0);
let request = String::from_utf8_lossy(&buffer[..read]);
let body = request
.to_ascii_lowercase()
.contains(&site)
.then(|| page(&request))
.flatten();
let reply = match body {
Some(body) => format!(
"HTTP/1.1 200 OK\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
body.len()
),
None => {
"HTTP/1.1 404 Not Found\r\nContent-Length: 0\r\nConnection: close\r\n\r\n"
.to_string()
}
};
let _ = tls.write_all(reply.as_bytes()).await;
let _ = tls.shutdown().await;
});
}
});
addr
}
pub(crate) struct SilentPort {
addr: SocketAddr,
heard: Arc<(Mutex<Vec<Connection>>, Condvar)>,
markers: Mutex<Vec<SocketAddr>>,
}
struct Connection {
from: SocketAddr,
sent: Vec<u8>,
closed: bool,
told: bool,
}
const CLOSE_PATIENCE: Duration = Duration::from_secs(60);
fn already_ended(sock: &mut std::net::TcpStream) -> Option<Vec<u8>> {
use std::io::{ErrorKind, Read};
sock.set_nonblocking(true).ok()?;
let mut sent = Vec::new();
let mut buffer = [0u8; 1024];
loop {
match sock.read(&mut buffer) {
Ok(0) => return Some(sent),
Ok(read) => sent.extend_from_slice(&buffer[..read]),
Err(error) if error.kind() == ErrorKind::WouldBlock => return None,
Err(error) if error.kind() == ErrorKind::Interrupted => {}
Err(_) => return Some(sent),
}
}
}
impl SilentPort {
pub(crate) fn open() -> Self {
let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("binds loopback");
let addr = listener.local_addr().expect("a local address");
let heard = Arc::new((Mutex::new(Vec::<Connection>::new()), Condvar::new()));
let log = Arc::clone(&heard);
std::thread::spawn(move || {
loop {
let Ok((mut sock, from)) = listener.accept() else {
continue;
};
let ended = match held_here(from) {
true => None,
false => match already_ended(&mut sock) {
Some(sent) => Some(sent),
None => continue,
},
};
let closed = ended.is_some();
let index = {
let mut connections = log.0.lock().unwrap();
connections.push(Connection {
from,
sent: ended.unwrap_or_default(),
closed,
told: !closed,
});
log.1.notify_all();
connections.len() - 1
};
if closed {
continue;
}
let log = Arc::clone(&log);
std::thread::spawn(move || {
use std::io::Read;
let mut buffer = [0u8; 1024];
loop {
let read = sock.read(&mut buffer).unwrap_or(0);
let mut connections = log.0.lock().unwrap();
let connection = &mut connections[index];
connection.sent.extend_from_slice(&buffer[..read]);
connection.closed = read == 0;
log.1.notify_all();
if read == 0 {
return;
}
}
});
}
});
Self {
addr,
heard,
markers: Mutex::new(Vec::new()),
}
}
pub(crate) fn addr(&self) -> SocketAddr {
self.addr
}
pub(crate) fn heard(&self) -> usize {
self.settled().iter().map(|(sent, _)| sent.len()).sum()
}
pub(crate) fn received(&self) -> Vec<u8> {
self.settled()
.into_iter()
.flat_map(|(sent, _)| sent)
.collect()
}
pub(crate) fn connections_told(&self) -> usize {
self.settled().iter().filter(|(_, told)| *told).count()
}
fn settled(&self) -> Vec<(Vec<u8>, bool)> {
let marker = std::net::TcpStream::connect(self.addr).expect("connects to loopback");
let from = marker.local_addr().expect("a local address");
let mut markers = self.markers.lock().unwrap();
markers.push(from);
let (lock, changed) = &*self.heard;
let (connections, waited) = changed
.wait_timeout_while(lock.lock().unwrap(), CLOSE_PATIENCE, |connections| {
match connections.iter().position(|c| c.from == from) {
Some(marker) => connections[..marker].iter().any(|c| !c.closed),
None => true,
}
})
.unwrap();
let before = connections
.iter()
.position(|c| c.from == from)
.unwrap_or(connections.len());
let before = &connections[..before];
assert!(
!waited.timed_out(),
"a connection to the port was still open after {CLOSE_PATIENCE:?}: {:?}",
before
.iter()
.filter(|c| !c.closed)
.map(|c| c.from)
.collect::<Vec<_>>()
);
before
.iter()
.filter(|c| !markers.contains(&c.from))
.map(|c| (c.sent.clone(), c.told))
.collect()
}
}
pub(crate) struct SilentUdpPort {
addr: SocketAddr,
heard: Arc<(Mutex<Heard>, Condvar)>,
stopping: Arc<std::sync::atomic::AtomicBool>,
reader: Option<std::thread::JoinHandle<()>>,
}
#[derive(Default)]
struct Heard {
datagrams: Vec<(SocketAddr, Vec<u8>)>,
markers: Vec<SocketAddr>,
}
impl Heard {
fn sent(&self) -> impl Iterator<Item = &[u8]> {
self.datagrams
.iter()
.filter(|(from, _)| !self.markers.contains(from))
.map(|(_, payload)| payload.as_slice())
}
}
const DATAGRAM_PATIENCE: Duration = Duration::from_secs(30);
impl SilentUdpPort {
pub(crate) fn open() -> Self {
let socket = std::net::UdpSocket::bind("127.0.0.1:0").expect("binds loopback");
let addr = socket.local_addr().expect("a local address");
let heard = Arc::new((Mutex::new(Heard::default()), Condvar::new()));
let stopping = Arc::new(std::sync::atomic::AtomicBool::new(false));
let (log, stop) = (Arc::clone(&heard), Arc::clone(&stopping));
let reader = std::thread::spawn(move || {
let mut buffer = [0u8; 65_535];
while let Ok((len, from)) = recv_from_this_process_blocking(&socket, &mut buffer) {
if stop.load(std::sync::atomic::Ordering::Acquire) {
break;
}
let mut heard = log.0.lock().unwrap();
heard.datagrams.push((from, buffer[..len].to_vec()));
log.1.notify_all();
}
});
Self {
addr,
heard,
stopping,
reader: Some(reader),
}
}
pub(crate) fn addr(&self) -> SocketAddr {
self.addr
}
pub(crate) fn datagrams(&self) -> Vec<Vec<u8>> {
let marker = std::net::UdpSocket::bind("127.0.0.1:0").expect("binds loopback");
let from = marker.local_addr().expect("a local address");
let (lock, arrived) = &*self.heard;
lock.lock().unwrap().markers.push(from);
marker.send_to(&[], self.addr).expect("sends on loopback");
let (heard, waited) = arrived
.wait_timeout_while(lock.lock().unwrap(), DATAGRAM_PATIENCE, |heard| {
!heard.datagrams.iter().any(|(source, _)| *source == from)
})
.unwrap();
assert!(
!waited.timed_out(),
"the port's own datagram was not read in {DATAGRAM_PATIENCE:?}"
);
heard.sent().map(<[u8]>::to_vec).collect()
}
pub(crate) async fn arrived(&self, count: usize) {
let heard = Arc::clone(&self.heard);
tokio::task::spawn_blocking(move || {
let (lock, arrived) = &*heard;
let (_heard, waited) = arrived
.wait_timeout_while(lock.lock().unwrap(), DATAGRAM_PATIENCE, |heard| {
heard.sent().count() < count
})
.unwrap();
assert!(
!waited.timed_out(),
"fewer than {count} datagrams arrived in {DATAGRAM_PATIENCE:?}"
);
})
.await
.expect("the wait does not panic");
}
}
impl Drop for SilentUdpPort {
fn drop(&mut self) {
self.stopping
.store(true, std::sync::atomic::Ordering::Release);
let Some(reader) = self.reader.take() else {
return;
};
if let Ok(waker) = std::net::UdpSocket::bind("127.0.0.1:0")
&& waker.send_to(&[], self.addr).is_ok()
{
let _ = reader.join();
}
}
}
pub(crate) fn refused_ports(ip: std::net::IpAddr, count: usize) -> Vec<u16> {
const REFUSAL_PATIENCE: Duration = Duration::from_secs(3);
let refused: Vec<u16> = (1..1024u16)
.rev()
.filter(|&port| {
let asked =
std::net::TcpStream::connect_timeout(&SocketAddr::new(ip, port), REFUSAL_PATIENCE);
matches!(asked, Err(error) if error.kind() == std::io::ErrorKind::ConnectionRefused)
})
.take(count)
.collect();
assert_eq!(refused.len(), count, "too few ports refuse at {ip}");
refused
}
pub(crate) fn refused_port(ip: std::net::IpAddr) -> SocketAddr {
SocketAddr::new(ip, refused_ports(ip, 1)[0])
}
pub(crate) struct ClosedUdpPort {
port: u16,
_held: [std::net::UdpSocket; 2],
}
impl ClosedUdpPort {
pub(crate) fn open(ip: std::net::IpAddr) -> Self {
let peer = std::net::UdpSocket::bind((ip, 0)).expect("binds loopback");
let held = std::net::UdpSocket::bind((ip, 0)).expect("binds loopback");
held.connect(peer.local_addr().expect("a local address"))
.expect("connects on loopback");
let port = held.local_addr().expect("a local address").port();
Self {
port,
_held: [held, peer],
}
}
pub(crate) fn port(&self) -> u16 {
self.port
}
}
pub(crate) struct HeldTcpPort {
port: u16,
_held: socket2::Socket,
}
impl HeldTcpPort {
pub(crate) fn open(ip: std::net::IpAddr) -> Self {
use socket2::{Domain, Socket, Type};
let domain = match ip {
std::net::IpAddr::V4(_) => Domain::IPV4,
std::net::IpAddr::V6(_) => Domain::IPV6,
};
let held = Socket::new(domain, Type::STREAM, None).expect("a socket");
#[cfg(unix)]
held.set_reuse_port(true).expect("port reuse");
held.bind(&SocketAddr::new(ip, 0).into())
.expect("binds loopback");
let port = held
.local_addr()
.ok()
.and_then(|addr| addr.as_socket())
.expect("a local address")
.port();
Self { port, _held: held }
}
pub(crate) fn port(&self) -> u16 {
self.port
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_silent_udp_port_lets_go_of_its_port_when_dropped() {
const RELEASE_PATIENCE: Duration = Duration::from_secs(10);
let silent = SilentUdpPort::open();
let addr = silent.addr();
assert!(
std::net::UdpSocket::bind(addr).is_err(),
"the port is held while it is open"
);
drop(silent);
let dropped = std::time::Instant::now();
while std::net::UdpSocket::bind(addr).is_err() {
assert!(
dropped.elapsed() < RELEASE_PATIENCE,
"the port was still held {RELEASE_PATIENCE:?} after the drop"
);
std::thread::sleep(Duration::from_millis(1));
}
}
#[test]
fn a_closed_udp_port_refuses_and_stays_taken_while_held() {
for ip in [
std::net::IpAddr::V4(std::net::Ipv4Addr::LOCALHOST),
std::net::IpAddr::V6(std::net::Ipv6Addr::LOCALHOST),
] {
let closed = ClosedUdpPort::open(ip);
let target = SocketAddr::new(ip, closed.port());
let asker = std::net::UdpSocket::bind((ip, 0)).expect("binds loopback");
asker.connect(target).expect("connects on loopback");
asker
.set_read_timeout(Some(Duration::from_secs(10)))
.expect("a timeout");
asker.send(b"anyone").expect("sends on loopback");
let answer = asker.recv(&mut [0u8; 16]).map_err(|error| error.kind());
assert_eq!(
answer,
Err(std::io::ErrorKind::ConnectionRefused),
"{ip}: the port did not refuse"
);
assert!(
std::net::UdpSocket::bind(target).is_err(),
"{ip}: another socket took the port while it was held"
);
}
}
#[test]
fn a_held_tcp_port_stays_taken_and_admits_a_pinned_source() {
use socket2::{Domain, Socket, Type};
for ip in [
std::net::IpAddr::V4(std::net::Ipv4Addr::LOCALHOST),
std::net::IpAddr::V6(std::net::Ipv6Addr::LOCALHOST),
] {
let held = HeldTcpPort::open(ip);
let target = SocketAddr::new(ip, held.port());
assert!(
std::net::TcpListener::bind(target).is_err(),
"{ip}: another socket took the port while it was held"
);
let domain = match ip {
std::net::IpAddr::V4(_) => Domain::IPV4,
std::net::IpAddr::V6(_) => Domain::IPV6,
};
let pinned = Socket::new(domain, Type::STREAM, None).expect("a socket");
pinned.set_reuse_address(true).expect("address reuse");
#[cfg(unix)]
pinned.set_reuse_port(true).expect("port reuse");
let wildcard = match ip {
std::net::IpAddr::V4(_) => std::net::IpAddr::V4(std::net::Ipv4Addr::UNSPECIFIED),
std::net::IpAddr::V6(_) => std::net::IpAddr::V6(std::net::Ipv6Addr::UNSPECIFIED),
};
pinned
.bind(&SocketAddr::new(wildcard, held.port()).into())
.unwrap_or_else(|error| panic!("{ip}: a pinned source was refused: {error}"));
}
}
#[cfg(unix)]
#[test]
fn a_connection_is_this_processs_while_it_holds_the_far_end() {
let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("binds loopback");
let near = std::net::TcpStream::connect(listener.local_addr().unwrap()).unwrap();
let (_accepted, far) = listener.accept().expect("accepts");
assert!(held_here(far), "a socket this process holds was not found");
drop(near);
assert!(
!held_here(far),
"an endpoint no socket of this process holds was taken for one"
);
}
#[test]
fn a_refused_port_is_never_handed_to_a_socket_asking_for_any() {
let ip = std::net::IpAddr::from([127, 0, 0, 1]);
let refused = refused_ports(ip, 2);
assert_ne!(refused[0], refused[1], "two ports, not one twice");
let asking: Vec<std::net::TcpListener> = (0..32)
.map(|_| std::net::TcpListener::bind((ip, 0)).expect("binds loopback"))
.collect();
for listener in &asking {
let handed = listener.local_addr().expect("an address").port();
assert!(!refused.contains(&handed), "port {handed} was handed out");
}
for port in refused {
let asked = std::net::TcpStream::connect(SocketAddr::new(ip, port));
assert_eq!(
asked.map(|_| ()).map_err(|error| error.kind()),
Err(std::io::ErrorKind::ConnectionRefused),
"port {port}"
);
}
}
#[cfg(unix)]
#[test]
fn a_datagram_is_this_processs_while_it_holds_the_socket_it_came_from() {
let peer = std::net::UdpSocket::bind("127.0.0.1:0").expect("binds loopback");
let to = peer.local_addr().unwrap();
let mut buf = [0u8; 8];
for bound in ["127.0.0.1:0", "0.0.0.0:0"] {
let sender = std::net::UdpSocket::bind(bound).expect("binds");
sender.send_to(b"x", to).expect("sends");
let (_, source) = peer.recv_from(&mut buf).expect("receives");
assert!(sent_here(source), "a socket bound to {bound} was not found");
drop(sender);
assert!(!sent_here(source), "a socket let go of was taken for one");
if let Ok(listener) = std::net::TcpListener::bind(source) {
assert!(!sent_here(source), "a stream socket was taken for one");
drop(listener);
}
}
}
#[cfg(unix)]
#[tokio::test]
async fn a_datagram_from_elsewhere_is_passed_over() {
let peer = tokio::net::UdpSocket::bind("127.0.0.1:0").await.unwrap();
let to = peer.local_addr().unwrap();
let elsewhere = std::net::UdpSocket::bind("127.0.0.1:0").unwrap();
elsewhere.send_to(b"elsewhere", to).unwrap();
drop(elsewhere);
let here = std::net::UdpSocket::bind("127.0.0.1:0").unwrap();
here.send_to(b"here", to).unwrap();
let mut buf = [0u8; 16];
let (len, source) = recv_from_this_process(&peer, &mut buf).await.unwrap();
assert_eq!(&buf[..len], b"here");
assert_eq!(source, here.local_addr().unwrap());
}
#[test]
fn a_silent_port_hears_everything_sent_before_it_is_asked() {
use std::io::Write;
let silent = SilentPort::open();
let held: Vec<std::net::TcpStream> = [&b"GET / HTTP/1.0\r\n\r\n"[..], b"\r\n\r\n"]
.into_iter()
.map(|bytes| {
let mut sock = std::net::TcpStream::connect(silent.addr()).unwrap();
sock.write_all(bytes).unwrap();
sock.shutdown(std::net::Shutdown::Write).unwrap();
sock
})
.collect();
assert_eq!(silent.heard(), 22);
assert_eq!(silent.received(), b"GET / HTTP/1.0\r\n\r\n\r\n\r\n");
assert_eq!(silent.heard(), 22, "the count's own connection counted");
assert_eq!(
silent.connections_told(),
2,
"the counts' own connections counted"
);
drop(held);
}
#[cfg(unix)]
const SEND_TO: &str = "ZOND_TEST_DATAGRAM_TO";
#[cfg(unix)]
#[test]
fn a_silent_udp_port_keeps_this_processs_datagrams_and_no_others() {
let silent = SilentUdpPort::open();
let here = std::net::UdpSocket::bind("127.0.0.1:0").unwrap();
here.send_to(b"here", silent.addr()).unwrap();
assert_eq!(silent.datagrams(), [b"here"]);
drop(here);
let path = format!(
"{}::send_one_datagram",
module_path!().split_once("::").expect("a crate path").1
);
let elsewhere = std::process::Command::new(std::env::current_exe().unwrap())
.args([path.as_str(), "--exact", "--ignored", "--test-threads=1"])
.env(SEND_TO, silent.addr().to_string())
.output()
.expect("another process runs");
let said = String::from_utf8_lossy(&elsewhere.stdout);
assert!(
elsewhere.status.success() && said.contains("1 passed"),
"the other process sent nothing:\n{said}"
);
assert_eq!(
silent.datagrams(),
[b"here"],
"another process's datagram was kept"
);
}
#[cfg(unix)]
#[test]
#[ignore = "the sender another test runs in a process of its own"]
fn send_one_datagram() {
if let Ok(to) = std::env::var(SEND_TO) {
let to: SocketAddr = to.parse().expect("an address");
let socket = std::net::UdpSocket::bind("127.0.0.1:0").unwrap();
socket.send_to(b"elsewhere", to).unwrap();
}
}
}