use core::fmt::{self, Debug, Display, Formatter};
use core::net::{IpAddr, Ipv4Addr, Ipv6Addr};
use core::ptr;
use std::sync::Arc;
use windows_sys::Win32::Foundation::{HANDLE, INVALID_HANDLE_VALUE};
use windows_sys::Win32::NetworkManagement::IpHelper::{
IP_BUF_TOO_SMALL, IP_FLAG_DF, IP_OPTION_INFORMATION, IP_SUCCESS, Icmp6CreateFile, Icmp6SendEcho2, IcmpCloseHandle,
IcmpCreateFile, IcmpSendEcho, IcmpSendEcho2Ex,
};
use windows_sys::Win32::Networking::WinSock::{AF_INET6, SOCKADDR_IN6};
use crate::util::{windows_ipv4, windows_ipv6};
use crate::{Buffer, Error};
struct Handles {
v4: HANDLE,
v6: HANDLE,
}
unsafe impl Send for Handles {}
unsafe impl Sync for Handles {}
#[derive(Copy, Clone, Eq, PartialEq, Debug, Hash)]
pub enum IpPair {
V4 {
src: Ipv4Addr,
dst: Ipv4Addr,
},
V6 {
src: Ipv6Addr,
dst: Ipv6Addr,
},
}
#[derive(Clone)]
pub struct Pinger {
handles: Arc<Handles>,
ttl: u8,
df: bool,
timeout: u32,
}
pub enum CreateError {
NoV4(Pinger),
NoV6(Pinger),
None,
}
impl Debug for CreateError {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
write!(
f,
"{}",
match self {
CreateError::None => "failed to create ICMP V4 and V6 handles",
CreateError::NoV4(_) => "failed to create ICMP V4 handle",
CreateError::NoV6(_) => "failed to create ICMP V6 handle",
}
)
}
}
impl Display for CreateError {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
Debug::fmt(self, f)
}
}
impl core::error::Error for CreateError {}
impl Pinger {
pub fn new() -> Result<Self, CreateError> {
let v4 = unsafe { IcmpCreateFile() };
let v6 = unsafe { Icmp6CreateFile() };
let ret = Self {
handles: Arc::new(Handles { v4, v6 }),
ttl: 255,
df: false,
timeout: 2000,
};
match (v4, v6) {
(INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE) => Err(CreateError::None),
(INVALID_HANDLE_VALUE, _) => Err(CreateError::NoV6(ret)),
(_, INVALID_HANDLE_VALUE) => Err(CreateError::NoV4(ret)),
(_, _) => Ok(ret),
}
}
pub fn new_v4() -> Option<Self> {
match Self::new() {
Ok(ret) | Err(CreateError::NoV6(ret)) => Some(ret),
_ => None,
}
}
pub fn new_v6() -> Option<Self> {
match Self::new() {
Ok(ret) | Err(CreateError::NoV4(ret)) => Some(ret),
_ => None,
}
}
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
}
#[inline]
fn make_ip_opts(&self) -> IP_OPTION_INFORMATION {
#[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;
IP_OPTION_INFORMATION {
Ttl: self.ttl,
Flags: if self.df { DONT_FRAGMENT } else { 0 },
..Default::default()
}
}
pub fn send4(&self, dst: Ipv4Addr, buf: &mut Buffer) -> Result<u32, Error> {
buf.init_for_send();
let ret = unsafe {
IcmpSendEcho(
self.handles.v4,
windows_ipv4(dst),
buf.request_data_ptr(),
buf.request_data_len(),
&self.make_ip_opts(),
buf.reply_data_ptr(),
buf.reply_data_len(),
self.timeout,
)
};
finish_v4(ret, buf)
}
pub fn send4_from(&self, src: Ipv4Addr, dst: Ipv4Addr, buf: &mut Buffer) -> Result<u32, Error> {
buf.init_for_send();
let ret = unsafe {
IcmpSendEcho2Ex(
self.handles.v4,
ptr::null_mut(), None, ptr::null(), windows_ipv4(src),
windows_ipv4(dst),
buf.request_data_ptr(),
buf.request_data_len(),
&self.make_ip_opts(),
buf.reply_data_ptr(),
buf.reply_data_len(),
self.timeout,
)
};
finish_v4(ret, buf)
}
pub fn send6(&self, dst: Ipv6Addr, buf: &mut Buffer) -> Result<u32, Error> {
let dst = SOCKADDR_IN6 {
sin6_family: AF_INET6,
sin6_addr: windows_ipv6(dst),
..Default::default()
};
buf.init_for_send();
let ret = unsafe {
Icmp6SendEcho2(
self.handles.v6,
ptr::null_mut(), None, ptr::null(), &SOCKADDR_IN6::default(),
&dst,
buf.request_data_ptr(),
buf.request_data_len(),
&self.make_ip_opts(),
buf.reply_data_ptr(),
buf.reply_data_len(),
self.timeout,
)
};
finish_v6(ret, buf)
}
pub fn send6_from(&self, src: Ipv6Addr, dst: Ipv6Addr, buf: &mut Buffer) -> Result<u32, Error> {
let dst = SOCKADDR_IN6 {
sin6_family: AF_INET6,
sin6_addr: windows_ipv6(dst),
..Default::default()
};
let src = SOCKADDR_IN6 {
sin6_family: AF_INET6,
sin6_addr: windows_ipv6(src),
..Default::default()
};
buf.init_for_send();
let ret = unsafe {
Icmp6SendEcho2(
self.handles.v6,
ptr::null_mut(), None, ptr::null(), &src,
&dst,
buf.request_data_ptr(),
buf.request_data_len(),
&self.make_ip_opts(),
buf.reply_data_ptr(),
buf.reply_data_len(),
self.timeout,
)
};
finish_v6(ret, buf)
}
pub fn send(&self, dst: IpAddr, buf: &mut Buffer) -> Result<u32, Error> {
match dst {
IpAddr::V4(ip) => self.send4(ip, buf),
IpAddr::V6(ip) => self.send6(ip, buf),
}
}
pub fn send_from(&mut self, src_dst_pair: IpPair, buf: &mut Buffer) -> Result<u32, Error> {
match src_dst_pair {
IpPair::V4 { src, dst } => self.send4_from(src, dst, buf),
IpPair::V6 { src, dst } => self.send6_from(src, dst, buf),
}
}
}
const _: () = {
const fn assert_send_sync<T: Send + Sync>() {}
assert_send_sync::<Pinger>();
};
fn finish_v4(ret: u32, buf: &mut Buffer) -> Result<u32, Error> {
if ret == 0 {
return Err(Error::from_lasterror());
}
let Some(reply) = buf.as_echo_reply() else {
return Err(Error::from_iperror(IP_BUF_TOO_SMALL));
};
let (status, rtt) = (reply.Status, reply.RoundTripTime);
buf.set_filled4();
if status == IP_SUCCESS {
Ok(rtt)
} else {
Err(Error::from_iperror(status))
}
}
fn finish_v6(ret: u32, buf: &mut Buffer) -> Result<u32, Error> {
if ret == 0 {
return Err(Error::from_lasterror());
}
let Some(reply) = buf.as_echo_reply6() else {
return Err(Error::from_iperror(IP_BUF_TOO_SMALL));
};
let (status, rtt) = (reply.Status, reply.RoundTripTime);
buf.set_filled6();
if status == IP_SUCCESS {
Ok(rtt)
} else {
Err(Error::from_iperror(status))
}
}
impl Drop for Handles {
fn drop(&mut self) {
if self.v4 != INVALID_HANDLE_VALUE {
let ret = unsafe { IcmpCloseHandle(self.v4) };
debug_assert_ne!(0, ret);
}
if self.v6 != INVALID_HANDLE_VALUE {
let ret = unsafe { IcmpCloseHandle(self.v6) };
debug_assert_ne!(0, ret);
}
}
}