use core::ffi::c_void;
use core::mem::replace;
use core::net::{IpAddr, Ipv4Addr, Ipv6Addr};
use core::pin::Pin;
use core::ptr;
use core::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use core::task::{Context, Poll, Waker};
use std::sync::mpsc::{self, Receiver, SyncSender};
use std::sync::{Arc, LazyLock, Mutex};
use std::thread;
use windows_sys::Win32::Foundation::{
ERROR_IO_PENDING, GetLastError, HANDLE, WAIT_FAILED, WAIT_IO_COMPLETION, WAIT_OBJECT_0,
};
use windows_sys::Win32::NetworkManagement::IpHelper::{
IP_BUF_TOO_SMALL, IP_FLAG_DF, IP_OPTION_INFORMATION, IP_SUCCESS, Icmp6CreateFile, Icmp6ParseReplies,
Icmp6SendEcho2, IcmpCreateFile, IcmpParseReplies, IcmpSendEcho2, IcmpSendEcho2Ex,
};
use windows_sys::Win32::Networking::WinSock::{AF_INET6, SOCKADDR_IN6};
use windows_sys::Win32::Storage::FileSystem::{DELETE, SYNCHRONIZE};
use windows_sys::Win32::System::IO::IO_STATUS_BLOCK;
use windows_sys::Win32::System::Threading::{
CreateEventExW, EVENT_MODIFY_STATE, INFINITE, SetEvent, WaitForSingleObjectEx,
};
use crate::util::{windows_ipv4, windows_ipv6};
use crate::{Buffer, Error, IpPair};
#[derive(Clone)]
pub struct AsyncPinger {
worker: Worker,
ttl: u8,
df: bool,
timeout: u32,
}
#[must_use]
pub struct AsyncResult {
pub result: Result<u32, Error>,
pub buffer: Buffer,
}
pub struct PingFuture {
state: Arc<Mutex<State>>,
kind: IpKind,
}
const _: () = {
const fn assert_send_unpin<T: Send + Unpin>() {}
assert_send_unpin::<PingFuture>();
};
enum State {
Unpolled(Buffer),
Polled(Buffer, Waker),
Ready(Buffer),
Failed(Buffer, u32),
FailedAsyncSend(Buffer, u32),
Invalid,
}
impl AsyncPinger {
#[expect(
clippy::new_without_default,
reason = "new() starts a worker thread, so Default would be misleading"
)]
pub fn new() -> Self {
Self {
worker: Worker::new(),
ttl: 255,
df: false,
timeout: 2000,
}
}
pub fn set_ttl(&mut self, ttl: u8) {
self.ttl = ttl
}
pub fn ttl(&self) -> u8 {
self.ttl
}
pub fn set_df(&mut self, df: bool) {
self.df = df;
}
pub fn df(&self) -> bool {
self.df
}
pub fn set_timeout(&mut self, timeout: u32) {
self.timeout = timeout;
}
pub fn timeout(&self) -> u32 {
self.timeout
}
pub fn send4(&self, dst: Ipv4Addr, mut buf: Buffer) -> PingFuture {
buf.init_for_send();
self.worker.begin_v4(None, dst, buf, self.ttl, self.timeout, self.df)
}
pub fn send4_from(&self, src: Ipv4Addr, dst: Ipv4Addr, mut buf: Buffer) -> PingFuture {
buf.init_for_send();
self.worker
.begin_v4(Some(src), dst, buf, self.ttl, self.timeout, self.df)
}
pub fn send6(&self, dst: Ipv6Addr, mut buf: Buffer) -> PingFuture {
buf.init_for_send();
self.worker.begin_v6(None, dst, buf, self.ttl, self.timeout, self.df)
}
pub fn send6_from(&self, src: Ipv6Addr, dst: Ipv6Addr, mut buf: Buffer) -> PingFuture {
buf.init_for_send();
self.worker
.begin_v6(Some(src), dst, buf, self.ttl, self.timeout, self.df)
}
pub fn send(&self, dst: IpAddr, buf: Buffer) -> PingFuture {
match dst {
IpAddr::V4(dst) => self.send4(dst, buf),
IpAddr::V6(dst) => self.send6(dst, buf),
}
}
pub fn send_from(&self, src_dst_pair: IpPair, buf: Buffer) -> PingFuture {
match src_dst_pair {
IpPair::V4 { src, dst } => self.send4_from(src, dst, buf),
IpPair::V6 { src, dst } => self.send6_from(src, dst, buf),
}
}
}
#[derive(Copy, Clone)]
enum IpOptionalPair {
V4 { src: Option<Ipv4Addr>, dst: Ipv4Addr },
V6 { src: Option<Ipv6Addr>, dst: Ipv6Addr },
}
#[derive(Copy, Clone, Eq, PartialEq, Debug)]
enum IpKind {
V4,
V6,
}
#[derive(Clone)]
struct Worker {
inner: SyncSender<Job>,
}
struct Job {
pair: IpOptionalPair,
data_ptr: *mut c_void,
data_len: u16,
reply_ptr: *mut c_void,
reply_len: u32,
ttl: u8,
timeout: u32,
df: bool,
cx: Arc<Mutex<State>>,
}
unsafe impl Send for Job {}
impl Worker {
fn new() -> Self {
Self {
inner: ASYNC.tx.clone(),
}
}
fn begin_v4(
&self,
src: Option<Ipv4Addr>,
dst: Ipv4Addr,
mut buf: Buffer,
ttl: u8,
timeout: u32,
df: bool,
) -> PingFuture {
let data_ptr = buf.request_data_ptr();
let data_len = buf.request_data_len();
let reply_ptr = buf.reply_data_ptr();
let reply_len = buf.reply_data_len();
let state = Arc::new(Mutex::new(State::Unpolled(buf)));
let cx = Arc::clone(&state);
let job = Job {
pair: IpOptionalPair::V4 { src, dst },
data_ptr,
data_len,
reply_ptr,
reply_len,
ttl,
timeout,
df,
cx,
};
self.inner
.send(job)
.expect("the async worker thread never drops the receiver");
unsafe { SetEvent(ASYNC.handles.input_event) };
PingFuture {
state,
kind: IpKind::V4,
}
}
fn begin_v6(
&self,
src: Option<Ipv6Addr>,
dst: Ipv6Addr,
mut buf: Buffer,
ttl: u8,
timeout: u32,
df: bool,
) -> PingFuture {
let data_ptr = buf.request_data_ptr();
let data_len = buf.request_data_len();
let reply_ptr = buf.reply_data_ptr();
let reply_len = buf.reply_data_len();
let state = Arc::new(Mutex::new(State::Unpolled(buf)));
let cx = Arc::clone(&state);
let job = Job {
pair: IpOptionalPair::V6 { src, dst },
data_ptr,
data_len,
reply_ptr,
reply_len,
ttl,
timeout,
df,
cx,
};
self.inner
.send(job)
.expect("the async worker thread never drops the receiver");
unsafe { SetEvent(ASYNC.handles.input_event) };
PingFuture {
state,
kind: IpKind::V6,
}
}
}
#[derive(Copy, Clone)]
struct Handles {
input_event: HANDLE,
icmp: HANDLE,
icmp6: HANDLE,
}
unsafe impl Send for Handles {}
unsafe impl Sync for Handles {}
struct AsyncGlobals {
handles: Handles,
tx: SyncSender<Job>,
}
static ASYNC_BUFFER_SIZE_CT: Option<&'static str> = std::option_env!("WINPING_ASYNC_BUFFER_SIZE");
static ASYNC_BUFFER_SIZE_RT_IS_SET: AtomicBool = AtomicBool::new(false);
static ASYNC_BUFFER_SIZE_RT: AtomicUsize = AtomicUsize::new(0);
static ASYNC_BUFFER_SIZE_DEFAULT: usize = 1024;
pub fn set_async_buffer_size(size: usize) {
ASYNC_BUFFER_SIZE_RT.store(size, Ordering::SeqCst);
ASYNC_BUFFER_SIZE_RT_IS_SET.store(true, Ordering::SeqCst);
}
static ASYNC: LazyLock<AsyncGlobals> = LazyLock::new(|| {
let channel_size = if ASYNC_BUFFER_SIZE_RT_IS_SET.load(Ordering::Relaxed) {
ASYNC_BUFFER_SIZE_RT.load(Ordering::Relaxed)
} else {
ASYNC_BUFFER_SIZE_CT.map_or(ASYNC_BUFFER_SIZE_DEFAULT, |s| {
s.parse()
.expect("Failed to parse value of WINPING_ASYNC_BUFFER_SIZE compile-time environment variable")
})
};
let (tx, rx) = mpsc::sync_channel(channel_size);
const EVENT_ACCESS: u32 = DELETE | EVENT_MODIFY_STATE | SYNCHRONIZE;
let input_event = unsafe { CreateEventExW(ptr::null(), ptr::null(), 0, EVENT_ACCESS) };
assert!(!input_event.is_null(), "could not initialize event handle");
let icmp = unsafe { IcmpCreateFile() };
let icmp6 = unsafe { Icmp6CreateFile() };
let handles = Handles {
input_event,
icmp,
icmp6,
};
thread::spawn(move || {
loop {
let wait = unsafe { WaitForSingleObjectEx(handles.input_event, INFINITE, 1) };
match wait {
WAIT_IO_COMPLETION | WAIT_OBJECT_0 => while try_recv_job(&rx, &handles) {},
WAIT_FAILED => {
let err = Error::from_lasterror();
unreachable!("AsyncPinger thread failed to wait in event loop: {}", err)
}
x => unreachable!("unexpected return from WaitForSingleObjectEx: {:x}", x),
}
}
});
AsyncGlobals { handles, tx }
});
#[inline]
fn try_recv_job(rx: &Receiver<Job>, handles: &Handles) -> bool {
let job = match rx.try_recv() {
Ok(job) => job,
_ => return false,
};
#[expect(
clippy::as_conversions,
clippy::cast_possible_truncation,
reason = "IP_FLAG_DF is the constant 2"
)]
const DONT_FRAGMENT: u8 = IP_FLAG_DF as u8;
let ip_opts = IP_OPTION_INFORMATION {
Ttl: job.ttl,
Flags: if job.df { DONT_FRAGMENT } else { 0 },
..Default::default()
};
let arcptr = Arc::into_raw(job.cx);
#[inline]
fn after_send(ret: u32, arcptr: *const Mutex<State>) {
if ret != 0 {
let arc = unsafe { Arc::from_raw(arcptr) };
let mut lock = arc.lock().expect("state mutex poisoned");
let state = replace(&mut *lock, State::Invalid);
match state {
State::Unpolled(buf) => *lock = State::FailedAsyncSend(buf, ret),
State::Polled(buf, waker) => {
*lock = State::FailedAsyncSend(buf, ret);
waker.wake();
}
_ => {} }
return;
}
let err = unsafe { GetLastError() };
if err != ERROR_IO_PENDING {
let arc = unsafe { Arc::from_raw(arcptr) };
let mut lock = arc.lock().expect("state mutex poisoned");
let state = replace(&mut *lock, State::Invalid);
match state {
State::Unpolled(buf) => *lock = State::Failed(buf, err),
State::Polled(buf, waker) => {
*lock = State::Failed(buf, err);
waker.wake();
}
_ => {} }
}
}
use IpOptionalPair::{V4, V6};
match job.pair {
V4 { src: Some(src), dst } => {
let ret = unsafe {
IcmpSendEcho2Ex(
handles.icmp,
ptr::null_mut(), Some(callback_fn), arcptr.cast(), windows_ipv4(src),
windows_ipv4(dst),
job.data_ptr,
job.data_len,
&ip_opts,
job.reply_ptr,
job.reply_len,
job.timeout,
)
};
after_send(ret, arcptr);
}
V4 { src: None, dst } => {
let ret = unsafe {
IcmpSendEcho2(
handles.icmp,
ptr::null_mut(), Some(callback_fn), arcptr.cast(), windows_ipv4(dst),
job.data_ptr,
job.data_len,
&ip_opts,
job.reply_ptr,
job.reply_len,
job.timeout,
)
};
after_send(ret, arcptr);
}
V6 { src, dst } => {
let src = SOCKADDR_IN6 {
sin6_family: AF_INET6,
sin6_addr: windows_ipv6(src.unwrap_or(Ipv6Addr::UNSPECIFIED)),
..Default::default()
};
let dst = SOCKADDR_IN6 {
sin6_family: AF_INET6,
sin6_addr: windows_ipv6(dst),
..Default::default()
};
let ret = unsafe {
Icmp6SendEcho2(
handles.icmp6,
ptr::null_mut(), Some(callback_fn), arcptr.cast(), &src,
&dst,
job.data_ptr,
job.data_len,
&ip_opts,
job.reply_ptr,
job.reply_len,
job.timeout,
)
};
after_send(ret, arcptr);
}
}
true
}
unsafe extern "system" fn callback_fn(apccontext: *mut c_void, _io_status_block: *mut IO_STATUS_BLOCK, _rsvd: u32) {
let state_arc = unsafe { Arc::from_raw(apccontext.cast::<Mutex<State>>()) };
let mut lock = state_arc.lock().expect("state mutex poisoned");
let state = replace(&mut *lock, State::Invalid);
match state {
State::Unpolled(buf) => *lock = State::Ready(buf),
State::Polled(buf, waker) => {
*lock = State::Ready(buf);
waker.wake();
}
_ => {} }
}
impl Future for PingFuture {
type Output = AsyncResult;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
let mut lock = self.state.lock().expect("state mutex poisoned");
let state = replace(&mut *lock, State::Invalid);
match state {
State::Unpolled(buf) | State::Polled(buf, _) => {
*lock = State::Polled(buf, cx.waker().clone());
Poll::Pending
}
State::Ready(mut buf) => {
drop(lock);
let ret = match self.kind {
IpKind::V4 => unsafe { IcmpParseReplies(buf.reply_data_ptr(), buf.reply_data_len()) },
IpKind::V6 => unsafe { Icmp6ParseReplies(buf.reply_data_ptr(), buf.reply_data_len()) },
};
let result = if ret == 0 {
Err(Error::from_lasterror())
} else {
let parsed = match self.kind {
IpKind::V4 => {
#[cfg(target_pointer_width = "32")]
let reply = buf.as_echo_reply();
#[cfg(target_pointer_width = "64")]
let reply = buf.as_echo_reply32();
let parsed = reply.map(|reply| (reply.Status, reply.RoundTripTime));
if parsed.is_some() {
buf.set_filled4();
}
parsed
}
IpKind::V6 => {
let parsed = buf.as_echo_reply6().map(|reply| (reply.Status, reply.RoundTripTime));
if parsed.is_some() {
buf.set_filled6();
}
parsed
}
};
match parsed {
Some((IP_SUCCESS, rtt)) => Ok(rtt),
Some((status, _)) => Err(Error::from_iperror(status)),
None => Err(Error::from_iperror(IP_BUF_TOO_SMALL)),
}
};
Poll::Ready(AsyncResult { result, buffer: buf })
}
State::Failed(buf, err) => {
drop(lock);
Poll::Ready(AsyncResult {
result: Err(Error::from_winerror(err)),
buffer: buf,
})
}
State::FailedAsyncSend(_buf, err) => {
unreachable!("Failed to send async. Expected return of 0, got {} instead.", err)
}
State::Invalid => unreachable!(),
}
}
}