use std::collections::VecDeque;
use std::ffi::c_int;
use std::net::SocketAddr;
use std::time::Duration;
use crate::netif::Sender;
use crate::scope::SimShared;
use crate::sockets::{SockRec, UnmodelledOption};
pub(crate) const WSAEFAULT: c_int = 10014;
pub(crate) const WSAEINVAL: c_int = 10022;
pub(crate) const WSAEMSGSIZE: c_int = 10040;
pub(crate) const WSAENOPROTOOPT: c_int = 10042;
pub(crate) const WSAEOPNOTSUPP: c_int = 10045;
pub(crate) const WSAEWOULDBLOCK: c_int = 10035;
pub(crate) const SOL_SOCKET: c_int = 0xffff;
pub(crate) const IPPROTO_IP: c_int = 0;
pub(crate) const IPPROTO_TCP: c_int = 6;
pub(crate) const IPPROTO_UDP: c_int = 17;
pub(crate) const IPPROTO_IPV6: c_int = 41;
pub(crate) const SO_PROTOCOL_INFOA: c_int = 0x2004;
pub(crate) const SO_PROTOCOL_INFOW: c_int = 0x2005;
pub(crate) const SO_KEEPALIVE: c_int = 0x0008;
pub(crate) const SO_OOBINLINE: c_int = 0x0100;
const IP_DONTFRAGMENT: c_int = 14;
const IPV6_DONTFRAG: c_int = 14;
const MTU_DISCOVER: c_int = 71;
const PMTUDISC_DO: u8 = 1;
const PMTUDISC_PROBE: u8 = 3;
const PMTUDISC_MAX: c_int = 4;
#[derive(Default)]
pub(crate) struct WinSock {
pub(crate) v6: bool,
legacy_frag: bool,
pub(crate) stamping: Stamping,
}
#[derive(Default)]
pub(crate) struct Stamping {
rx: bool,
tx: Option<usize>,
ready: VecDeque<(u32, u64)>,
}
#[derive(Clone, Copy, PartialEq)]
enum Class {
Harmless,
Unmodelled,
Refused(c_int),
}
#[derive(Clone, Copy)]
enum Shape {
Flag,
Dword,
UpTo(u32),
Hops,
Bytes,
}
#[derive(Clone, Copy, PartialEq)]
enum Access {
Both,
Get,
Set,
}
#[derive(Clone, Copy, PartialEq)]
enum Takes {
Any,
Stream,
}
struct Known {
level: c_int,
name: c_int,
class: Class,
shape: Shape,
access: Access,
takes: Takes,
default: i32,
}
const fn opt(level: c_int, name: c_int, class: Class, shape: Shape, default: i32) -> Known {
Known {
level,
name,
class,
shape,
access: Access::Both,
takes: Takes::Any,
default,
}
}
const fn get_only(level: c_int, name: c_int, shape: Shape) -> Known {
Known {
access: Access::Get,
..opt(level, name, Class::Unmodelled, shape, 0)
}
}
const fn set_only(level: c_int, name: c_int) -> Known {
Known {
access: Access::Set,
..opt(level, name, Class::Unmodelled, Shape::Bytes, 0)
}
}
use Class::{Harmless, Unmodelled};
use Shape::{Bytes, Dword, Flag, Hops, UpTo};
static KNOWN: &[Known] = &[
Known {
takes: Takes::Stream,
..opt(SOL_SOCKET, SO_KEEPALIVE, Harmless, Flag, 0)
},
opt(SOL_SOCKET, 0x0001, Harmless, Flag, 0),
opt(SOL_SOCKET, 0x0010, Harmless, Flag, 0),
opt(SOL_SOCKET, SO_OOBINLINE, Harmless, Flag, 0),
opt(SOL_SOCKET, 0x0040, Class::Refused(WSAEINVAL), Dword, 0),
opt(SOL_SOCKET, 0x1003, Class::Refused(WSAEINVAL), Dword, 0),
opt(SOL_SOCKET, 0x1004, Class::Refused(WSAEINVAL), Dword, 0),
opt(SOL_SOCKET, !0x0004, Unmodelled, Flag, 0),
get_only(SOL_SOCKET, 0x1009, Bytes),
get_only(SOL_SOCKET, 0x2001, Dword),
opt(SOL_SOCKET, 0x2002, Unmodelled, Dword, 0),
get_only(SOL_SOCKET, 0x2003, Dword),
opt(SOL_SOCKET, 0x3002, Unmodelled, Flag, 0),
opt(SOL_SOCKET, 0x3003, Unmodelled, Flag, 0),
opt(SOL_SOCKET, 0x3005, Unmodelled, Flag, 0),
opt(SOL_SOCKET, 0x3006, Unmodelled, Flag, 0),
opt(SOL_SOCKET, 0x3007, Unmodelled, Flag, 0),
opt(SOL_SOCKET, 0x3008, Unmodelled, Flag, 0),
opt(SOL_SOCKET, 0x7008, Unmodelled, Dword, 0),
get_only(SOL_SOCKET, 0x7009, Dword),
get_only(SOL_SOCKET, 0x700A, Dword),
set_only(SOL_SOCKET, 0x700B),
get_only(SOL_SOCKET, 0x700C, Dword),
set_only(SOL_SOCKET, 0x7010),
opt(IPPROTO_IP, 1, Unmodelled, Bytes, 0),
opt(IPPROTO_IP, 2, Unmodelled, Flag, 0),
opt(IPPROTO_IP, 3, Harmless, Dword, 0),
opt(IPPROTO_IP, 4, Harmless, Hops, 128),
opt(IPPROTO_IP, 10, Harmless, Hops, 1),
opt(IPPROTO_IP, 11, Unmodelled, Flag, 1),
set_only(IPPROTO_IP, 13),
set_only(IPPROTO_IP, 15),
set_only(IPPROTO_IP, 16),
set_only(IPPROTO_IP, 17),
set_only(IPPROTO_IP, 18),
opt(IPPROTO_IP, 19, Unmodelled, Flag, 0),
opt(IPPROTO_IP, 21, Unmodelled, Flag, 0),
opt(IPPROTO_IP, 22, Unmodelled, Flag, 1),
opt(IPPROTO_IP, 24, Unmodelled, Flag, 0),
opt(IPPROTO_IP, 28, Unmodelled, Flag, 0),
set_only(IPPROTO_IP, 29),
set_only(IPPROTO_IP, 30),
get_only(IPPROTO_IP, 33, Bytes),
opt(IPPROTO_IP, 40, Unmodelled, Flag, 0),
opt(IPPROTO_IP, 47, Unmodelled, Flag, 0),
opt(IPPROTO_IP, 50, Unmodelled, Flag, 0),
opt(IPPROTO_IP, 60, Unmodelled, Bytes, 0),
opt(IPPROTO_IP, 70, Unmodelled, Bytes, 0),
get_only(IPPROTO_IP, 73, Dword),
opt(IPPROTO_IP, 76, Unmodelled, Dword, -1),
opt(IPPROTO_IPV6, 2, Unmodelled, Flag, 0),
opt(IPPROTO_IPV6, 4, Harmless, Hops, 128),
opt(IPPROTO_IPV6, 10, Harmless, Hops, 1),
opt(IPPROTO_IPV6, 11, Unmodelled, Flag, 1),
set_only(IPPROTO_IPV6, 13),
opt(IPPROTO_IPV6, 19, Unmodelled, Flag, 0),
opt(IPPROTO_IPV6, 21, Unmodelled, Flag, 0),
opt(IPPROTO_IPV6, 23, Unmodelled, Dword, 0),
opt(IPPROTO_IPV6, 24, Unmodelled, Flag, 0),
opt(IPPROTO_IPV6, 27, Unmodelled, Flag, 1),
opt(IPPROTO_IPV6, 28, Unmodelled, Flag, 0),
set_only(IPPROTO_IPV6, 29),
set_only(IPPROTO_IPV6, 30),
get_only(IPPROTO_IPV6, 33, Bytes),
opt(IPPROTO_IPV6, 39, Harmless, Dword, 0),
opt(IPPROTO_IPV6, 40, Unmodelled, Flag, 0),
opt(IPPROTO_IPV6, 47, Unmodelled, Flag, 0),
opt(IPPROTO_IPV6, 50, Unmodelled, Flag, 0),
get_only(IPPROTO_IPV6, 72, Dword),
opt(IPPROTO_IPV6, 76, Unmodelled, Dword, -1),
opt(IPPROTO_TCP, 1, Harmless, Flag, 0),
opt(IPPROTO_TCP, 2, Unmodelled, Flag, 0),
opt(IPPROTO_TCP, 3, Harmless, Dword, 7200),
opt(IPPROTO_TCP, 10, Unmodelled, Flag, 0),
opt(IPPROTO_TCP, 15, Unmodelled, Flag, 0),
opt(IPPROTO_TCP, 16, Harmless, UpTo(255), 10),
opt(IPPROTO_TCP, 17, Harmless, Dword, 1),
opt(IPPROTO_TCP, 18, Unmodelled, Flag, 0),
get_only(IPPROTO_TCP, 19, Bytes),
opt(IPPROTO_TCP, 0x7000, Unmodelled, Flag, 1),
opt(IPPROTO_UDP, 1, Unmodelled, Flag, 0),
opt(IPPROTO_UDP, 2, Unmodelled, Dword, 0),
opt(IPPROTO_UDP, 3, Unmodelled, Dword, 0),
opt(IPPROTO_UDP, 20, Unmodelled, Flag, 0),
];
pub(crate) fn unknown(level: c_int) -> c_int {
match level {
IPPROTO_IP | IPPROTO_IPV6 | IPPROTO_TCP | IPPROTO_UDP => WSAENOPROTOOPT,
_ => WSAEINVAL,
}
}
#[derive(Clone, Copy)]
pub(crate) struct Kind {
pub(crate) stream: bool,
pub(crate) connecting: bool,
pub(crate) v6: bool,
}
pub(crate) fn level_applies(kind: Kind, level: c_int, name: c_int) -> Result<(), c_int> {
match level {
IPPROTO_IPV6 if !kind.v6 && !matches!(name, 4 | IPV6_DONTFRAG | MTU_DISCOVER) => {
Err(WSAEINVAL)
}
IPPROTO_TCP if !kind.stream => Err(WSAENOPROTOOPT),
IPPROTO_UDP if kind.stream => Err(WSAENOPROTOOPT),
_ => Ok(()),
}
}
fn lookup(level: c_int, name: c_int) -> Option<&'static Known> {
KNOWN.iter().find(|k| k.level == level && k.name == name)
}
fn usable(known: &Known, kind: Kind, set: bool) -> Result<(), c_int> {
if let Class::Refused(code) = known.class {
return Err(code);
}
let wrong_way = if set {
known.access == Access::Get
} else {
known.access == Access::Set
};
if wrong_way {
return Err(unknown(known.level));
}
if known.takes == Takes::Stream && !kind.stream {
return Err(WSAENOPROTOOPT);
}
if set && kind.v6 && known.level == IPPROTO_IP && known.name == 4 {
return Err(WSAEINVAL);
}
if set && known.level == SOL_SOCKET && known.name == SO_KEEPALIVE && kind.connecting {
return Err(WSAEINVAL);
}
Ok(())
}
pub(crate) unsafe fn set(
shared: &SimShared,
rec: &SockRec,
kind: Kind,
level: c_int,
name: c_int,
val: *const u8,
len: u32,
) -> Result<(), c_int> {
let known = lookup(level, name).ok_or(unknown(level))?;
usable(known, kind, true)?;
let bytes = match known.shape {
Bytes => {
if val.is_null() && len > 0 {
return Err(WSAEFAULT);
}
if val.is_null() {
Vec::new()
} else {
unsafe { std::slice::from_raw_parts(val, len as usize) }.to_vec()
}
}
shape => {
if val.is_null() || (len as usize) < size_of::<c_int>() {
return Err(WSAEFAULT);
}
let v = unsafe { val.cast::<c_int>().read_unaligned() };
let stored = match shape {
Flag => c_int::from(v != 0),
UpTo(max) if v < 0 || v as u32 > max => return Err(WSAEINVAL),
Hops if v == -1 && known.name == 4 => 255,
Hops if v == -1 => known.default,
Hops if !(0..=255).contains(&v) => return Err(WSAEINVAL),
_ => v,
};
stored.to_ne_bytes().to_vec()
}
};
if known.class == Unmodelled
&& shared.unmodelled_option(rec, UnmodelledOption::Set { level, name })
{
return Err(unknown(level));
}
let stored_level = if name == 4 && matches!(level, IPPROTO_IP | IPPROTO_IPV6) {
IPPROTO_IP
} else {
level
};
rec.keep_ignored(stored_level, name, &bytes);
Ok(())
}
pub(crate) fn get(
shared: &SimShared,
rec: &SockRec,
kind: Kind,
level: c_int,
name: c_int,
) -> Result<Vec<u8>, c_int> {
let known = lookup(level, name).ok_or(unknown(level))?;
usable(known, kind, false)?;
if known.class == Unmodelled
&& shared.unmodelled_option(rec, UnmodelledOption::Get { level, name })
{
return Err(unknown(level));
}
let stored_level = if name == 4 && matches!(level, IPPROTO_IP | IPPROTO_IPV6) {
IPPROTO_IP
} else {
level
};
Ok(match rec.ignored_value(stored_level, name) {
Some(bytes) => bytes,
None if matches!(known.shape, Bytes) => Vec::new(),
None => known.default.to_ne_bytes().to_vec(),
})
}
pub(crate) unsafe fn set_frag(
rec: &SockRec,
level: c_int,
name: c_int,
val: *const u8,
len: u32,
) -> Option<Result<(), c_int>> {
let which = match (level, name) {
(IPPROTO_IP, IP_DONTFRAGMENT) | (IPPROTO_IPV6, IPV6_DONTFRAG) => true,
(IPPROTO_IP | IPPROTO_IPV6, MTU_DISCOVER) => false,
_ => return None,
};
if val.is_null() || (len as usize) < size_of::<c_int>() {
return Some(Err(WSAEFAULT));
}
let v = unsafe { val.cast::<c_int>().read_unaligned() };
if !which && !(0..PMTUDISC_MAX).contains(&v) {
return Some(Err(WSAEINVAL));
}
let mut state = rec.state();
if level == IPPROTO_IP && state.win.v6 {
return Some(Err(WSAEINVAL));
}
if which {
if state.frag.pmtudisc != 0 {
return Some(Err(WSAEINVAL));
}
state.win.legacy_frag = true;
state.frag.dontfrag = v != 0;
state.frag.dontfrag6 = v != 0;
} else {
if state.win.legacy_frag {
return Some(Err(WSAEINVAL));
}
state.frag.pmtudisc = v as u8;
state.frag.pmtudisc6 = v as u8;
let flag = matches!(v as u8, PMTUDISC_DO | PMTUDISC_PROBE);
state.frag.dontfrag = flag;
state.frag.dontfrag6 = flag;
}
Some(Ok(()))
}
pub(crate) fn get_frag(rec: &SockRec, level: c_int, name: c_int) -> Option<c_int> {
let frag = rec.state().frag;
Some(match (level, name) {
(IPPROTO_IP, IP_DONTFRAGMENT) => c_int::from(frag.dontfrag),
(IPPROTO_IP, MTU_DISCOVER) => c_int::from(frag.pmtudisc),
(IPPROTO_IPV6, IPV6_DONTFRAG) => c_int::from(frag.dontfrag6),
(IPPROTO_IPV6, MTU_DISCOVER) => c_int::from(frag.pmtudisc6),
_ => return None,
})
}
pub(crate) fn check_send(
shared: &SimShared,
rec: &SockRec,
sender: &Sender,
dest: SocketAddr,
len: usize,
) -> Result<(), c_int> {
let Sender::Host(path) = sender else {
return Ok(());
};
let frag = rec.state().frag;
let v4 = match dest {
SocketAddr::V4(_) => true,
SocketAddr::V6(v6) => v6.ip().to_ipv4_mapped().is_some(),
};
let no_frag = |flag: bool, mode: u8| flag || mode == PMTUDISC_DO || mode == PMTUDISC_PROBE;
let (keep_whole, headers) = if v4 {
(no_frag(frag.dontfrag, frag.pmtudisc), 8 + 20)
} else {
(no_frag(frag.dontfrag6, frag.pmtudisc6), 8 + 40)
};
if !keep_whole {
return Ok(());
}
let Some(mtu) = shared.nic(&path.name).map(|nic| nic.spec.mtu as usize) else {
return Ok(());
};
if len.saturating_add(headers) > mtu {
return Err(WSAEMSGSIZE);
}
Ok(())
}
const TIMESTAMPING_FLAG_RX: u32 = 1;
const TIMESTAMPING_FLAG_TX: u32 = 2;
const TIMESTAMPING_CONFIG_LEN: usize = 8;
pub(crate) unsafe fn configure_stamping(
rec: &SockRec,
input: *const u8,
input_len: u32,
) -> Result<(), c_int> {
if input.is_null() || (input_len as usize) < TIMESTAMPING_CONFIG_LEN {
return Err(WSAEFAULT);
}
let flags = unsafe { input.cast::<u32>().read_unaligned() };
let buffered = unsafe { input.add(4).cast::<u16>().read_unaligned() };
if flags & !(TIMESTAMPING_FLAG_RX | TIMESTAMPING_FLAG_TX) != 0 {
return Err(WSAEINVAL);
}
let mut state = rec.state();
let stamping = &mut state.win.stamping;
stamping.rx = flags & TIMESTAMPING_FLAG_RX != 0;
stamping.tx = (flags & TIMESTAMPING_FLAG_TX != 0).then_some(usize::from(buffered));
let keep = stamping.tx.unwrap_or(0);
stamping.ready.truncate(keep);
Ok(())
}
pub(crate) unsafe fn take_tx_stamp(
rec: &SockRec,
input: *const u8,
input_len: u32,
output: *mut u8,
output_len: u32,
returned: *mut u32,
) -> Result<(), c_int> {
let mut state = rec.state();
let stamping = &mut state.win.stamping;
if stamping.tx.is_none() {
return Err(WSAEOPNOTSUPP);
}
if input.is_null() || (input_len as usize) < size_of::<u32>() {
return Err(WSAEFAULT);
}
if output.is_null() || (output_len as usize) < size_of::<u64>() {
return Err(WSAEFAULT);
}
let id = unsafe { input.cast::<u32>().read_unaligned() };
let at = stamping
.ready
.iter()
.position(|&(tag, _)| tag == id)
.ok_or(WSAEWOULDBLOCK)?;
let (_, stamp) = stamping.ready.remove(at).expect("position is in range");
unsafe {
output.cast::<u64>().write_unaligned(stamp);
if !returned.is_null() {
returned.write_unaligned(size_of::<u64>() as u32);
}
}
Ok(())
}
pub(crate) fn note_tx_stamp(rec: &SockRec, id: u32, sent: Duration) {
let mut state = rec.state();
let stamping = &mut state.win.stamping;
if let Some(room) = stamping.tx
&& stamping.ready.len() < room
{
stamping
.ready
.push_back((id, snare_interpose::performance_count(sent)));
}
}
pub(crate) fn rx_stamp(rec: &SockRec, arrived: Duration) -> Option<u64> {
rec.state()
.win
.stamping
.rx
.then(|| snare_interpose::performance_count(arrived))
}
pub(crate) unsafe fn get_protocol_info(
kind: Kind,
name: c_int,
val: *mut u8,
len: *mut u32,
) -> Result<(), c_int> {
use windows_sys::Win32::Networking::WinSock as ws;
let family = if kind.v6 { ws::AF_INET6 } else { ws::AF_INET } as i32;
let (ty, protocol) = if kind.stream {
(ws::SOCK_STREAM, ws::IPPROTO_TCP)
} else {
(ws::SOCK_DGRAM, ws::IPPROTO_UDP)
};
let entry = if name == SO_PROTOCOL_INFOW {
catalog_entry(
ws::WSAEnumProtocolsW,
protocol,
|e: &ws::WSAPROTOCOL_INFOW| (e.iAddressFamily, e.iSocketType) == (family, ty),
)
} else {
catalog_entry(
ws::WSAEnumProtocolsA,
protocol,
|e: &ws::WSAPROTOCOL_INFOA| (e.iAddressFamily, e.iSocketType) == (family, ty),
)
};
let size = entry.as_ref().map_or(0, Vec::len);
if val.is_null() || len.is_null() || (unsafe { *len } as usize) < size {
if name == SO_PROTOCOL_INFOA && !len.is_null() {
unsafe { *len = size as u32 };
}
return Err(WSAEFAULT);
}
let entry = entry.ok_or(WSAENOPROTOOPT)?;
unsafe {
std::ptr::copy_nonoverlapping(entry.as_ptr(), val, size);
if name == SO_PROTOCOL_INFOW {
*len = size as u32;
}
}
Ok(())
}
fn catalog_entry<T>(
enumerate: unsafe extern "system" fn(*const i32, *mut T, *mut u32) -> i32,
protocol: i32,
matches: impl Fn(&T) -> bool,
) -> Option<Vec<u8>> {
use windows_sys::Win32::Networking::WinSock as ws;
snare_interpose::real(|| unsafe {
let mut data: ws::WSADATA = std::mem::zeroed();
if ws::WSAStartup(0x0202, &mut data) != 0 {
return None;
}
let protocols = [protocol, 0];
let mut bytes = 0u32;
enumerate(protocols.as_ptr(), std::ptr::null_mut(), &mut bytes);
let mut entries: Vec<T> = (0..bytes as usize / size_of::<T>() + 1)
.map(|_| std::mem::zeroed())
.collect();
bytes = (entries.len() * size_of::<T>()) as u32;
let count = enumerate(protocols.as_ptr(), entries.as_mut_ptr(), &mut bytes);
ws::WSACleanup();
let entry = entries
.get(..usize::try_from(count).ok()?)?
.iter()
.find(|e| matches(e))?;
Some(std::slice::from_raw_parts((entry as *const T).cast::<u8>(), size_of::<T>()).to_vec())
})
}