const SUFFIX_DOMAIN_CONTROLLERS: u8 = 0x1C;
const SUFFIX_DOMAIN_MASTER_BROWSER: u8 = 0x1B;
const FLAG_GROUP: u16 = 0x8000;
const HEADER_BYTES: usize = 12;
const ENCODED_NAME_BYTES: usize = 34;
const ANSWER_FIXED_BYTES: usize = 2 + 2 + 4 + 2;
const ENTRY_BYTES: usize = 18;
const FLAG_RESPONSE: u16 = 0x8000;
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RegisteredName {
pub name: String,
pub suffix: u8,
pub group: bool,
}
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NameTable {
pub names: Vec<RegisteredName>,
pub unit_id: [u8; 6],
}
impl NameTable {
#[must_use]
pub fn domain_controller(&self) -> bool {
self.names.iter().any(|entry| {
(entry.suffix == SUFFIX_DOMAIN_CONTROLLERS && entry.group)
|| (entry.suffix == SUFFIX_DOMAIN_MASTER_BROWSER && !entry.group)
})
}
#[must_use]
pub fn workstation(&self) -> Option<&str> {
self.names
.iter()
.find(|entry| entry.suffix == 0x00 && !entry.group && !entry.name.is_empty())
.map(|entry| entry.name.as_str())
}
#[must_use]
pub fn domain(&self) -> Option<&str> {
self.names
.iter()
.find(|entry| entry.suffix == 0x00 && entry.group && !entry.name.is_empty())
.map(|entry| entry.name.as_str())
}
}
#[must_use]
pub fn node_status(datagram: &[u8]) -> Option<NameTable> {
let flags = u16::from_be_bytes([*datagram.get(2)?, *datagram.get(3)?]);
if flags & FLAG_RESPONSE == 0 {
return None;
}
let answers = u16::from_be_bytes([*datagram.get(6)?, *datagram.get(7)?]);
if answers == 0 {
return None;
}
let rdata = datagram.get(HEADER_BYTES + ENCODED_NAME_BYTES + ANSWER_FIXED_BYTES..)?;
let count = *rdata.first()? as usize;
let mut names = Vec::with_capacity(count.min(rdata.len() / ENTRY_BYTES));
for index in 0..count {
let at = 1 + index * ENTRY_BYTES;
let entry = rdata.get(at..at + ENTRY_BYTES)?;
let flags = u16::from_be_bytes([entry[16], entry[17]]);
names.push(RegisteredName {
name: String::from_utf8_lossy(&entry[..15]).trim().to_string(),
suffix: entry[15],
group: flags & FLAG_GROUP != 0,
});
}
let statistics = 1 + count * ENTRY_BYTES;
let unit_id = rdata
.get(statistics..statistics + 6)
.and_then(|bytes| <[u8; 6]>::try_from(bytes).ok())
.unwrap_or([0; 6]);
Some(NameTable { names, unit_id })
}
#[cfg(test)]
pub(crate) mod tests {
use super::*;
pub(crate) fn response(entries: &[(&str, u8, bool)]) -> Vec<u8> {
let mut out = vec![0x80, 0xf0]; out.extend_from_slice(&0x8400u16.to_be_bytes()); out.extend_from_slice(&0u16.to_be_bytes()); out.extend_from_slice(&1u16.to_be_bytes()); out.extend_from_slice(&0u16.to_be_bytes()); out.extend_from_slice(&0u16.to_be_bytes());
out.push(0x20);
out.extend_from_slice(b"CKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
out.push(0x00);
out.extend_from_slice(&0x0021u16.to_be_bytes()); out.extend_from_slice(&0x0001u16.to_be_bytes()); out.extend_from_slice(&0u32.to_be_bytes()); let rdlength = 1 + entries.len() * ENTRY_BYTES + 46;
out.extend_from_slice(&(rdlength as u16).to_be_bytes());
out.push(entries.len() as u8);
for (name, suffix, group) in entries {
let mut padded = format!("{name:<15}").into_bytes();
padded.truncate(15);
out.extend_from_slice(&padded);
out.push(*suffix);
out.extend_from_slice(&(if *group { FLAG_GROUP } else { 0 }).to_be_bytes());
}
out.extend_from_slice(&[0xde, 0xad, 0xbe, 0xef, 0x00, 0x01]); out.extend_from_slice(&[0u8; 40]); out
}
#[test]
fn a_table_yields_the_names_and_the_adapter() {
let table = node_status(&response(&[
("FILESERVER", 0x00, false),
("FILESERVER", 0x20, false),
("WORKGROUP", 0x00, true),
]))
.expect("a well-formed response parses");
assert_eq!(table.names.len(), 3);
assert_eq!(table.workstation(), Some("FILESERVER"));
assert_eq!(table.domain(), Some("WORKGROUP"));
assert_eq!(table.unit_id, [0xde, 0xad, 0xbe, 0xef, 0x00, 0x01]);
}
#[test]
fn the_domain_controllers_group_names_a_controller() {
let table = node_status(&response(&[
("DC01", 0x00, false),
("CORP", 0x00, true),
("CORP", SUFFIX_DOMAIN_CONTROLLERS, true),
]))
.expect("parses");
assert!(table.domain_controller());
assert_eq!(table.domain(), Some("CORP"));
}
#[test]
fn the_domain_master_browser_names_one_too() {
let table = node_status(&response(&[
("DC01", 0x00, false),
("CORP", SUFFIX_DOMAIN_MASTER_BROWSER, false),
]))
.expect("parses");
assert!(table.domain_controller());
}
#[test]
fn a_suffix_in_the_wrong_form_names_nothing() {
let unique_1c =
node_status(&response(&[("CORP", SUFFIX_DOMAIN_CONTROLLERS, false)])).expect("parses");
assert!(!unique_1c.domain_controller());
let group_1b = node_status(&response(&[("CORP", SUFFIX_DOMAIN_MASTER_BROWSER, true)]))
.expect("parses");
assert!(!group_1b.domain_controller());
}
#[test]
fn a_workstation_is_not_a_controller() {
let table = node_status(&response(&[
("LAPTOP", 0x00, false),
("LAPTOP", 0x20, false),
("WORKGROUP", 0x00, true),
("WORKGROUP", 0x1E, true),
]))
.expect("parses");
assert!(!table.domain_controller());
}
#[test]
fn a_query_is_refused() {
let mut query = response(&[("HOST", 0x00, false)]);
query[2] = 0x00; query[3] = 0x10;
assert!(node_status(&query).is_none());
}
#[test]
fn a_count_the_datagram_cannot_back_is_refused() {
let mut lying = response(&[("HOST", 0x00, false)]);
let table_at = HEADER_BYTES + ENCODED_NAME_BYTES + ANSWER_FIXED_BYTES;
lying[table_at] = 200;
lying.truncate(table_at + 1 + ENTRY_BYTES);
assert!(node_status(&lying).is_none());
}
#[test]
fn a_truncated_statistics_block_costs_only_the_adapter() {
let full = response(&[("HOST", 0x00, false)]);
let table_at = HEADER_BYTES + ENCODED_NAME_BYTES + ANSWER_FIXED_BYTES;
let table = node_status(&full[..table_at + 1 + ENTRY_BYTES]).expect("the names parse");
assert_eq!(table.workstation(), Some("HOST"));
assert_eq!(table.unit_id, [0; 6]);
}
#[test]
fn arbitrary_bytes_are_refused_rather_than_read() {
for bytes in [
&b""[..],
&b"\x00"[..],
&b"\x80\xf0\x84\x00"[..],
&[0xff; 64][..],
] {
let _ = node_status(bytes);
}
assert!(node_status(b"").is_none());
assert!(node_status(&[0u8; 12]).is_none());
}
}