662 lines
20 KiB
Rust
662 lines
20 KiB
Rust
use crate::libs::args::{Config, Family, Output, Padding};
|
|
use rand::{distributions::Alphanumeric, Rng};
|
|
use socket2::{Domain, Protocol, Socket, Type};
|
|
use std::{
|
|
io,
|
|
net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, ToSocketAddrs, UdpSocket},
|
|
thread,
|
|
time::{Duration, Instant},
|
|
};
|
|
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
|
enum Version {
|
|
V4,
|
|
V6,
|
|
}
|
|
impl Version {
|
|
fn request_type(self) -> u8 {
|
|
match self {
|
|
Self::V4 => 8,
|
|
Self::V6 => 128,
|
|
}
|
|
}
|
|
fn reply_type(self) -> u8 {
|
|
match self {
|
|
Self::V4 => 0,
|
|
Self::V6 => 129,
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn generate_ping_request(config: Config) -> io::Result<()> {
|
|
config.validate()?;
|
|
let payload = config.payload_bytes()?;
|
|
let size = config.packet_size(payload.len())?;
|
|
let destination = if config.dry_run {
|
|
// Dry runs do not perform DNS or create sockets. Literal addresses determine the family.
|
|
config
|
|
.dest_addr
|
|
.parse::<IpAddr>()
|
|
.ok()
|
|
.map(|ip| SocketAddr::new(ip, 0))
|
|
} else {
|
|
Some(resolve_destination(&config)?)
|
|
};
|
|
let version = match destination.map(|addr| addr.ip()) {
|
|
Some(IpAddr::V4(_)) => Version::V4,
|
|
Some(IpAddr::V6(_)) => Version::V6,
|
|
None => match config.family {
|
|
Family::V6 => Version::V6,
|
|
_ => Version::V4,
|
|
},
|
|
};
|
|
if matches!(
|
|
(config.family, version),
|
|
(Family::V4, Version::V6) | (Family::V6, Version::V4)
|
|
) {
|
|
return Err(io::Error::new(
|
|
io::ErrorKind::InvalidInput,
|
|
"destination and --family disagree",
|
|
));
|
|
}
|
|
let ty = config.ping_type.unwrap_or(version.request_type());
|
|
if config.code != 0 && ty == version.request_type() {
|
|
return Err(io::Error::new(
|
|
io::ErrorKind::InvalidInput,
|
|
"echo requests require code 0",
|
|
));
|
|
}
|
|
if !config.raw && !config.dry_run && (ty != version.request_type() || config.code != 0) {
|
|
return Err(io::Error::new(
|
|
io::ErrorKind::InvalidInput,
|
|
"custom type or code requires --raw",
|
|
));
|
|
}
|
|
let socket = if config.dry_run {
|
|
None
|
|
} else {
|
|
let socket = Socket::new(
|
|
match version {
|
|
Version::V4 => Domain::IPV4,
|
|
Version::V6 => Domain::IPV6,
|
|
},
|
|
if config.raw { Type::RAW } else { Type::DGRAM },
|
|
Some(match version {
|
|
Version::V4 => Protocol::ICMPV4,
|
|
Version::V6 => Protocol::ICMPV6,
|
|
}),
|
|
)?;
|
|
if let Some(ttl) = config.ttl {
|
|
match version {
|
|
Version::V4 => socket.set_ttl_v4(u32::from(ttl))?,
|
|
Version::V6 => socket.set_unicast_hops_v6(u32::from(ttl))?,
|
|
}
|
|
}
|
|
let bind_addr = match version {
|
|
Version::V4 => SocketAddr::from((Ipv4Addr::UNSPECIFIED, 0)),
|
|
Version::V6 => SocketAddr::from((Ipv6Addr::UNSPECIFIED, 0)),
|
|
};
|
|
socket.bind(&bind_addr.into())?;
|
|
Some(UdpSocket::from(socket))
|
|
};
|
|
let mut results = Vec::new();
|
|
let run_start = Instant::now();
|
|
for index in 0..config.count {
|
|
if index > 0 && !config.dry_run {
|
|
let scheduled =
|
|
run_start + Duration::from_millis(config.interval_ms).saturating_mul(index);
|
|
if let Some(delay) = scheduled.checked_duration_since(Instant::now()) {
|
|
thread::sleep(delay);
|
|
}
|
|
}
|
|
let seq = config.sequence.wrapping_add(index as u16);
|
|
let packet = create_buffer(
|
|
ty,
|
|
config.code,
|
|
config.identifier,
|
|
seq,
|
|
&payload,
|
|
size,
|
|
config.padding,
|
|
version,
|
|
)?;
|
|
let result = if let (Some(socket), Some(destination)) = (&socket, destination) {
|
|
probe(socket, destination, &packet, seq, &config, version)?
|
|
} else {
|
|
ProbeResult::DryRun
|
|
};
|
|
render_probe(&config, index, seq, &packet, &result);
|
|
results.push(result);
|
|
}
|
|
render_summary(&config, &results);
|
|
if results
|
|
.iter()
|
|
.all(|r| matches!(r, ProbeResult::Echo { .. } | ProbeResult::DryRun))
|
|
{
|
|
Ok(())
|
|
} else {
|
|
Err(io::Error::new(
|
|
io::ErrorKind::Other,
|
|
"one or more probes did not receive a matching reply",
|
|
))
|
|
}
|
|
}
|
|
|
|
fn resolve_destination(config: &Config) -> io::Result<SocketAddr> {
|
|
(config.dest_addr.as_str(), 0)
|
|
.to_socket_addrs()?
|
|
.find(|addr| match config.family {
|
|
Family::Auto => true,
|
|
Family::V4 => addr.is_ipv4(),
|
|
Family::V6 => addr.is_ipv6(),
|
|
})
|
|
.ok_or_else(|| {
|
|
io::Error::new(
|
|
io::ErrorKind::InvalidInput,
|
|
"destination has no address in the requested family",
|
|
)
|
|
})
|
|
}
|
|
|
|
enum ProbeResult {
|
|
DryRun,
|
|
Echo {
|
|
source: IpAddr,
|
|
bytes: usize,
|
|
elapsed: Duration,
|
|
response: Vec<u8>,
|
|
},
|
|
Error {
|
|
source: IpAddr,
|
|
ty: u8,
|
|
code: u8,
|
|
response: Vec<u8>,
|
|
},
|
|
Timeout,
|
|
}
|
|
|
|
fn probe(
|
|
socket: &UdpSocket,
|
|
destination: SocketAddr,
|
|
packet: &[u8],
|
|
seq: u16,
|
|
config: &Config,
|
|
version: Version,
|
|
) -> io::Result<ProbeResult> {
|
|
let start = Instant::now();
|
|
let sent = socket.send_to(packet, destination)?;
|
|
if sent != packet.len() {
|
|
return Err(io::Error::new(
|
|
io::ErrorKind::WriteZero,
|
|
"partial ICMP packet send",
|
|
));
|
|
}
|
|
let expected_id = if config.raw {
|
|
config.identifier
|
|
} else {
|
|
socket.local_addr()?.port()
|
|
};
|
|
let deadline = start + config.timeout();
|
|
let mut buf = vec![0; 65535];
|
|
loop {
|
|
let Some(remaining) = deadline
|
|
.checked_duration_since(Instant::now())
|
|
.filter(|d| !d.is_zero())
|
|
else {
|
|
return Ok(ProbeResult::Timeout);
|
|
};
|
|
socket.set_read_timeout(Some(remaining))?;
|
|
let (length, source) = match socket.recv_from(&mut buf) {
|
|
Ok(value) => value,
|
|
Err(e)
|
|
if matches!(
|
|
e.kind(),
|
|
io::ErrorKind::WouldBlock | io::ErrorKind::TimedOut
|
|
) =>
|
|
{
|
|
return Ok(ProbeResult::Timeout);
|
|
}
|
|
Err(e) => return Err(e),
|
|
};
|
|
let Some(icmp) = received_icmp(&buf[..length], config.raw && version == Version::V4) else {
|
|
continue;
|
|
};
|
|
match classify_response(
|
|
icmp,
|
|
source.ip(),
|
|
destination.ip(),
|
|
expected_id,
|
|
seq,
|
|
&packet[8..],
|
|
version,
|
|
) {
|
|
Response::Ignore => continue,
|
|
Response::Echo => {
|
|
return Ok(ProbeResult::Echo {
|
|
source: source.ip(),
|
|
bytes: icmp.len(),
|
|
elapsed: start.elapsed(),
|
|
response: icmp.to_vec(),
|
|
});
|
|
}
|
|
Response::Error(ty, code) => {
|
|
return Ok(ProbeResult::Error {
|
|
source: source.ip(),
|
|
ty,
|
|
code,
|
|
response: icmp.to_vec(),
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn received_icmp(packet: &[u8], raw_ipv4: bool) -> Option<&[u8]> {
|
|
if !raw_ipv4 {
|
|
return (packet.len() >= 8).then_some(packet);
|
|
}
|
|
let first = *packet.first()?;
|
|
let header_len = usize::from(first & 0x0f) * 4;
|
|
if first >> 4 != 4 || header_len < 20 || packet.len() < header_len + 8 {
|
|
return None;
|
|
}
|
|
Some(&packet[header_len..])
|
|
}
|
|
|
|
enum Response {
|
|
Ignore,
|
|
Echo,
|
|
Error(u8, u8),
|
|
}
|
|
fn classify_response(
|
|
packet: &[u8],
|
|
source: IpAddr,
|
|
destination: IpAddr,
|
|
id: u16,
|
|
seq: u16,
|
|
sent_payload: &[u8],
|
|
version: Version,
|
|
) -> Response {
|
|
if packet.len() < 8 {
|
|
return Response::Ignore;
|
|
}
|
|
let ty = packet[0];
|
|
let code = packet[1];
|
|
let checksum_ok = version == Version::V6 || calculate_checksum(packet) == 0;
|
|
if ty == version.reply_type()
|
|
&& code == 0
|
|
&& source == destination
|
|
&& packet[4..6] == id.to_be_bytes()
|
|
&& packet[6..8] == seq.to_be_bytes()
|
|
&& packet[8..] == *sent_payload
|
|
&& checksum_ok
|
|
{
|
|
return Response::Echo;
|
|
}
|
|
let is_error = match version {
|
|
Version::V4 => matches!(ty, 3 | 11 | 12),
|
|
Version::V6 => matches!(ty, 1..=4),
|
|
};
|
|
if is_error && checksum_ok && quoted_probe_matches(&packet[8..], destination, id, seq, version)
|
|
{
|
|
return Response::Error(ty, code);
|
|
}
|
|
Response::Ignore
|
|
}
|
|
|
|
fn quoted_probe_matches(
|
|
quoted: &[u8],
|
|
destination: IpAddr,
|
|
id: u16,
|
|
seq: u16,
|
|
version: Version,
|
|
) -> bool {
|
|
let embedded = match (version, destination) {
|
|
(Version::V4, IpAddr::V4(ip)) if quoted.len() >= 28 && quoted[16..20] == ip.octets() => {
|
|
received_icmp(quoted, true)
|
|
}
|
|
(Version::V6, IpAddr::V6(ip))
|
|
if quoted.len() >= 48 && quoted[0] >> 4 == 6 && quoted[24..40] == ip.octets() =>
|
|
{
|
|
Some("ed[40..])
|
|
}
|
|
_ => None,
|
|
};
|
|
embedded.is_some_and(|p| {
|
|
p.len() >= 8
|
|
&& p[0] == version.request_type()
|
|
&& p[4..6] == id.to_be_bytes()
|
|
&& p[6..8] == seq.to_be_bytes()
|
|
})
|
|
}
|
|
|
|
#[allow(clippy::too_many_arguments)]
|
|
fn create_buffer(
|
|
ty: u8,
|
|
code: u8,
|
|
id: u16,
|
|
seq: u16,
|
|
payload: &[u8],
|
|
size: usize,
|
|
padding: Padding,
|
|
version: Version,
|
|
) -> io::Result<Vec<u8>> {
|
|
if !(8..=65515).contains(&size) || payload.len() > size - 8 {
|
|
return Err(io::Error::new(
|
|
io::ErrorKind::InvalidInput,
|
|
"invalid packet size",
|
|
));
|
|
}
|
|
let mut buf = vec![0; size];
|
|
buf[0] = ty;
|
|
buf[1] = code;
|
|
buf[4..6].copy_from_slice(&id.to_be_bytes());
|
|
buf[6..8].copy_from_slice(&seq.to_be_bytes());
|
|
buf[8..8 + payload.len()].copy_from_slice(payload);
|
|
if matches!(padding, Padding::Random)
|
|
|| (matches!(padding, Padding::Auto) && payload.is_empty())
|
|
{
|
|
let mut rng = rand::thread_rng();
|
|
for byte in &mut buf[8 + payload.len()..] {
|
|
*byte = rng.sample(Alphanumeric);
|
|
}
|
|
}
|
|
if version == Version::V4 {
|
|
let checksum = calculate_checksum(&buf);
|
|
buf[2..4].copy_from_slice(&checksum.to_be_bytes());
|
|
}
|
|
// Linux ICMPv6 sockets calculate the mandatory pseudo-header checksum.
|
|
Ok(buf)
|
|
}
|
|
|
|
fn calculate_checksum(buf: &[u8]) -> u16 {
|
|
let mut sum = 0u32;
|
|
for chunk in buf.chunks(2) {
|
|
sum += u32::from(u16::from_be_bytes([chunk[0], *chunk.get(1).unwrap_or(&0)]));
|
|
}
|
|
while sum >> 16 != 0 {
|
|
sum = (sum & 0xffff) + (sum >> 16);
|
|
}
|
|
!(sum as u16)
|
|
}
|
|
|
|
fn hex_bytes(bytes: &[u8]) -> String {
|
|
bytes.iter().map(|b| format!("{b:02x}")).collect()
|
|
}
|
|
fn json_string(value: &str) -> String {
|
|
let mut out = String::from("\"");
|
|
for ch in value.chars() {
|
|
match ch {
|
|
'"' => out.push_str("\\\""),
|
|
'\\' => out.push_str("\\\\"),
|
|
'\n' => out.push_str("\\n"),
|
|
'\r' => out.push_str("\\r"),
|
|
'\t' => out.push_str("\\t"),
|
|
c if c <= '\u{001f}' => out.push_str(&format!("\\u{:04x}", c as u32)),
|
|
c => out.push(c),
|
|
}
|
|
}
|
|
out.push('"');
|
|
out
|
|
}
|
|
fn render_probe(config: &Config, index: u32, seq: u16, packet: &[u8], result: &ProbeResult) {
|
|
match config.output {
|
|
Output::Summary => println!("{}", probe_line(index, seq, result)),
|
|
Output::Hex => {
|
|
println!("[PROBE {}] sequence {}", index + 1, seq);
|
|
print!(
|
|
"{}",
|
|
rhexdump::hexdump::RhexdumpString::new().hexdump_bytes(packet)
|
|
);
|
|
match result {
|
|
ProbeResult::Echo { response, .. } | ProbeResult::Error { response, .. } => {
|
|
print!(
|
|
"{}",
|
|
rhexdump::hexdump::RhexdumpString::new().hexdump_bytes(response)
|
|
)
|
|
}
|
|
_ => {}
|
|
}
|
|
println!("{}", probe_line(index, seq, result));
|
|
}
|
|
Output::Json => {
|
|
let (status, source, elapsed, response, error) = match result {
|
|
ProbeResult::DryRun => ("dry_run", None, None, None, None),
|
|
ProbeResult::Timeout => ("timeout", None, None, None, None),
|
|
ProbeResult::Echo {
|
|
source,
|
|
elapsed,
|
|
response,
|
|
..
|
|
} => (
|
|
"reply",
|
|
Some(source.to_string()),
|
|
Some(elapsed.as_secs_f64() * 1000.0),
|
|
Some(hex_bytes(response)),
|
|
None,
|
|
),
|
|
ProbeResult::Error {
|
|
source,
|
|
ty,
|
|
code,
|
|
response,
|
|
} => (
|
|
"icmp_error",
|
|
Some(source.to_string()),
|
|
None,
|
|
Some(hex_bytes(response)),
|
|
Some((*ty, *code)),
|
|
),
|
|
};
|
|
println!(
|
|
"{{\"kind\":\"probe\",\"index\":{},\"sequence\":{},\"status\":{},\"destination\":{},\"source\":{},\"elapsed_ms\":{},\"sent_hex\":{},\"received_hex\":{},\"icmp_type\":{},\"icmp_code\":{}}}",
|
|
index + 1,
|
|
seq,
|
|
json_string(status),
|
|
json_string(&config.dest_addr),
|
|
source
|
|
.as_deref()
|
|
.map(json_string)
|
|
.unwrap_or_else(|| "null".into()),
|
|
elapsed
|
|
.map(|ms| ms.to_string())
|
|
.unwrap_or_else(|| "null".into()),
|
|
json_string(&hex_bytes(packet)),
|
|
response
|
|
.as_deref()
|
|
.map(json_string)
|
|
.unwrap_or_else(|| "null".into()),
|
|
error
|
|
.map(|e| e.0.to_string())
|
|
.unwrap_or_else(|| "null".into()),
|
|
error
|
|
.map(|e| e.1.to_string())
|
|
.unwrap_or_else(|| "null".into())
|
|
);
|
|
}
|
|
}
|
|
}
|
|
fn probe_line(index: u32, seq: u16, result: &ProbeResult) -> String {
|
|
match result {
|
|
ProbeResult::DryRun => format!("probe {} seq={} dry run", index + 1, seq),
|
|
ProbeResult::Timeout => format!("probe {} seq={} timed out", index + 1, seq),
|
|
ProbeResult::Echo {
|
|
source,
|
|
bytes,
|
|
elapsed,
|
|
..
|
|
} => format!(
|
|
"probe {} seq={} reply from {}: {} bytes in {:.2} ms",
|
|
index + 1,
|
|
seq,
|
|
source,
|
|
bytes,
|
|
elapsed.as_secs_f64() * 1000.0
|
|
),
|
|
ProbeResult::Error {
|
|
source, ty, code, ..
|
|
} => format!(
|
|
"probe {} seq={} ICMP error from {}: type {}, code {}",
|
|
index + 1,
|
|
seq,
|
|
source,
|
|
ty,
|
|
code
|
|
),
|
|
}
|
|
}
|
|
fn render_summary(config: &Config, results: &[ProbeResult]) {
|
|
let sent = results.len();
|
|
let received = results
|
|
.iter()
|
|
.filter(|r| matches!(r, ProbeResult::Echo { .. }))
|
|
.count();
|
|
let errors = results
|
|
.iter()
|
|
.filter(|r| matches!(r, ProbeResult::Error { .. }))
|
|
.count();
|
|
let dry = results
|
|
.iter()
|
|
.filter(|r| matches!(r, ProbeResult::DryRun))
|
|
.count();
|
|
let rtts: Vec<f64> = results
|
|
.iter()
|
|
.filter_map(|r| {
|
|
if let ProbeResult::Echo { elapsed, .. } = r {
|
|
Some(elapsed.as_secs_f64() * 1000.0)
|
|
} else {
|
|
None
|
|
}
|
|
})
|
|
.collect();
|
|
let stats = if rtts.is_empty() {
|
|
None
|
|
} else {
|
|
Some((
|
|
rtts.iter().copied().fold(f64::INFINITY, f64::min),
|
|
rtts.iter().sum::<f64>() / rtts.len() as f64,
|
|
rtts.iter().copied().fold(0.0, f64::max),
|
|
))
|
|
};
|
|
match config.output {
|
|
Output::Json => println!(
|
|
"{{\"kind\":\"summary\",\"sent\":{sent},\"received\":{received},\"errors\":{errors},\"dry_run\":{dry},\"rtt_min_ms\":{},\"rtt_avg_ms\":{},\"rtt_max_ms\":{}}}",
|
|
stats
|
|
.map(|s| s.0.to_string())
|
|
.unwrap_or_else(|| "null".into()),
|
|
stats
|
|
.map(|s| s.1.to_string())
|
|
.unwrap_or_else(|| "null".into()),
|
|
stats
|
|
.map(|s| s.2.to_string())
|
|
.unwrap_or_else(|| "null".into())
|
|
),
|
|
_ => {
|
|
println!("{sent} probes, {received} replies, {errors} ICMP errors, {dry} dry runs");
|
|
if let Some((min, avg, max)) = stats {
|
|
println!("RTT min/avg/max = {min:.2}/{avg:.2}/{max:.2} ms");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use std::net::IpAddr;
|
|
#[test]
|
|
fn checksum_and_exact_payload() {
|
|
assert_eq!(
|
|
calculate_checksum(&[0, 1, 0xf2, 3, 0xf4, 0xf5, 0xf6, 0xf7]),
|
|
0x220d
|
|
);
|
|
let packet = create_buffer(
|
|
8,
|
|
0,
|
|
0x1234,
|
|
7,
|
|
&[0, 0xff, 0x01],
|
|
11,
|
|
Padding::None,
|
|
Version::V4,
|
|
)
|
|
.unwrap();
|
|
assert_eq!(&packet[8..], &[0, 0xff, 0x01]);
|
|
assert_eq!(calculate_checksum(&packet), 0);
|
|
}
|
|
#[test]
|
|
fn matches_only_the_sent_reply() {
|
|
let destination: IpAddr = "127.0.0.1".parse().unwrap();
|
|
let mut reply = create_buffer(0, 0, 4, 9, b"abc", 11, Padding::None, Version::V4).unwrap();
|
|
assert!(matches!(
|
|
classify_response(&reply, destination, destination, 4, 9, b"abc", Version::V4),
|
|
Response::Echo
|
|
));
|
|
assert!(matches!(
|
|
classify_response(&reply, destination, destination, 4, 10, b"abc", Version::V4),
|
|
Response::Ignore
|
|
));
|
|
reply[8] = b'z';
|
|
assert!(matches!(
|
|
classify_response(&reply, destination, destination, 4, 9, b"abc", Version::V4),
|
|
Response::Ignore
|
|
));
|
|
}
|
|
#[test]
|
|
fn malformed_raw_header_is_ignored() {
|
|
assert!(received_icmp(&[], true).is_none());
|
|
assert!(received_icmp(&[0; 7], false).is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn recognizes_quoted_probe_in_router_error() {
|
|
let destination: IpAddr = "192.0.2.1".parse().unwrap();
|
|
let router: IpAddr = "192.0.2.254".parse().unwrap();
|
|
let mut error = vec![0u8; 8 + 20 + 8];
|
|
error[0] = 3;
|
|
error[8] = 0x45;
|
|
error[8 + 16..8 + 20].copy_from_slice(&[192, 0, 2, 1]);
|
|
error[28] = 8;
|
|
error[32..34].copy_from_slice(&4u16.to_be_bytes());
|
|
error[34..36].copy_from_slice(&9u16.to_be_bytes());
|
|
let checksum = calculate_checksum(&error);
|
|
error[2..4].copy_from_slice(&checksum.to_be_bytes());
|
|
assert!(matches!(
|
|
classify_response(&error, router, destination, 4, 9, &[], Version::V4),
|
|
Response::Error(3, 0)
|
|
));
|
|
assert!(matches!(
|
|
classify_response(&error, router, destination, 4, 10, &[], Version::V4),
|
|
Response::Ignore
|
|
));
|
|
}
|
|
|
|
#[test]
|
|
fn ipv6_reply_and_quoted_error_match() {
|
|
let destination: IpAddr = "2001:db8::1".parse().unwrap();
|
|
let router: IpAddr = "2001:db8::ff".parse().unwrap();
|
|
let reply = create_buffer(129, 0, 4, 9, b"abc", 11, Padding::None, Version::V6).unwrap();
|
|
assert!(matches!(
|
|
classify_response(&reply, destination, destination, 4, 9, b"abc", Version::V6),
|
|
Response::Echo
|
|
));
|
|
assert!(matches!(
|
|
classify_response(&reply, router, destination, 4, 9, b"abc", Version::V6),
|
|
Response::Ignore
|
|
));
|
|
let mut error = vec![0u8; 8 + 40 + 8];
|
|
error[0] = 1;
|
|
error[8] = 0x60;
|
|
error[8 + 24..8 + 40].copy_from_slice(&match destination {
|
|
IpAddr::V6(ip) => ip.octets(),
|
|
_ => unreachable!(),
|
|
});
|
|
error[48] = 128;
|
|
error[52..54].copy_from_slice(&4u16.to_be_bytes());
|
|
error[54..56].copy_from_slice(&9u16.to_be_bytes());
|
|
assert!(matches!(
|
|
classify_response(&error, router, destination, 4, 9, b"abc", Version::V6),
|
|
Response::Error(1, 0)
|
|
));
|
|
}
|
|
}
|