use std::collections::{BTreeMap, HashSet};
use std::ffi::CStr;
use std::fs;
use std::net::{Ipv4Addr, UdpSocket};
use std::sync::mpsc::{self, Receiver, Sender, TryRecvError};
use std::thread;
use std::time::{Duration, Instant};
use if_addrs::{get_if_addrs, IfAddr};
const KEEP_ALIVE: Duration = Duration::from_secs(600);
pub const DEFAULT_SWEEP_INTERVAL: Duration = Duration::from_secs(60);
const MAX_CONCURRENT_RESOLVES: usize = 16;
#[derive(Clone, Copy, PartialEq, Eq)]
#[derive(Debug)]
pub enum LanSort {
Ip,
Hostname,
Mac,
Iface,
}
impl LanSort {
pub fn next(self) -> Self {
match self {
Self::Ip => Self::Hostname,
Self::Hostname => Self::Mac,
Self::Mac => Self::Iface,
Self::Iface => Self::Ip,
}
}
pub fn label(self) -> &'static str {
match self {
Self::Ip => "ip",
Self::Hostname => "host",
Self::Mac => "mac",
Self::Iface => "iface",
}
}
}
#[derive(Clone)]
pub struct Neighbor {
pub ip: Ipv4Addr,
pub mac: Option<String>,
pub iface: String,
pub complete: bool,
pub hostname: Option<String>,
pub is_gateway: bool,
pub is_self: bool,
pub last_seen: Instant,
}
pub struct LanCollector {
pub neighbors: BTreeMap<Ipv4Addr, Neighbor>,
pub tracked: HashSet<Ipv4Addr>,
pub subnets: Vec<(String, Ipv4Addr, u8)>,
pub own_ips: HashSet<Ipv4Addr>,
pub gateways: HashSet<Ipv4Addr>,
pub sort: LanSort,
pub sweep_interval: Duration,
pub sweep_enabled: bool,
pub sweeping: bool,
pub last_sweep: Option<Instant>,
pub resolve_failures: HashSet<Ipv4Addr>,
resolving: HashSet<Ipv4Addr>,
hostname_tx: Sender<(Ipv4Addr, Option<String>)>,
hostname_rx: Receiver<(Ipv4Addr, Option<String>)>,
sweep_done_rx: Option<Receiver<()>>,
}
const NON_LAN_IFACE_PREFIXES: [&str; 4] = ["docker", "br-", "veth", "virbr"];
impl LanCollector {
pub fn new() -> Self {
let (tx, rx) = mpsc::channel();
Self {
neighbors: BTreeMap::new(),
tracked: std::collections::HashSet::new(),
subnets: Vec::new(),
own_ips: HashSet::new(),
gateways: HashSet::new(),
sort: LanSort::Ip,
sweep_interval: DEFAULT_SWEEP_INTERVAL,
sweep_enabled: true,
sweeping: false,
last_sweep: None,
resolve_failures: HashSet::new(),
resolving: HashSet::new(),
hostname_tx: tx,
hostname_rx: rx,
sweep_done_rx: None,
}
}
pub fn sample(&mut self) {
let now = Instant::now();
self.refresh_subnets();
self.read_gateways();
self.read_arp(now);
self.prune(now);
self.spawn_resolves();
self.drain_hostnames();
self.maybe_sweep(now);
}
fn refresh_subnets(&mut self) {
self.subnets.clear();
self.own_ips.clear();
let Ok(list) = get_if_addrs() else {
return;
};
for ifa in list {
let IfAddr::V4(v4) = ifa.addr else {
continue;
};
self.own_ips.insert(v4.ip);
if NON_LAN_IFACE_PREFIXES.iter().any(|p| ifa.name.starts_with(p)) {
continue;
}
let mask = u32::from(v4.netmask);
if !v4.ip.is_private() && !v4.ip.is_link_local() {
continue;
}
let net = Ipv4Addr::from(u32::from(v4.ip) & mask);
let prefix = mask.count_ones() as u8;
if !self
.subnets
.iter()
.any(|(_, n, p)| *n == net && *p == prefix)
{
self.subnets.push((ifa.name, net, prefix));
}
}
self.subnets.sort();
}
fn read_gateways(&mut self) {
self.gateways.clear();
let Ok(content) = fs::read_to_string("/proc/net/route") else {
return;
};
for line in content.lines().skip(1) {
let cols: Vec<&str> = line.split_whitespace().collect();
if cols.len() >= 4 && cols[1] == "00000000" {
if let Ok(raw) = u32::from_str_radix(cols[2], 16) {
self.gateways.insert(Ipv4Addr::from(u32::from_be(raw)));
}
}
}
}
fn read_arp(&mut self, now: Instant) {
let Ok(content) = fs::read_to_string("/proc/net/arp") else {
return;
};
for line in content.lines().skip(1) {
let cols: Vec<&str> = line.split_whitespace().collect();
if cols.len() < 6 {
continue;
}
let Ok(ip) = cols[0].parse::<Ipv4Addr>() else {
continue;
};
let flags = u16::from_str_radix(cols[2].trim_start_matches("0x"), 16).unwrap_or(0);
let complete = flags & 0x2 != 0;
let mac = cols[3].to_lowercase();
let mac = if complete && mac != "00:00:00:00:00:00" {
Some(mac)
} else {
None
};
let iface = cols[5].to_string();
if iface == "lo" {
continue;
}
let is_gateway = self.gateways.contains(&ip);
let is_self = self.own_ips.contains(&ip);
match self.neighbors.get_mut(&ip) {
Some(n) => {
n.iface = iface;
n.mac = mac;
n.complete = complete;
n.is_gateway = is_gateway;
n.is_self = is_self;
n.last_seen = now;
}
None if complete => {
self.neighbors.insert(
ip,
Neighbor {
ip,
mac,
iface,
complete,
hostname: None,
is_gateway,
is_self,
last_seen: now,
},
);
}
None => {}
}
}
}
fn prune(&mut self, now: Instant) {
self.neighbors.retain(|_, n| now.duration_since(n.last_seen) < KEEP_ALIVE);
}
fn spawn_resolves(&mut self) {
let candidates: Vec<Ipv4Addr> = self
.neighbors
.values()
.filter(|n| {
n.complete
&& n.hostname.is_none()
&& !self.resolving.contains(&n.ip)
&& !self.resolve_failures.contains(&n.ip)
})
.map(|n| n.ip)
.collect();
for ip in candidates {
if self.resolving.len() >= MAX_CONCURRENT_RESOLVES {
break;
}
self.resolving.insert(ip);
let tx = self.hostname_tx.clone();
thread::spawn(move || {
let _ = tx.send((ip, resolve_any(ip)));
});
}
}
fn drain_hostnames(&mut self) {
loop {
match self.hostname_rx.try_recv() {
Ok((ip, Some(host))) => {
if let Some(n) = self.neighbors.get_mut(&ip) {
n.hostname = Some(host);
}
self.resolving.remove(&ip);
}
Ok((ip, None)) => {
self.resolving.remove(&ip);
self.resolve_failures.insert(ip);
}
Err(TryRecvError::Empty) => break,
Err(TryRecvError::Disconnected) => break,
}
}
}
fn maybe_sweep(&mut self, now: Instant) {
if let Some(rx) = &self.sweep_done_rx {
if rx.try_recv().is_ok() {
self.sweeping = false;
self.sweep_done_rx = None;
self.last_sweep = Some(now);
self.resolve_failures.clear();
}
}
if !self.sweep_enabled || self.sweeping || self.subnets.is_empty() {
return;
}
let due = self
.last_sweep
.is_none_or(|t| now.duration_since(t) >= self.sweep_interval);
if due {
self.start_sweep();
}
}
pub fn sweep_now(&mut self) {
if !self.sweeping {
self.last_sweep = None;
}
}
fn start_sweep(&mut self) {
let Some((_, net, prefix)) = self.pick_subnet() else {
return;
};
let (done_tx, done_rx) = mpsc::channel();
self.sweeping = true;
self.sweep_done_rx = Some(done_rx);
thread::spawn(move || {
for ip in host_addrs(net, prefix) {
if let Ok(sock) = UdpSocket::bind("0.0.0.0:0") {
if sock.connect((ip, 9)).is_ok() {
let _ = sock.send(&[]);
}
}
}
let _ = done_tx.send(());
});
}
fn pick_subnet(&self) -> Option<(String, Ipv4Addr, u8)> {
self.subnets
.iter()
.find(|(_, net, prefix)| {
host_range(*net, *prefix)
.any(|ip| self.gateways.contains(&ip))
})
.or_else(|| self.subnets.first())
.cloned()
}
pub fn sorted_neighbors(&self) -> Vec<&Neighbor> {
let mut list: Vec<&Neighbor> = self.neighbors.values().collect();
match self.sort {
LanSort::Ip => list.sort_by_key(|n| u32::from(n.ip)),
LanSort::Hostname => list.sort_by(|a, b| {
a.hostname
.as_deref()
.unwrap_or("")
.cmp(b.hostname.as_deref().unwrap_or(""))
.then(u32::from(a.ip).cmp(&u32::from(b.ip)))
}),
LanSort::Mac => list.sort_by(|a, b| {
a.mac.as_deref()
.unwrap_or("")
.cmp(b.mac.as_deref().unwrap_or(""))
.then(u32::from(a.ip).cmp(&u32::from(b.ip)))
}),
LanSort::Iface => list.sort_by(|a, b| {
a.iface.cmp(&b.iface).then(u32::from(a.ip).cmp(&u32::from(b.ip)))
}),
}
if !self.tracked.is_empty() {
list.sort_by_key(|n| !self.tracked.contains(&n.ip));
}
list
}
}
impl Default for LanCollector {
fn default() -> Self {
Self::new()
}
}
fn host_addrs(net: Ipv4Addr, prefix: u8) -> Vec<Ipv4Addr> {
host_range(net, prefix).collect()
}
fn host_range(net: Ipv4Addr, prefix: u8) -> impl Iterator<Item = Ipv4Addr> {
let base = u32::from(net);
let host_bits = 32 - prefix.min(32) as u32;
let start = base + 1;
let end = base | ((1u32 << host_bits) - 1);
(start..end).map(Ipv4Addr::from)
}
fn resolve_any(ip: Ipv4Addr) -> Option<String> {
resolve_mdns(ip)
.or_else(|| resolve_nbns(ip))
.or_else(|| resolve_hostname(ip))
}
const MDNS_GROUP: Ipv4Addr = Ipv4Addr::new(224, 0, 0, 251);
const MDNS_PORT: u16 = 5353;
fn resolve_mdns(ip: Ipv4Addr) -> Option<String> {
let sock = UdpSocket::bind("0.0.0.0:0").ok()?;
sock.set_read_timeout(Some(Duration::from_millis(600))).ok()?;
let query = build_ptr_query(ip, 0x6c74);
let mut buf = [0u8; 1500];
for _ in 0..2 {
sock.send_to(&query, (MDNS_GROUP, MDNS_PORT)).ok()?;
let until = Instant::now() + Duration::from_millis(600);
while Instant::now() < until {
match sock.recv_from(&mut buf) {
Ok((n, _)) => {
if let Some(name) = parse_ptr_response(&buf[..n]) {
return Some(name);
}
}
Err(e) if e.kind() == std::io::ErrorKind::WouldBlock
|| e.kind() == std::io::ErrorKind::TimedOut => continue,
Err(_) => return None,
}
}
}
None
}
fn build_ptr_query(ip: Ipv4Addr, id: u16) -> Vec<u8> {
let [a, b, c, d] = ip.octets();
let mut m = Vec::with_capacity(17 + 4 + 6);
m.extend_from_slice(&id.to_be_bytes());
m.extend_from_slice(&[0x00, 0x00]); m.extend_from_slice(&[0x00, 0x01]); m.extend_from_slice(&[0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);
for label in [d.to_string(), c.to_string(), b.to_string(), a.to_string(), "in-addr".into(), "arpa".into()] {
m.push(label.len() as u8);
m.extend_from_slice(label.as_bytes());
}
m.push(0);
m.extend_from_slice(&12u16.to_be_bytes()); m.extend_from_slice(&1u16.to_be_bytes()); m
}
fn parse_ptr_response(buf: &[u8]) -> Option<String> {
if buf.len() < 12 {
return None;
}
let flags = u16::from_be_bytes([buf[2], buf[3]]);
if flags & 0x8000 == 0 {
return None; }
let qd = u16::from_be_bytes([buf[4], buf[5]]) as usize;
let an = u16::from_be_bytes([buf[6], buf[7]]) as usize;
let mut i = 12usize;
for _ in 0..qd {
read_name(buf, &mut i)?;
i += 4;
}
for _ in 0..an {
read_name(buf, &mut i)?;
if i + 10 > buf.len() {
return None;
}
let rtype = u16::from_be_bytes([buf[i], buf[i + 1]]);
let rdlen = u16::from_be_bytes([buf[i + 8], buf[i + 9]]) as usize;
if rtype == 12 && rdlen > 0 && i + 10 + rdlen <= buf.len() {
let mut j = i + 10;
if let Some(name) = read_name(buf, &mut j) {
let lower = name.to_lowercase();
if let Some(base) = lower.strip_suffix(".local") {
if !base.is_empty() {
return Some(base.to_string());
}
}
}
}
i += 10 + rdlen;
}
None
}
fn read_name(buf: &[u8], i: &mut usize) -> Option<String> {
let mut labels: Vec<String> = Vec::new();
let mut pos = *i;
let mut end = *i;
let mut jumps = 0;
loop {
let &len = buf.get(pos)?;
if len & 0xC0 == 0xC0 {
let &lo = buf.get(pos + 1)?;
if end == *i {
end = pos + 2;
}
pos = (((len & 0x3F) as usize) << 8) | lo as usize;
jumps += 1;
if jumps > 16 {
return None;
}
} else if len == 0 {
if end == *i {
end = pos + 1;
}
break;
} else {
let l = len as usize;
let s = pos + 1;
if s + l > buf.len() {
return None;
}
labels.push(String::from_utf8_lossy(&buf[s..s + l]).into_owned());
pos = s + l;
}
}
*i = end;
if labels.is_empty() {
None
} else {
Some(labels.join("."))
}
}
fn resolve_nbns(ip: Ipv4Addr) -> Option<String> {
let sock = UdpSocket::bind("0.0.0.0:0").ok()?;
sock.set_read_timeout(Some(Duration::from_millis(400))).ok()?;
let query = build_nbns_query(0x2a2a);
let mut buf = [0u8; 1500];
for _ in 0..2 {
sock.send_to(&query, (ip, 137)).ok()?;
let until = Instant::now() + Duration::from_millis(400);
while Instant::now() < until {
match sock.recv_from(&mut buf) {
Ok((n, src)) if src.ip() == ip => {
if let Some(name) = parse_nbns_response(&buf[..n]) {
let name = name.trim_end_matches('\0').trim().to_lowercase();
if !name.is_empty() && name.parse::<Ipv4Addr>().is_err() {
return Some(name);
}
}
}
Ok(_) => continue, Err(e)
if e.kind() == std::io::ErrorKind::WouldBlock
|| e.kind() == std::io::ErrorKind::TimedOut =>
{
continue
}
Err(_) => return None,
}
}
}
None
}
fn build_nbns_query(id: u16) -> Vec<u8> {
let mut m = Vec::with_capacity(50);
m.extend_from_slice(&id.to_be_bytes());
m.extend_from_slice(&[0x00, 0x00]); m.extend_from_slice(&[0x00, 0x01]); m.extend_from_slice(&[0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);
m.push(0x20); m.extend_from_slice(b"CKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"); m.push(0x00);
m.extend_from_slice(&0x21u16.to_be_bytes()); m.extend_from_slice(&1u16.to_be_bytes()); m
}
fn parse_nbns_response(buf: &[u8]) -> Option<String> {
if buf.len() < 12 {
return None;
}
let flags = u16::from_be_bytes([buf[2], buf[3]]);
if flags & 0x8000 == 0 {
return None; }
let mut i = 12usize;
read_name(buf, &mut i)?; if i + 10 > buf.len() {
return None;
}
let rdlen = u16::from_be_bytes([buf[i + 8], buf[i + 9]]) as usize;
i += 10;
if rdlen < 19 || i + rdlen > buf.len() || buf[i] == 0 {
return None;
}
let rec = &buf[i + 1..i + 17];
let name = String::from_utf8_lossy(&rec[..15])
.trim_matches(|c: char| c == ' ' || c == '\0')
.to_string();
if name.is_empty() || name.parse::<Ipv4Addr>().is_ok() {
None
} else {
Some(name)
}
}
fn resolve_hostname(ip: Ipv4Addr) -> Option<String> {
let mut addr: libc::sockaddr_in = unsafe { std::mem::zeroed() };
addr.sin_family = libc::AF_INET as libc::sa_family_t;
addr.sin_addr.s_addr = u32::from(ip).to_be();
let mut host = [0 as libc::c_char; 256];
let mut serv = [0 as libc::c_char; 64];
let rc = unsafe {
libc::getnameinfo(
&addr as *const libc::sockaddr_in as *const libc::sockaddr,
std::mem::size_of::<libc::sockaddr_in>() as libc::socklen_t,
host.as_mut_ptr(),
host.len() as libc::socklen_t,
serv.as_mut_ptr(),
serv.len() as libc::socklen_t,
libc::NI_NAMEREQD,
)
};
if rc != 0 {
return None;
}
let name = unsafe { CStr::from_ptr(host.as_ptr()) }
.to_string_lossy()
.trim_end_matches('.')
.trim_end_matches(".lan")
.to_lowercase();
if name.is_empty() || name.parse::<Ipv4Addr>().is_ok() {
None
} else {
Some(name)
}
}
#[cfg(test)]
mod tests {
#[test]
fn tracked_neighbors_sort_first() {
let mut c = LanCollector::new();
for k in 1..=3u32 {
let ip = format!("10.0.0.{k}").parse().unwrap();
c.neighbors.insert(ip, Neighbor {
ip,
mac: None,
iface: "eth0".into(),
complete: true,
hostname: None,
is_gateway: false,
is_self: false,
last_seen: std::time::Instant::now(),
});
}
c.tracked.insert("10.0.0.3".parse().unwrap());
let ips: Vec<_> = c
.sorted_neighbors()
.iter()
.map(|n| n.ip.to_string())
.collect();
assert_eq!(ips, vec!["10.0.0.3", "10.0.0.1", "10.0.0.2"]);
}
use super::*;
#[test]
fn host_range_excludes_network_and_broadcast() {
let hosts: Vec<Ipv4Addr> = host_range("192.168.1.0".parse().unwrap(), 24).collect();
assert_eq!(hosts.len(), 254);
assert_eq!(hosts[0], "192.168.1.1".parse::<Ipv4Addr>().unwrap());
assert_eq!(hosts[253], "192.168.1.254".parse::<Ipv4Addr>().unwrap());
}
#[test]
fn ptr_query_well_formed() {
let q = build_ptr_query("192.168.1.7".parse().unwrap(), 0x1234);
assert_eq!(&q[0..2], &[0x12, 0x34]); assert_eq!(&q[2..4], &[0, 0]); assert_eq!(&q[4..6], &[0, 1]); let tail = &q[12..];
let expected: &[&[u8]] = &[
b"7", b"1", b"168", b"192", b"in-addr", b"arpa",
];
let mut pos = 0;
for lbl in expected {
assert_eq!(tail[pos], lbl.len() as u8);
assert_eq!(&tail[pos + 1..pos + 1 + lbl.len()], *lbl);
pos += 1 + lbl.len();
}
assert_eq!(tail[pos], 0);
assert_eq!(&tail[pos + 1..pos + 3], &[0, 12]); assert_eq!(&tail[pos + 3..pos + 5], &[0, 1]); }
fn name_bytes(name: &str) -> Vec<u8> {
let mut out = Vec::new();
for lbl in name.split('.') {
out.push(lbl.len() as u8);
out.extend_from_slice(lbl.as_bytes());
}
out.push(0);
out
}
#[test]
fn parses_ptr_answer_with_compression() {
let mut m = Vec::new();
m.extend_from_slice(&[0x6c, 0x74]); m.extend_from_slice(&[0x84, 0x00]); m.extend_from_slice(&[0, 1, 0, 1, 0, 0, 0, 0]); m.extend_from_slice(&name_bytes("7.1.168.192.in-addr.arpa"));
m.extend_from_slice(&[0, 12, 0, 1]);
m.extend_from_slice(&[0xC0, 0x0C]);
m.extend_from_slice(&[0, 12, 0, 1, 0, 0, 0, 120]); let rd = name_bytes("MyPhone.local");
m.extend_from_slice(&(rd.len() as u16).to_be_bytes());
m.extend_from_slice(&rd);
assert_eq!(parse_ptr_response(&m).as_deref(), Some("myphone"));
}
#[test]
fn skips_non_ptr_and_non_local_answers() {
let answers = |rd: &[u8], rtype: u16| -> Vec<u8> {
let mut a = Vec::new();
a.extend_from_slice(&[0xC0, 0x0C]); a.extend_from_slice(&rtype.to_be_bytes());
a.extend_from_slice(&[0, 1, 0, 0, 0, 60]); a.extend_from_slice(&(rd.len() as u16).to_be_bytes());
a.extend_from_slice(rd);
a
};
let mut m = Vec::new();
m.extend_from_slice(&[0, 1, 0x84, 0, 0, 1, 0, 3, 0, 0, 0, 0]); m.extend_from_slice(&name_bytes("7.1.168.192.in-addr.arpa"));
m.extend_from_slice(&[0, 12, 0, 1]);
m.extend(&answers(&[192, 168, 1, 7], 1));
m.extend(&answers(&name_bytes("gw.example.com"), 12));
m.extend(&answers(&name_bytes("MyPhone.local"), 12));
assert_eq!(parse_ptr_response(&m).as_deref(), Some("myphone"));
let mut m2 = Vec::new();
m2.extend_from_slice(&[0, 1, 0x84, 0, 0, 1, 0, 1, 0, 0, 0, 0]); m2.extend_from_slice(&name_bytes("7.1.168.192.in-addr.arpa"));
m2.extend_from_slice(&[0, 12, 0, 1]);
m2.extend(&answers(&name_bytes("gw.example.com"), 12));
assert_eq!(parse_ptr_response(&m2), None);
}
#[test]
fn rejects_queries_and_garbage() {
assert_eq!(parse_ptr_response(&[]), None);
assert_eq!(parse_ptr_response(&[0u8; 11]), None);
let mut q = build_ptr_query("192.168.1.7".parse().unwrap(), 1);
q[2] = 0x00; assert_eq!(parse_ptr_response(&q), None);
}
#[test]
fn read_name_handles_plain_and_pointer() {
let mut m = Vec::new();
m.extend_from_slice(&name_bytes("a.local"));
let ptr_at = m.len();
m.extend_from_slice(&[0xC0, 0x00]); let mut i = ptr_at;
assert_eq!(read_name(&m, &mut i).as_deref(), Some("a.local"));
assert_eq!(i, ptr_at + 2); }
#[test]
fn nbns_query_well_formed() {
let q = build_nbns_query(0x4242);
assert_eq!(&q[0..2], &[0x42, 0x42]); assert_eq!(&q[2..4], &[0, 0]); assert_eq!(&q[4..6], &[0, 1]); assert_eq!(q[12], 0x20); assert_eq!(&q[13..15], b"CK"); assert_eq!(&q[13 + 30..13 + 32], b"AA");
assert_eq!(q[45], 0); assert_eq!(&q[46..48], &[0, 0x21]); assert_eq!(&q[48..50], &[0, 1]); }
#[test]
fn parses_nbns_node_status_response() {
let mut m = Vec::new();
m.extend_from_slice(&[0x2a, 0x2a]); m.extend_from_slice(&[0x84, 0x00]); m.extend_from_slice(&[0, 0, 0, 1, 0, 0, 0, 0]); m.push(0x20); m.extend_from_slice(b"CKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
m.push(0);
m.extend_from_slice(&[0, 0x21, 0, 1, 0, 0, 0, 0]); let names = 1u8;
let mut rec: Vec<u8> = b"SMBSHARE".to_vec();
rec.resize(15, b' '); rec.push(0x04); rec.extend_from_slice(&[192, 168, 1, 1]);
m.extend_from_slice(&((1 + rec.len()) as u16).to_be_bytes()); m.push(names);
m.extend_from_slice(&rec);
assert_eq!(parse_nbns_response(&m).as_deref(), Some("SMBSHARE"));
}
#[test]
fn rejects_nbns_queries_and_empty_names() {
assert_eq!(parse_nbns_response(&[]), None);
assert_eq!(parse_nbns_response(&[0u8; 20]), None);
let mut q = build_nbns_query(1);
q[2] = 0x00; assert_eq!(parse_nbns_response(&q), None);
let mut m = Vec::new();
m.extend_from_slice(&[0, 1, 0x84, 0, 0, 0, 0, 1, 0, 0, 0, 0]);
m.push(0x20);
m.extend_from_slice(b"CKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
m.push(0);
m.extend_from_slice(&[0, 0x21, 0, 1, 0, 0, 0, 0]);
m.extend_from_slice(&19u16.to_be_bytes());
m.push(0); m.extend_from_slice(&[0u8; 18]);
assert_eq!(parse_nbns_response(&m), None);
}
}