use std::{
collections::HashMap,
net::SocketAddr,
sync::{
Arc,
atomic::{AtomicBool, Ordering},
},
};
use bytes::BytesMut;
use parking_lot::RwLock;
use tokio::{io::Interest, net::UdpSocket};
const RECV_BUF_LEN: usize = 65_536;
const SOCK_BUF_SIZE: usize = 4 * 1024 * 1024;
#[derive(Clone)]
pub struct RawSocket {
inner: Arc<UdpSocket>,
blocked: Arc<Blocklist>,
}
#[derive(Clone, Copy)]
pub enum Fault {
Lost { inbound_only: bool },
Delayed(std::time::Duration),
}
#[derive(Default)]
struct Blocklist {
any: AtomicBool,
addrs: RwLock<HashMap<SocketAddr, Fault>>,
}
impl Blocklist {
fn fault(&self, addr: SocketAddr) -> Option<Fault> {
if !self.any.load(Ordering::Relaxed) {
return None;
}
self.addrs.read().get(&addr).copied()
}
fn drops(&self, addr: SocketAddr, outgoing: bool) -> bool {
matches!(
self.fault(addr),
Some(Fault::Lost { inbound_only }) if !(outgoing && inbound_only)
)
}
}
impl RawSocket {
#[allow(clippy::unused_async)]
pub async fn bind(addr: SocketAddr) -> Result<Self, crate::Error> {
let sock = socket2::Socket::new(
socket2::Domain::for_address(addr),
socket2::Type::DGRAM,
Some(socket2::Protocol::UDP),
)?;
#[cfg(windows)]
win::exclusive_addr_use(&sock)?;
sock.set_send_buffer_size(SOCK_BUF_SIZE)?;
sock.set_recv_buffer_size(SOCK_BUF_SIZE)?;
sock.set_nonblocking(true)?;
sock.bind(&socket2::SockAddr::from(addr))?;
#[cfg(windows)]
win::disable_udp_connreset(&sock)?;
let std_sock: std::net::UdpSocket = sock.into();
Ok(Self {
inner: Arc::new(UdpSocket::from_std(std_sock)?),
blocked: Arc::default(),
})
}
pub fn adopt_blocklist(&mut self, other: &RawSocket) {
self.blocked = other.blocked.clone();
}
pub fn set_blocked(&self, addr: SocketAddr, blocked: bool, inbound_only: bool) {
self.set_fault(addr, blocked.then_some(Fault::Lost { inbound_only }));
}
pub fn set_fault(&self, addr: SocketAddr, fault: Option<Fault>) {
let mut addrs = self.blocked.addrs.write();
match fault {
Some(fault) => addrs.insert(addr, fault),
None => addrs.remove(&addr),
};
self.blocked.any.store(!addrs.is_empty(), Ordering::Relaxed);
}
#[inline]
pub async fn send_to(&self, data: &[u8], addr: SocketAddr) -> Result<(), crate::Error> {
match self.blocked.fault(addr) {
Some(Fault::Lost {
inbound_only: false,
}) => return Ok(()),
Some(Fault::Delayed(delay)) => {
let (sock, data) = (self.inner.clone(), data.to_vec());
tokio::spawn(async move {
tokio::time::sleep(delay).await;
let _ = sock.send_to(&data, addr).await;
});
return Ok(());
}
Some(Fault::Lost { inbound_only: true }) | None => {}
}
self.inner.send_to(data, addr).await?;
Ok(())
}
pub async fn send_to_vectored(
&self,
bufs: &[std::io::IoSlice<'_>],
addr: SocketAddr,
) -> Result<(), crate::Error> {
if self.blocked.drops(addr, true) {
return Ok(());
}
let sock_addr = socket2::SockAddr::from(addr);
loop {
self.inner.writable().await?;
match self.inner.try_io(Interest::WRITABLE, || {
socket2::SockRef::from(&*self.inner).send_to_vectored(bufs, &sock_addr)
}) {
Ok(_) => return Ok(()),
Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => {}
Err(e) => return Err(e.into()),
}
}
}
pub async fn recv_from(&self) -> Result<(BytesMut, SocketAddr), std::io::Error> {
loop {
let mut buf = BytesMut::with_capacity(RECV_BUF_LEN);
let (_, addr) = self.inner.recv_buf_from(&mut buf).await?;
if !self.blocked.drops(addr, false) {
return Ok((buf, addr));
}
}
}
pub fn local_addr(&self) -> Result<SocketAddr, crate::Error> {
Ok(self.inner.local_addr()?)
}
}
pub fn is_transient_recv_error(e: &std::io::Error) -> bool {
use std::io::ErrorKind;
matches!(
e.kind(),
ErrorKind::ConnectionReset
| ErrorKind::ConnectionRefused
| ErrorKind::ConnectionAborted
| ErrorKind::Interrupted
| ErrorKind::WouldBlock
| ErrorKind::TimedOut
| ErrorKind::HostUnreachable
| ErrorKind::NetworkUnreachable
| ErrorKind::NetworkDown
)
}
#[cfg(windows)]
pub(crate) mod win {
use std::os::windows::io::AsRawSocket;
use windows_sys::Win32::Networking::WinSock::{
SIO_UDP_CONNRESET, SO_EXCLUSIVEADDRUSE, SOCKET, SOCKET_ERROR, SOL_SOCKET, WSAIoctl,
setsockopt,
};
#[allow(clippy::cast_possible_truncation)]
fn raw(sock: &socket2::Socket) -> SOCKET {
sock.as_raw_socket() as SOCKET
}
#[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap)]
pub fn exclusive_addr_use(sock: &socket2::Socket) -> std::io::Result<()> {
let on: i32 = 1;
let rc = unsafe {
setsockopt(
raw(sock),
SOL_SOCKET,
SO_EXCLUSIVEADDRUSE,
(&raw const on).cast(),
size_of::<i32>() as i32,
)
};
if rc == SOCKET_ERROR {
return Err(std::io::Error::last_os_error());
}
Ok(())
}
#[allow(clippy::cast_possible_truncation)]
pub fn disable_udp_connreset(sock: &socket2::Socket) -> std::io::Result<()> {
let off: u32 = 0;
let mut returned: u32 = 0;
let rc = unsafe {
WSAIoctl(
raw(sock),
SIO_UDP_CONNRESET,
(&raw const off).cast(),
size_of::<u32>() as u32,
std::ptr::null_mut(),
0,
&raw mut returned,
std::ptr::null_mut(),
None,
)
};
if rc == SOCKET_ERROR {
return Err(std::io::Error::last_os_error());
}
Ok(())
}
}