use crate::config::ServiceDetection;
use crate::config::limits::{CONNECT_PROBE_TIMEOUT, DISCOVERY_CONCURRENCY};
use crate::evasion::EvasionProfile;
use crate::journal::settle::{Outcome, Settled};
use crate::logging::error;
use crate::model::host::{Host, HostStatus, NetworkRole, StatusProtocol, StatusReason};
use crate::model::ip::scoped::ZoneMap;
use crate::model::ip::set::IpSet;
use crate::model::port::discovery::{Discovery, ScanResponse};
use crate::model::port::{Port, PortSet, PortState, Protocol};
use crate::model::target::PlannedTarget;
use crate::report::ScannerKind;
use crate::report::StopReason;
use crate::scanner::audit::ProbeAudit;
use crate::scanner::dispatcher::dispatch_addresses;
use crate::scanner::handle::ScanHandle;
use crate::scanner::payload;
use crate::scanner::pool::ProbePool;
use crate::scanner::session::ScanContext;
use crate::scanner::strategy::{HostScanner, PortScanner, StrategyError};
use async_trait::async_trait;
use socket2::{Domain, Socket, Type};
use std::io::ErrorKind;
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
use std::sync::Arc;
use std::time::Instant;
use tokio::net::{TcpSocket, TcpStream};
use tokio::sync::mpsc;
use tokio::time::timeout;
#[cfg(any(windows, test))]
mod syn_retries;
#[derive(Debug, Clone, Copy, Default)]
struct ConnectShaping {
source_port: Option<u16>,
hop_limit: Option<u8>,
}
impl ConnectShaping {
fn is_active(self) -> bool {
self.source_port.is_some() || self.hop_limit.is_some()
}
}
impl From<&EvasionProfile> for ConnectShaping {
fn from(evasion: &EvasionProfile) -> Self {
Self {
source_port: evasion.source_port,
hop_limit: evasion.ttl,
}
}
}
pub struct ConnectScanner {
ips: IpSet,
ctx: ScanContext,
evasion: EvasionProfile,
}
impl ConnectScanner {
pub fn new(ips: IpSet, ctx: ScanContext, evasion: &EvasionProfile) -> Self {
Self {
ips,
ctx,
evasion: evasion.clone(),
}
}
}
#[async_trait]
impl HostScanner for ConnectScanner {
fn kind(&self) -> ScannerKind {
ScannerKind::Connect
}
async fn discover_hosts(&mut self) -> Result<(), StrategyError> {
discover(
std::mem::take(&mut self.ips),
self.ctx.clone(),
&self.evasion,
)
.await
}
}
struct Probed {
ip: IpAddr,
port: Option<Port>,
responses: Vec<String>,
about_the_host: crate::fingerprint::AboutTheHost,
answered: bool,
outcome: Outcome,
role: Option<NetworkRole>,
}
type ProbedPort = Option<Probed>;
pub struct ConnectPortScanner {
ctx: ScanContext,
concurrency: usize,
detection: ServiceDetection,
evasion: EvasionProfile,
zones: ZoneMap,
}
impl ConnectPortScanner {
pub fn new(
ctx: ScanContext,
concurrency: usize,
detection: ServiceDetection,
evasion: &EvasionProfile,
) -> Self {
Self {
ctx,
concurrency,
detection,
evasion: evasion.clone(),
zones: ZoneMap::new(),
}
}
pub fn with_zones(mut self, zones: ZoneMap) -> Self {
self.zones = zones;
self
}
}
#[async_trait]
impl PortScanner for ConnectPortScanner {
fn kind(&self) -> ScannerKind {
ScannerKind::Connect
}
fn supported_protocols(&self) -> Vec<Protocol> {
vec![Protocol::Tcp]
}
async fn scan(&mut self, rx: mpsc::Receiver<PlannedTarget>) -> Result<(), StrategyError> {
scan(
rx,
self.concurrency,
self.ctx.clone(),
self.detection,
&self.evasion,
&self.zones,
)
.await
}
}
pub struct ConnectUdpPortScanner {
ctx: ScanContext,
concurrency: usize,
evasion: EvasionProfile,
service_detection: ServiceDetection,
zones: ZoneMap,
}
impl ConnectUdpPortScanner {
pub fn new(ctx: ScanContext, concurrency: usize, evasion: &EvasionProfile) -> Self {
Self::with_detection(ctx, concurrency, evasion, ServiceDetection::default())
}
pub fn with_detection(
ctx: ScanContext,
concurrency: usize,
evasion: &EvasionProfile,
service_detection: ServiceDetection,
) -> Self {
Self {
ctx,
concurrency,
evasion: evasion.clone(),
service_detection,
zones: ZoneMap::new(),
}
}
pub fn with_zones(mut self, zones: ZoneMap) -> Self {
self.zones = zones;
self
}
}
#[async_trait]
impl PortScanner for ConnectUdpPortScanner {
fn kind(&self) -> ScannerKind {
ScannerKind::ConnectUdp
}
fn supported_protocols(&self) -> Vec<Protocol> {
vec![Protocol::Udp]
}
async fn detect_services(&mut self, ctx: &ScanContext) {
crate::scanner::service::detect(ctx, self.service_detection, Protocol::Udp).await;
}
async fn scan(&mut self, mut rx: mpsc::Receiver<PlannedTarget>) -> Result<(), StrategyError> {
let ctx = self.ctx.clone();
let shaping = ConnectShaping::from(&self.evasion);
let mut pool = ProbePool::new(
self.concurrency,
self.ctx.clone(),
self.kind(),
|probed, audit: &mut ProbeAudit| absorb_probe(&ctx, probed, audit),
);
let mut probes = 0u128;
let mut reason = StopReason::AttemptsSpent;
while let Some(target) = rx.recv().await {
if let Some(cause) = self.ctx.handle.stopped() {
reason = cause.into();
record_unasked(&self.ctx, &target);
break;
}
probes += 1;
if self.ctx.host_expired(target.ip()) {
record_unasked(&self.ctx, &target);
continue;
}
pool.audit().record_send(true);
let endpoint = self.zones.endpoint(target.ip(), target.port());
pool.admit(udp_port_prober(target, shaping, endpoint)).await;
}
while let Ok(target) = rx.try_recv() {
record_unasked(&self.ctx, &target);
}
pool.drain().await;
finish(&self.ctx, pool.into_audit(), self.kind(), probes, reason);
Ok(())
}
}
pub async fn scan(
mut rx: mpsc::Receiver<PlannedTarget>,
concurrency_limit: usize,
ctx: ScanContext,
detection: ServiceDetection,
evasion: &EvasionProfile,
zones: &ZoneMap,
) -> Result<(), StrategyError> {
let shaping = ConnectShaping::from(evasion);
let folder = ctx.clone();
let mut pool = ProbePool::new(
concurrency_limit,
ctx.clone(),
ScannerKind::Connect,
|probed, audit: &mut ProbeAudit| absorb_probe(&folder, probed, audit),
);
let mut probes = 0u128;
let mut reason = StopReason::AttemptsSpent;
while let Some(target) = rx.recv().await {
if let Some(cause) = ctx.handle.stopped() {
reason = cause.into();
record_unasked(&ctx, &target);
break;
}
probes += 1;
if ctx.host_expired(target.ip()) {
record_unasked(&ctx, &target);
continue;
}
pool.audit().record_send(true);
let endpoint = zones.endpoint(target.ip(), target.port());
pool.admit(port_prober(target, detection, shaping, endpoint))
.await;
}
while let Ok(target) = rx.try_recv() {
record_unasked(&ctx, &target);
}
pool.drain().await;
finish(
&ctx,
pool.into_audit(),
ScannerKind::Connect,
probes,
reason,
);
Ok(())
}
fn absorb_probe(ctx: &ScanContext, probed: ProbedPort, audit: &mut ProbeAudit) {
let Some(probed) = probed else {
return;
};
ctx.record_outcome(probed.outcome);
if probed.answered {
audit.record_host_found(None);
}
if probed.port.is_none() && !probed.answered && probed.role.is_none() {
return;
}
if let Some((number, protocol)) = probed
.port
.as_ref()
.map(|port| (port.number(), port.protocol()))
{
ctx.record_responses(probed.ip.into(), number, protocol, probed.responses);
}
ctx.update_host(probed.ip, |host| {
if let Some(port) = probed.port.clone() {
host.add_port(port);
}
if let Some(role) = probed.role {
host.add_network_role(role);
}
if probed.answered {
host.record_evidence(
HostStatus::Up,
StatusReason::new(StatusProtocol::TcpSyn, "tcp connect answered by the host"),
);
}
if !probed.about_the_host.is_empty() {
probed.about_the_host.clone().apply(host);
}
});
}
fn settled(number: u16, state: PortState, reason: Option<ScanResponse>) -> Port {
let port = crate::fingerprint::baseline_port(number, Protocol::Tcp, state);
match reason {
Some(reason) => port.with_discovery(Discovery::new(reason)),
None => port,
}
}
fn record_unasked(ctx: &ScanContext, target: &PlannedTarget) {
let port =
crate::fingerprint::baseline_port(target.port(), target.protocol(), PortState::Unasked);
ctx.update_host(target.ip(), |host| {
host.add_port(port);
});
ctx.record_outcome(Outcome::Unasked);
}
async fn port_prober(
planned: PlannedTarget,
detection: ServiceDetection,
shaping: ConnectShaping,
socket_addr: SocketAddr,
) -> ProbedPort {
let target = planned.target;
if target.protocol == Protocol::Udp {
return None;
}
let position = planned.position;
match timeout(CONNECT_PROBE_TIMEOUT, connect_shaped(socket_addr, shaping))
.await
.unwrap_or_else(|_elapsed| Err(ErrorKind::TimedOut.into()))
{
Ok(stream) => {
let port = settled(target.port, PortState::Open, Some(ScanResponse::TcpSynAck));
let (port, about_the_host, responses) =
crate::fingerprint::fingerprint_tcp_detailed(stream, port, detection).await;
Some(Probed {
ip: target.ip,
port: Some(port),
responses,
about_the_host,
answered: true,
outcome: Outcome::Answered { position },
role: None,
})
}
Err(e) => {
match e.kind() {
ErrorKind::ConnectionRefused => Some(Probed {
ip: target.ip,
port: Some(settled(
target.port,
PortState::Closed,
Some(ScanResponse::TcpRst),
)),
responses: Vec::new(),
about_the_host: crate::fingerprint::AboutTheHost::default(),
answered: true,
outcome: Outcome::Answered { position },
role: None,
}),
ErrorKind::TimedOut => Some(Probed {
ip: target.ip,
port: Some(settled(
target.port,
PortState::Filtered,
Some(ScanResponse::NoResponse),
)),
responses: Vec::new(),
about_the_host: crate::fingerprint::AboutTheHost::default(),
answered: false,
outcome: Outcome::Exhausted { position },
role: None,
}),
_ => Some(Probed {
ip: target.ip,
port: Some(settled(target.port, PortState::Unasked, None)),
responses: Vec::new(),
about_the_host: crate::fingerprint::AboutTheHost::default(),
answered: false,
outcome: Outcome::Unroutable,
role: None,
}),
}
}
}
}
fn source_bind(family: IpAddr, port: u16) -> SocketAddr {
match family {
IpAddr::V4(_) => SocketAddr::new(IpAddr::V4(Ipv4Addr::UNSPECIFIED), port),
IpAddr::V6(_) => SocketAddr::new(IpAddr::V6(Ipv6Addr::UNSPECIFIED), port),
}
}
fn wildcard_for(target: IpAddr) -> SocketAddr {
source_bind(target, 0)
}
fn configure_shaping(
socket: &Socket,
family: IpAddr,
shaping: ConnectShaping,
) -> std::io::Result<()> {
if let Some(hops) = shaping.hop_limit {
match family {
IpAddr::V4(_) => socket.set_ttl_v4(hops.into())?,
IpAddr::V6(_) => socket.set_unicast_hops_v6(hops.into())?,
}
}
if shaping.source_port.is_some() {
socket.set_reuse_address(true)?;
#[cfg(unix)]
socket.set_reuse_port(true)?;
}
Ok(())
}
fn shaped_tcp_socket(target: IpAddr, shaping: ConnectShaping) -> std::io::Result<TcpSocket> {
let domain = match target {
IpAddr::V4(_) => Domain::IPV4,
IpAddr::V6(_) => Domain::IPV6,
};
let socket = Socket::new(domain, Type::STREAM, Some(socket2::Protocol::TCP))?;
configure_shaping(&socket, target, shaping)?;
#[cfg(windows)]
syn_retries::limit(&socket, target);
if let Some(port) = shaping.source_port {
socket.bind(&source_bind(target, port).into())?;
}
socket.set_nonblocking(true)?;
Ok(TcpSocket::from_std_stream(std::net::TcpStream::from(
socket,
)))
}
async fn connect_shaped(addr: SocketAddr, shaping: ConnectShaping) -> std::io::Result<TcpStream> {
if !shaping.is_active() && cfg!(not(windows)) {
return TcpStream::connect(addr).await;
}
shaped_tcp_socket(addr.ip(), shaping)?.connect(addr).await
}
async fn shaped_udp_socket(
family: IpAddr,
shaping: ConnectShaping,
) -> std::io::Result<tokio::net::UdpSocket> {
if !shaping.is_active() {
return tokio::net::UdpSocket::bind(wildcard_for(family)).await;
}
let domain = match family {
IpAddr::V4(_) => Domain::IPV4,
IpAddr::V6(_) => Domain::IPV6,
};
let socket = Socket::new(domain, Type::DGRAM, Some(socket2::Protocol::UDP))?;
configure_shaping(&socket, family, shaping)?;
socket.bind(&source_bind(family, shaping.source_port.unwrap_or(0)).into())?;
socket.set_nonblocking(true)?;
tokio::net::UdpSocket::from_std(std::net::UdpSocket::from(socket))
}
async fn udp_port_prober(
planned: PlannedTarget,
shaping: ConnectShaping,
socket_addr: SocketAddr,
) -> ProbedPort {
let target = planned.target;
if target.protocol != Protocol::Udp {
return None;
}
let position = planned.position;
let record = |state, answered, outcome| {
Some(Probed {
ip: target.ip,
port: Some(crate::fingerprint::baseline_port(
target.port,
Protocol::Udp,
state,
)),
responses: Vec::new(),
about_the_host: crate::fingerprint::AboutTheHost::default(),
answered,
outcome,
role: None,
})
};
let socket = match shaped_udp_socket(target.ip, shaping).await {
Ok(socket) => socket,
Err(e) => {
error!(
verbosity = 2,
"no UDP socket for probing {socket_addr}: {e}"
);
return record(PortState::Unasked, false, Outcome::Unroutable);
}
};
if let Err(e) = socket.connect(socket_addr).await {
error!(
verbosity = 2,
"cannot address UDP probe to {socket_addr}: {e}"
);
return record(PortState::Unasked, false, Outcome::Unroutable);
}
if let Err(e) = socket.send(payload::for_port(target.port)).await {
return match e.kind() {
ErrorKind::ConnectionRefused => {
record(PortState::Closed, false, Outcome::Answered { position })
}
_ => {
error!(
verbosity = 2,
"failed to send UDP probe to {socket_addr}: {e}"
);
record(PortState::Unasked, false, Outcome::Unroutable)
}
};
}
let mut buf = [0u8; 1024];
match timeout(CONNECT_PROBE_TIMEOUT, socket.recv(&mut buf)).await {
Ok(Ok(read)) => {
record(PortState::Open, true, Outcome::Answered { position }).map(|probed| Probed {
role: payload::declared_role(target.port, &buf[..read]),
..probed
})
}
Ok(Err(e)) if e.kind() == ErrorKind::ConnectionRefused => {
record(PortState::Closed, false, Outcome::Answered { position })
}
Ok(Err(e)) => {
error!(
verbosity = 2,
"UDP probe to {socket_addr} failed after sending: {e}"
);
record(PortState::OpenFiltered, false, Outcome::Unroutable)
}
Err(_) => record(
PortState::OpenFiltered,
false,
Outcome::Exhausted { position },
),
}
}
fn finish(
ctx: &ScanContext,
audit: ProbeAudit,
scanner: ScannerKind,
probes: u128,
reason: StopReason,
) {
audit.report("connect", probes, reason, None, None);
ctx.record_probe_stats(audit.stats(scanner, probes, reason, None, None));
}
pub async fn discover(
ips: IpSet,
ctx: ScanContext,
evasion: &EvasionProfile,
) -> Result<(), StrategyError> {
let shaping = ConnectShaping::from(evasion);
let ports: Arc<[u16]> = PortSet::common_discovery()
.iter()
.map(|(port, _)| port)
.collect::<Vec<_>>()
.into();
let mut rx = dispatch_addresses(ips, 1024, ctx.order_seed, &ctx.handle);
let folder = ctx.clone();
let mut pool = ProbePool::new(
DISCOVERY_CONCURRENCY,
ctx.clone(),
ScannerKind::Connect,
|probed, audit: &mut ProbeAudit| absorb_host(&folder, probed, audit),
);
let mut probes = 0u128;
let mut reason = StopReason::AttemptsSpent;
while let Some(ip) = rx.recv().await {
if let Some(cause) = ctx.handle.stopped() {
reason = cause.into();
ctx.record_outcome(Outcome::Unasked);
break;
}
probes += 1;
pool.audit().record_send(true);
pool.admit(prober(ip, Arc::clone(&ports), ctx.handle.clone(), shaping))
.await;
}
while rx.try_recv().is_ok() {
ctx.record_outcome(Outcome::Unasked);
}
pool.drain().await;
finish(
&ctx,
pool.into_audit(),
ScannerKind::Connect,
probes,
reason,
);
Ok(())
}
struct ProbedHost {
ip: IpAddr,
fate: Fate,
}
enum Fate {
Answered(Box<Host>),
Exhausted,
Unroutable,
Interrupted,
Unasked,
}
fn absorb_host(ctx: &ScanContext, probed: ProbedHost, audit: &mut ProbeAudit) {
match probed.fate {
Fate::Answered(host) => {
let ip = host.primary_ip();
audit.record_host_found(None);
ctx.settle_address(probed.ip, Settled::Answered);
ctx.update_host(ip, |existing| existing.merge(*host));
}
Fate::Exhausted => ctx.settle_address(probed.ip, Settled::Exhausted),
Fate::Unroutable => ctx.record_outcome(Outcome::Unroutable),
Fate::Interrupted => ctx.record_outcome(Outcome::Interrupted),
Fate::Unasked => ctx.record_outcome(Outcome::Unasked),
}
}
async fn prober(
ip: IpAddr,
ports: Arc<[u16]>,
handle: ScanHandle,
shaping: ConnectShaping,
) -> ProbedHost {
let start = Instant::now();
let mut asked = false;
for &port in ports.iter() {
if handle.should_stop() {
return ProbedHost {
ip,
fate: if asked {
Fate::Interrupted
} else {
Fate::Unasked
},
};
}
let attempt = timeout(
CONNECT_PROBE_TIMEOUT,
connect_shaped(SocketAddr::new(ip, port), shaping),
)
.await
.unwrap_or_else(|_elapsed| Err(ErrorKind::TimedOut.into()));
match attempt {
Ok(_) => return answered(ip, start),
Err(e) => match e.kind() {
ErrorKind::ConnectionRefused
| ErrorKind::ConnectionReset
| ErrorKind::ConnectionAborted => return answered(ip, start),
ErrorKind::TimedOut => asked = true,
_ => {}
},
}
}
ProbedHost {
ip,
fate: if asked {
Fate::Exhausted
} else {
Fate::Unroutable
},
}
}
fn answered(ip: IpAddr, start: Instant) -> ProbedHost {
let mut host = Host::new(ip);
host.add_rtt_from(start.elapsed(), StatusProtocol::TcpSyn);
host.record_evidence(
HostStatus::Up,
StatusReason::new(StatusProtocol::TcpSyn, "tcp connect answered by the host"),
);
ProbedHost {
ip,
fate: Fate::Answered(Box::new(host)),
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::model::target::Target;
use tokio::net::UdpSocket;
fn udp_target(ip: IpAddr, port: u16) -> PlannedTarget {
PlannedTarget::new(
u64::from(port),
Target {
ip,
port,
protocol: Protocol::Udp,
},
)
}
async fn closed_loopback_udp_port(ip: IpAddr) -> u16 {
let socket = UdpSocket::bind((ip, 0)).await.expect("bind to reserve");
let port = socket.local_addr().expect("reserved addr").port();
drop(socket);
port
}
#[test]
fn probe_socket_binds_the_target_family() {
assert!(wildcard_for(IpAddr::V4(Ipv4Addr::LOCALHOST)).is_ipv4());
assert!(wildcard_for(IpAddr::V6(Ipv6Addr::LOCALHOST)).is_ipv6());
}
#[tokio::test]
async fn closed_ipv6_port_is_classified_not_dropped() {
let ip = IpAddr::V6(Ipv6Addr::LOCALHOST);
let port = closed_loopback_udp_port(ip).await;
let probed = udp_port_prober(
udp_target(ip, port),
ConnectShaping::default(),
SocketAddr::new(ip, port),
)
.await;
let probed = probed.expect("an IPv6 target must produce a verdict");
let probed_port = probed.port.expect("a closed port is still a verdict");
assert_eq!(probed.ip, ip);
assert_eq!(probed_port.number(), port);
assert_eq!(probed_port.state(), PortState::Closed);
}
#[tokio::test]
async fn closed_ipv4_port_is_closed() {
let ip = IpAddr::V4(Ipv4Addr::LOCALHOST);
let port = closed_loopback_udp_port(ip).await;
let probed = udp_port_prober(
udp_target(ip, port),
ConnectShaping::default(),
SocketAddr::new(ip, port),
)
.await;
assert_eq!(
probed
.and_then(|probed| probed.port)
.expect("a verdict")
.state(),
PortState::Closed
);
}
#[tokio::test]
async fn a_listener_that_answers_is_open() {
for ip in [
IpAddr::V4(Ipv4Addr::LOCALHOST),
IpAddr::V6(Ipv6Addr::LOCALHOST),
] {
let service = UdpSocket::bind((ip, 0)).await.expect("bind service");
let port = service.local_addr().unwrap().port();
tokio::spawn(async move {
let mut buf = [0u8; 64];
if let Ok((_, from)) = service.recv_from(&mut buf).await {
let _ = service.send_to(b"pong", from).await;
}
});
let probed = udp_port_prober(
udp_target(ip, port),
ConnectShaping::default(),
SocketAddr::new(ip, port),
)
.await;
assert_eq!(
probed
.and_then(|probed| probed.port)
.expect("a verdict")
.state(),
PortState::Open,
"a live {ip} listener must read as open"
);
}
}
#[tokio::test]
async fn tcp_targets_are_skipped() {
let target = PlannedTarget::new(
0,
Target {
ip: IpAddr::V4(Ipv4Addr::LOCALHOST),
port: 80,
protocol: Protocol::Tcp,
},
);
assert!(
udp_port_prober(
target,
ConnectShaping::default(),
SocketAddr::new(target.ip(), target.port()),
)
.await
.is_none()
);
}
#[test]
fn the_profile_maps_onto_what_a_connect_can_carry() {
let profile = EvasionProfile {
source_port: Some(53),
ttl: Some(12),
..Default::default()
};
let shaping = ConnectShaping::from(&profile);
assert_eq!(shaping.source_port, Some(53));
assert_eq!(shaping.hop_limit, Some(12));
assert!(shaping.is_active());
assert!(!ConnectShaping::from(&EvasionProfile::default()).is_active());
}
#[tokio::test]
async fn a_shaped_connect_pins_its_source_port_and_hop_limit() {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
.expect("a loopback listener");
let addr = listener.local_addr().expect("its address");
const PINNED: u16 = 40_517;
const HOPS: u8 = 9;
let shaping = ConnectShaping {
source_port: Some(PINNED),
hop_limit: Some(HOPS),
};
let accept = tokio::spawn(async move { listener.accept().await });
let stream = connect_shaped(addr, shaping)
.await
.expect("the shaped connect completes");
let (_accepted, peer) = accept
.await
.expect("the accept task joins")
.expect("an accept");
assert_eq!(
peer.port(),
PINNED,
"the SYN left from the pinned source port"
);
assert_eq!(
stream.ttl().expect("the socket's hop limit"),
u32::from(HOPS),
"the SYN carried the chosen hop limit"
);
}
#[tokio::test]
async fn a_shaped_udp_probe_pins_its_source_port() {
let server = UdpSocket::bind("127.0.0.1:0")
.await
.expect("a loopback server");
let server_addr = server.local_addr().expect("its address");
const PINNED: u16 = 40_619;
let shaping = ConnectShaping {
source_port: Some(PINNED),
hop_limit: None,
};
let socket = shaped_udp_socket(IpAddr::V4(Ipv4Addr::LOCALHOST), shaping)
.await
.expect("a shaped UDP socket");
socket
.connect(server_addr)
.await
.expect("addressing the peer");
socket.send(b"probe").await.expect("sending the probe");
let mut buf = [0u8; 8];
let (_read, from) = server
.recv_from(&mut buf)
.await
.expect("the datagram arrives");
assert_eq!(
from.port(),
PINNED,
"the datagram left from the pinned source port"
);
}
}