Imports name this capability’s declared dependencies, which fune builds next to it in your project; each one links to its page.
use super::funejson::Value; ← the fune runtime: the JSON value the test vectors use; fune build keeps it only where a signature takes one
use super::net_cidr::{cidr_info, is_cidr}; ← from net.cidr ^1.0.0 · built alongside by fune
use super::net_hostname_validate::validate_hostname; ← from net.hostname-validate ^1.0.0 · built alongside by fune
use super::net_ipv4::is_ipv4; ← from net.ipv4 ^1.0.0 · built alongside by fune
use super::net_ipv6::{format_ipv6, is_ipv6, parse_ipv6}; ← from net.ipv6 ^1.0.0 · built alongside by fune
use super::net_mac_address::validate_mac_address; ← from net.mac-address ^1.0.0 · built alongside by fune
use super::net_port::is_port; ← from net.port ^1.0.0 · built alongside by fune
const KNOWN: [&str; 5] = ["name", "host", "ports", "mac", "subnet"];
/// A whole number, whichever way the JSON reader stored it (22 and 22.0 are the same port).
fn whole_number(value: &Value) -> Option<i64> {
match value {
Value::Int(i) => Some(*i),
Value::Float(f) if f.is_finite() && f.fract() == 0.0 && f.abs() < 9.0e15 => Some(*f as i64),
_ => None,
}
}
/// An IPv6 block with its host bits cleared and its address in RFC 5952 form.
fn canonical_ipv6_block(text: &str) -> String {
let (address, prefix_text) = text.split_once('/').unwrap_or((text, "128"));
let prefix: i64 = prefix_text.parse().unwrap_or(128);
let groups: Vec<i64> = parse_ipv6(address)
.iter()
.enumerate()
.map(|(i, g)| {
let bits = (prefix - 16 * i as i64).clamp(0, 16);
if bits == 0 {
0
} else {
g & ((0xffff_i64 << (16 - bits)) & 0xffff)
}
})
.collect();
format!("{}/{}", format_ipv6(&groups), prefix)
}
/// Check one inventory entry and say everything that is wrong with it at once,
/// so a person fixing a file does not play whack-a-mole one error per run.
/// Never panics: a bad entry is a result, not a crash.
pub fn validate_device(entry: &Value) -> DeviceValidation {
let mut errors: Vec<String> = Vec::new();
let empty: Vec<(String, Value)> = Vec::new();
let pairs = match entry {
Value::Obj(pairs) => pairs,
_ => &empty,
};
let field = |key: &str| -> Option<&Value> {
pairs.iter().find(|(k, _)| k == key).map(|(_, v)| v).filter(|v| !v.is_null())
};
let mut name: Option<String> = None;
match field("name") {
None => errors.push("name is required".to_string()),
Some(Value::Str(s)) => {
let trimmed = s.trim_matches(|c: char| matches!(c, ' ' | '\t' | '\n' | '\r' | '\x0c' | '\x0b'));
if trimmed.is_empty() {
errors.push("name must not be empty".to_string());
} else {
name = Some(trimmed.to_string());
}
}
Some(_) => errors.push("name must be text".to_string()),
}
let mut host: Option<String> = None;
let mut host_kind: Option<String> = None;
match field("host") {
None => errors.push("host is required".to_string()),
Some(Value::Str(s)) => {
if is_ipv4(s) {
host = Some(s.clone());
host_kind = Some("ipv4".to_string());
} else if is_ipv6(s) {
host = Some(format_ipv6(&parse_ipv6(s)));
host_kind = Some("ipv6".to_string());
} else {
let check = validate_hostname(s);
if check.valid {
host = check.hostname;
host_kind = Some("hostname".to_string());
} else {
errors.push(format!(
"host \"{}\" is not an IPv4 address, IPv6 address or host name: {}",
s,
check.reason.unwrap_or_default()
));
}
}
}
Some(_) => errors.push("host must be text".to_string()),
}
let mut ports: Vec<i64> = Vec::new();
match field("ports") {
None => errors.push("ports is required".to_string()),
Some(Value::Arr(items)) => {
if items.is_empty() {
errors.push("ports must not be empty".to_string());
}
for (i, item) in items.iter().enumerate() {
match whole_number(item) {
None => errors.push(format!("ports[{}] must be a whole number", i)),
Some(port) if !is_port(port) => {
errors.push(format!("ports[{}] {} is not a port (1-65535)", i, port))
}
Some(port) if ports.contains(&port) => {
errors.push(format!("ports[{}] {} is listed twice", i, port))
}
Some(port) => ports.push(port),
}
}
}
Some(_) => errors.push("ports must be a list".to_string()),
}
let mut mac: Option<String> = None;
match field("mac") {
None => {}
Some(Value::Str(s)) => {
let check = validate_mac_address(s);
if check.valid {
mac = check.canonical;
} else {
errors.push(format!("mac \"{}\" is not valid: {}", s, check.reason.unwrap_or_default()));
}
}
Some(_) => errors.push("mac must be text".to_string()),
}
let mut subnet: Option<String> = None;
match field("subnet") {
None => {}
Some(Value::Str(s)) => {
if !is_cidr(s) {
errors.push(format!("subnet \"{}\" is not a CIDR block", s));
} else if s.contains(':') {
subnet = Some(canonical_ipv6_block(s));
} else {
subnet = Some(cidr_info(s).cidr);
}
}
Some(_) => errors.push("subnet must be text".to_string()),
}
// Sorted, not in file order: JavaScript lists integer-like keys first, so
// "file order" would differ between languages.
let mut unknown: Vec<&String> = pairs.iter().map(|(k, _)| k).filter(|k| !KNOWN.contains(&k.as_str())).collect();
unknown.sort();
unknown.dedup();
for key in unknown {
errors.push(format!("unknown field \"{}\"", key));
}
DeviceValidation {
valid: errors.is_empty(),
errors,
name,
host,
host_kind,
ports,
mac,
subnet,
}
}
fn opt(value: &Option<String>) -> Value {
match value {
Some(s) => Value::str(s),
None => Value::Null,
}
}
pub fn device_validation_to_value(v: &DeviceValidation) -> Value {
Value::obj(vec![
("valid", Value::Bool(v.valid)),
("errors", Value::Arr(v.errors.iter().map(|e| Value::str(e)).collect())),
("name", opt(&v.name)),
("host", opt(&v.host)),
("hostKind", opt(&v.host_kind)),
("ports", Value::Arr(v.ports.iter().map(|p| Value::Int(*p)).collect())),
("mac", opt(&v.mac)),
("subnet", opt(&v.subnet)),
])
}
pub fn fune_vector(args: &[Value]) -> Value {
device_validation_to_value(&validate_device(&args[0]))
}