use std::collections::VecDeque;
use std::ffi::c_int;
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, 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;
const IP_TOS: c_int = 3;
const IP_TTL: c_int = 4;
const MULTICAST_TTL: c_int = 10;
const PKTINFO: c_int = 19;
const HOPLIMIT: c_int = 21;
const IPV6_TCLASS: c_int = 39;
const RECVTOS: c_int = 40;
const ECN: c_int = 50;
const UDP_SEND_MSG_SIZE: c_int = 2;
const UDP_COALESCED: c_int = 3;
const SO_TIMESTAMP_ID: c_int = 0x300B;
#[derive(Default)]
pub(crate) struct WinSock {
pub(crate) v6: bool,
legacy_frag: bool,
pub(crate) stamping: Stamping,
recv4: Recv,
recv6: Recv,
uso: u32,
uro: u32,
}
#[derive(Default)]
struct Recv {
pktinfo: bool,
ecn: bool,
ttl: bool,
tos: bool,
}
#[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,
Tos,
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, Tos, 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),
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, IP_TOS, Harmless, Tos, 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, 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, 47, 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, 23, Unmodelled, Dword, 0),
opt(IPPROTO_IPV6, 24, Unmodelled, Flag, 0),
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, IPV6_TCLASS, Harmless, Tos, 0),
opt(IPPROTO_IPV6, 47, 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, 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) v6only: bool,
}
pub(crate) fn level_applies(kind: Kind, level: c_int, name: c_int) -> Result<(), c_int> {
let receive = matches!(name, PKTINFO | HOPLIMIT | RECVTOS | ECN);
let any_family = matches!(name, 4 | IPV6_DONTFRAG | MTU_DISCOVER | IPV6_TCLASS);
match level {
IPPROTO_IPV6 if !kind.v6 && !receive && !any_family => Err(WSAEINVAL),
IPPROTO_IP | IPPROTO_IPV6 if kind.stream && receive => Err(WSAEINVAL),
IPPROTO_TCP if !kind.stream => Err(WSAENOPROTOOPT),
IPPROTO_UDP if kind.stream => Err(WSAEINVAL),
_ => Ok(()),
}
}
fn dual_stack(rec: &SockRec) -> bool {
let state = rec.state();
!state.v6only
&& state.local.is_none_or(|local| match local.ip() {
IpAddr::V6(ip) => ip.is_unspecified() || ip.to_ipv4_mapped().is_some(),
IpAddr::V4(_) => true,
})
}
pub(crate) fn ip_on_v6(rec: &SockRec, name: c_int) -> Result<(), c_int> {
match name {
IP_TOS | IP_TTL | IP_DONTFRAGMENT | PKTINFO | HOPLIMIT | 24 | 25 | RECVTOS | 47 | ECN
| 51 | MTU_DISCOVER | 75
if !dual_stack(rec) =>
{
Err(WSAEINVAL)
}
_ => 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 && kind.v6only {
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),
Tos if !(0..=255).contains(&v) || v & 3 != 0 => 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 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(())
}
fn v4(dest: SocketAddr) -> bool {
match dest {
SocketAddr::V4(_) => true,
SocketAddr::V6(v6) => v6.ip().to_ipv4_mapped().is_some(),
}
}
pub(crate) fn max_payload(dest: SocketAddr) -> usize {
if v4(dest) { 65507 } else { 65527 }
}
enum Anc<'a> {
Flag(&'a mut bool),
Size(&'a mut u32),
}
fn anc(win: &mut WinSock, level: c_int, name: c_int) -> Option<Anc<'_>> {
let recv = match level {
IPPROTO_IP => &mut win.recv4,
IPPROTO_IPV6 => &mut win.recv6,
IPPROTO_UDP => {
return match name {
UDP_SEND_MSG_SIZE => Some(Anc::Size(&mut win.uso)),
UDP_COALESCED => Some(Anc::Size(&mut win.uro)),
_ => None,
};
}
_ => return None,
};
Some(Anc::Flag(match name {
PKTINFO => &mut recv.pktinfo,
ECN => &mut recv.ecn,
HOPLIMIT => &mut recv.ttl,
RECVTOS => &mut recv.tos,
_ => return None,
}))
}
pub(crate) unsafe fn set_anc(
rec: &SockRec,
level: c_int,
name: c_int,
val: *const u8,
len: u32,
) -> Option<Result<(), c_int>> {
let mut state = rec.state();
let option = anc(&mut state.win, level, name)?;
if val.is_null() || (len as usize) < size_of::<u32>() {
return Some(Err(WSAEFAULT));
}
let v = unsafe { val.cast::<u32>().read_unaligned() };
match option {
Anc::Flag(on) => *on = v != 0,
Anc::Size(size) => *size = v,
}
Some(Ok(()))
}
pub(crate) fn get_anc(rec: &SockRec, level: c_int, name: c_int) -> Option<u32> {
match anc(&mut rec.state().win, level, name)? {
Anc::Flag(on) => Some(u32::from(*on)),
Anc::Size(size) => Some(*size),
}
}
pub(crate) struct SendCtl {
tos: u8,
ttl: u8,
pub(crate) src: Option<IpAddr>,
seg: u32,
pub(crate) tx_id: Option<u32>,
}
fn kept(rec: &SockRec, level: c_int, name: c_int) -> Option<c_int> {
let bytes = rec.ignored_value(level, name)?;
Some(c_int::from_ne_bytes(bytes.get(..4)?.try_into().ok()?))
}
fn int(data: &[u8]) -> Result<c_int, c_int> {
let bytes = data.get(..4).ok_or(WSAEINVAL)?;
Ok(c_int::from_ne_bytes(bytes.try_into().unwrap()))
}
pub(crate) fn send_ctl(
shared: &SimShared,
rec: &SockRec,
dest: SocketAddr,
msgs: &[(c_int, c_int, Vec<u8>)],
) -> Result<SendCtl, c_int> {
let ipv4 = v4(dest);
let (level, tos_type) = if ipv4 {
(IPPROTO_IP, IP_TOS)
} else {
(IPPROTO_IPV6, IPV6_TCLASS)
};
let ttl = if dest.ip().is_multicast() {
kept(rec, level, MULTICAST_TTL)
} else {
kept(rec, IPPROTO_IP, IP_TTL)
};
let mut ctl = SendCtl {
tos: kept(rec, level, tos_type).unwrap_or(0) as u8,
ttl: ttl.map_or(crate::ancillary::Header::plain(dest.ip()).ttl, |t| t as u8),
src: None,
seg: rec.state().win.uso,
tx_id: None,
};
let bound = rec.state().local.is_some_and(|l| !l.ip().is_unspecified());
for (msg_level, ty, data) in msgs {
match (*msg_level, *ty) {
(l, ECN) if l == level => match int(data)? {
ecn @ 0..=2 => ctl.tos = (ctl.tos & !3) | ecn as u8,
_ => return Err(WSAEINVAL),
},
(l, t) if l == level && t == tos_type => match int(data)? {
tos @ 0..=255 if tos & 3 != 3 => ctl.tos = tos as u8,
_ => return Err(WSAEINVAL),
},
(l, HOPLIMIT) if l == level => match int(data)? {
ttl @ 0..=255 => ctl.ttl = ttl as u8,
_ => return Err(WSAEINVAL),
},
(l, PKTINFO) if l == level => {
if !bound {
ctl.src = pktinfo(shared, ipv4, data)?;
}
}
(IPPROTO_UDP, UDP_SEND_MSG_SIZE) if data.len() == 4 => {
ctl.seg = u32::from_ne_bytes(data[..4].try_into().unwrap());
}
(SOL_SOCKET, SO_TIMESTAMP_ID) if data.len() == 4 => {
ctl.tx_id = Some(u32::from_ne_bytes(data[..4].try_into().unwrap()));
}
_ => return Err(WSAEINVAL),
}
}
Ok(ctl)
}
fn pktinfo(shared: &SimShared, ipv4: bool, data: &[u8]) -> Result<Option<IpAddr>, c_int> {
let (addr, index): (IpAddr, &[u8]) = if ipv4 {
let addr: [u8; 4] = data.get(..4).ok_or(WSAEINVAL)?.try_into().unwrap();
(
Ipv4Addr::from(addr).into(),
data.get(4..8).ok_or(WSAEINVAL)?,
)
} else {
let addr: [u8; 16] = data.get(..16).ok_or(WSAEINVAL)?.try_into().unwrap();
(
Ipv6Addr::from(addr).into(),
data.get(16..20).ok_or(WSAEINVAL)?,
)
};
let index = u32::from_ne_bytes(index.try_into().unwrap());
let topo = shared.topo();
if index != 0 && topo.name_of(index).is_none() {
return Err(WSAEINVAL);
}
if addr.is_unspecified() {
return Ok(None);
}
if !topo.holds(addr) {
return Err(WSAEINVAL);
}
Ok(Some(addr))
}
pub(crate) fn header(ctl: &SendCtl, dest: SocketAddr) -> crate::ancillary::Header {
let dst = match dest.ip() {
IpAddr::V6(ip) => ip.to_ipv4_mapped().map_or(IpAddr::V6(ip), IpAddr::V4),
ip => ip,
};
crate::ancillary::Header {
tos: ctl.tos,
ttl: ctl.ttl,
..crate::ancillary::Header::plain(dst)
}
}
pub(crate) fn segment(ctl: &SendCtl, dest: SocketAddr, len: usize) -> Result<u16, c_int> {
let max = max_payload(dest);
let seg = ctl.seg as usize;
if seg > max {
return Err(WSAEINVAL);
}
if seg != 0 && len > seg {
return Ok(seg as u16);
}
if len > max {
return Err(WSAEMSGSIZE);
}
Ok(0)
}
pub(crate) fn coalesce(rec: Option<&SockRec>, seg: usize, len: usize, max: usize) -> Vec<usize> {
let limit = rec.map_or(0, |r| r.state().win.uro as usize);
let per_read = (limit / seg).max(1) * seg;
let mut out = Vec::new();
let mut at = 0;
while at < len {
let piece = if len - at <= max {
len - at
} else {
(max / seg) * seg
};
out.extend(
(0..piece)
.step_by(per_read)
.map(|from| per_read.min(piece - from)),
);
at += piece;
}
out
}
const SO_TIMESTAMP: c_int = 0x300A;
pub(crate) fn rx_cmsgs(
rec: &SockRec,
h: &crate::ancillary::Header,
arrived: Duration,
) -> Vec<(c_int, c_int, Vec<u8>)> {
let mut out = Vec::new();
{
let state = rec.state();
let (level, recv, tos_type, ttl_type) = match h.dst {
IpAddr::V4(_) => (IPPROTO_IP, &state.win.recv4, IP_TOS, IP_TTL),
IpAddr::V6(_) => (IPPROTO_IPV6, &state.win.recv6, IPV6_TCLASS, HOPLIMIT),
};
let int = |v: u8| c_int::from(v).to_ne_bytes().to_vec();
if recv.pktinfo {
let mut info = match h.dst {
IpAddr::V4(ip) => ip.octets().to_vec(),
IpAddr::V6(ip) => ip.octets().to_vec(),
};
info.extend(h.ifindex.to_ne_bytes());
out.push((level, PKTINFO, info));
}
if recv.ecn {
out.push((level, ECN, int(h.tos & 3)));
}
if recv.ttl {
out.push((level, ttl_type, int(h.ttl)));
}
if recv.tos {
out.push((level, tos_type, int(h.tos)));
}
}
if let Some(stamp) = rx_stamp(rec, arrived) {
out.push((SOL_SOCKET, SO_TIMESTAMP, stamp.to_ne_bytes().to_vec()));
}
if h.gso != 0 {
out.push((
IPPROTO_UDP,
UDP_COALESCED,
u32::from(h.gso).to_ne_bytes().to_vec(),
));
}
out
}
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())
})
}