pub mod correlation;
pub mod dial;
pub mod random;
pub mod rate;
pub mod udp_rate;
pub use correlation::{CorrelationKey, PendingMap, TxId};
pub use dial::DialGate;
pub use random::{fill_random, random_bytes};
pub use rate::RateLimiter;
pub use udp_rate::{ReplyBudget, UdpRateLimit};
use std::net::{IpAddr, Ipv6Addr, SocketAddr, TcpListener as StdTcpListener, UdpSocket as StdUdpSocket};
use socket2::{Domain, Protocol, Socket, Type};
use tokio::io::AsyncReadExt;
use tokio::net::{TcpListener, TcpStream, UdpSocket};
use crate::error::{Error, Result};
pub async fn connect_pinned(addr: SocketAddr) -> Result<TcpStream> {
let stream = TcpStream::connect(addr).await?;
let peer = stream.peer_addr().map_err(Error::from)?;
if peer.ip() != addr.ip() {
return Err(Error::Session(format!(
"connect peer IP {} != resolved {}",
peer.ip(),
addr.ip()
)));
}
Ok(stream)
}
pub async fn read_capped<R: AsyncReadExt + Unpin>(reader: &mut R, max: usize) -> Result<Vec<u8>> {
let mut buf = Vec::new();
let mut chunk = [0u8; 8192];
loop {
let n = reader.read(&mut chunk).await?;
if n == 0 {
break;
}
if buf.len().saturating_add(n) > max {
return Err(Error::Session(format!(
"response exceeds size limit ({max} bytes)"
)));
}
buf.extend_from_slice(&chunk[..n]);
}
Ok(buf)
}
pub async fn bind_tcp(port: u16, dual_stack: bool) -> Result<TcpListener> {
if dual_stack {
#[cfg(not(unix))]
{
return Err(Error::Config(
"listen-dual-stack #true requires Unix; set listen-dual-stack #false for IPv4-only"
.into(),
));
}
#[cfg(unix)]
{
match bind_tcp_v6_dualstack(port) {
Ok(listener) => return Ok(listener),
Err(err) => {
tracing::warn!(
%err,
port,
"listen-dual-stack TCP bind failed; falling back to IPv4-only"
);
}
}
}
}
let addr = SocketAddr::from(([0, 0, 0, 0], port));
TcpListener::bind(addr)
.await
.map_err(Error::from)
}
pub async fn bind_udp(port: u16, dual_stack: bool) -> Result<UdpSocket> {
if dual_stack {
#[cfg(not(unix))]
{
return Err(Error::Config(
"listen-dual-stack #true requires Unix; set listen-dual-stack #false for IPv4-only"
.into(),
));
}
#[cfg(unix)]
{
match bind_udp_v6_dualstack(port) {
Ok(socket) => return Ok(socket),
Err(err) => {
tracing::warn!(
%err,
port,
"listen-dual-stack UDP bind failed; falling back to IPv4-only"
);
}
}
}
}
let addr = SocketAddr::from(([0, 0, 0, 0], port));
UdpSocket::bind(addr)
.await
.map_err(Error::from)
}
fn bind_tcp_v6_dualstack(port: u16) -> Result<TcpListener> {
let socket = Socket::new(Domain::IPV6, Type::STREAM, Some(Protocol::TCP))?;
socket.set_only_v6(false)?;
socket.set_reuse_address(true)?;
#[cfg(unix)]
{
use std::os::unix::io::{FromRawFd, IntoRawFd};
let addr = SocketAddr::new(IpAddr::V6(Ipv6Addr::UNSPECIFIED), port);
socket.bind(&addr.into())?;
socket.listen(128)?;
let std = unsafe { StdTcpListener::from_raw_fd(socket.into_raw_fd()) };
std.set_nonblocking(true)?;
Ok(TcpListener::from_std(std)?)
}
#[cfg(not(unix))]
{
let _ = port;
Err(Error::Config("dual-stack TCP requires unix".into()))
}
}
fn bind_udp_v6_dualstack(port: u16) -> Result<UdpSocket> {
let socket = Socket::new(Domain::IPV6, Type::DGRAM, Some(Protocol::UDP))?;
socket.set_only_v6(false)?;
socket.set_reuse_address(true)?;
#[cfg(unix)]
{
use std::os::unix::io::{FromRawFd, IntoRawFd};
let addr = SocketAddr::new(IpAddr::V6(Ipv6Addr::UNSPECIFIED), port);
socket.bind(&addr.into())?;
let std = unsafe { StdUdpSocket::from_raw_fd(socket.into_raw_fd()) };
std.set_nonblocking(true)?;
Ok(UdpSocket::from_std(std)?)
}
#[cfg(not(unix))]
{
let _ = port;
Err(Error::Config("dual-stack UDP requires unix".into()))
}
}
pub fn normalize_socket_addr(addr: SocketAddr) -> SocketAddr {
match addr {
SocketAddr::V6(v6) => {
if let Some(v4) = v6.ip().to_ipv4_mapped() {
SocketAddr::new(IpAddr::V4(v4), v6.port())
} else {
addr
}
}
other => other,
}
}
pub fn detect_local_ipv6() -> Option<Ipv6Addr> {
let socket = StdUdpSocket::bind("[::]:0").ok()?;
socket.connect("[2001:4860:4860::8888]:80").ok()?;
match socket.local_addr().ok()? {
SocketAddr::V6(addr) if !addr.ip().is_loopback() && !addr.ip().is_unspecified() => {
Some(*addr.ip())
}
_ => None,
}
}
pub fn compact_ipv6(addr: Ipv6Addr, port: u16) -> [u8; 18] {
let mut out = [0u8; 18];
out[..16].copy_from_slice(&addr.octets());
out[16..].copy_from_slice(&port.to_be_bytes());
out
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn compact_ipv6_roundtrip() {
let ip = Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1);
let bytes = compact_ipv6(ip, 6881);
let mut ip_bytes = [0u8; 16];
ip_bytes.copy_from_slice(&bytes[..16]);
let port = u16::from_be_bytes([bytes[16], bytes[17]]);
assert_eq!(IpAddr::from(ip_bytes), IpAddr::from(ip));
assert_eq!(port, 6881);
}
#[test]
fn normalize_maps_ipv4_mapped() {
let mapped: SocketAddr = "[::ffff:203.0.113.9]:6881".parse().unwrap();
let v4: SocketAddr = "203.0.113.9:6881".parse().unwrap();
assert_eq!(normalize_socket_addr(mapped), v4);
assert_eq!(normalize_socket_addr(v4), v4);
}
}