net.cidr

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_is_cidr::cidr_block;  ← isCidr, another function of this group · built into the same file, even by a slim install
use super::net_ipv4_format_ipv4::format_ipv4;

/// Everything a subnet calculator shows for one IPv4 block.
///
/// Host bits in the input are dropped (192.168.1.77/24 describes
/// 192.168.1.0/24). A /31 is a point-to-point link with two usable addresses
/// and no broadcast (RFC 3021); a /32 is one host.
///
/// # Panics
/// Panics on a malformed block or an IPv6 block.
pub fn cidr_info(cidr: &str) -> CidrInfo {
    let (version, bits, prefix) = match cidr_block(cidr) {
        Some(block) => block,
        None => panic!("\"{}\" is not a CIDR block", cidr),
    };
    if version != 4 {
        panic!("cidrInfo handles IPv4 blocks only, received \"{}\"", cidr);
    }
    let size: i64 = 1 << (32 - prefix);
    let network = bits[0] - bits[0] % size;
    let last = network + size - 1;
    let point_to_point = prefix >= 31;
    CidrInfo {
        cidr: format!("{}/{}", format_ipv4(network), prefix),
        network: format_ipv4(network),
        prefix,
        netmask: format_ipv4(4294967296 - size),
        wildcard: format_ipv4(size - 1),
        broadcast: if point_to_point { None } else { Some(format_ipv4(last)) },
        first_host: format_ipv4(if point_to_point { network } else { network + 1 }),
        last_host: format_ipv4(if point_to_point { last } else { last - 1 }),
        host_count: if point_to_point { size } else { size - 2 },
        address_count: size,
    }
}

pub fn cidr_info_to_value(info: &CidrInfo) -> Value {
    Value::obj(vec![
        ("cidr", Value::str(&info.cidr)),
        ("network", Value::str(&info.network)),
        ("prefix", Value::Int(info.prefix)),
        ("netmask", Value::str(&info.netmask)),
        ("wildcard", Value::str(&info.wildcard)),
        ("broadcast", match &info.broadcast {
            Some(b) => Value::str(b),
            None => Value::Null,
        }),
        ("firstHost", Value::str(&info.first_host)),
        ("lastHost", Value::str(&info.last_host)),
        ("hostCount", Value::Int(info.host_count)),
        ("addressCount", Value::Int(info.address_count)),
    ])
}

pub fn fune_vector(args: &[Value]) -> Value {
    cidr_info_to_value(&cidr_info(args[0].as_str()))
}

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_is_cidr::cidr_block;  ← isCidr, another function of this group · built into the same file, even by a slim install
use super::net_ipv4_parse_ipv4::ipv4_value;
use super::net_ipv6_parse_ipv6::ipv6_groups;

/// Whether an address lies inside a block, IPv4 or IPv6.
///
/// An address of the other family is never inside (an IPv4-mapped IPv6
/// address is not treated as its IPv4 address).
///
/// # Panics
/// Panics on a malformed block or address.
pub fn cidr_contains(cidr: &str, address: &str) -> bool {
    let (version, bits, prefix) = match cidr_block(cidr) {
        Some(block) => block,
        None => panic!("\"{}\" is not a CIDR block", cidr),
    };
    let v4 = ipv4_value(address);
    let v6 = if v4.is_none() { ipv6_groups(address) } else { None };
    if v4.is_none() && v6.is_none() {
        panic!("\"{}\" is not an IP address", address);
    }
    if version == 4 {
        return match v4 {
            None => false,
            Some(a) => {
                let size: i64 = 1 << (32 - prefix);
                a / size == bits[0] / size
            }
        };
    }
    let groups = match v6 {
        None => return false,
        Some(g) => g,
    };
    for i in 0..8 {
        let taken = (prefix - 16 * i as i64).clamp(0, 16);
        let size: i64 = 1 << (16 - taken);
        if groups[i] / size != bits[i] / size {
            return false;
        }
    }
    true
}

pub fn fune_vector(args: &[Value]) -> Value {
    Value::Bool(cidr_contains(args[0].as_str(), args[1].as_str()))
}

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_ipv4_parse_ipv4::ipv4_value;
use super::net_ipv6_parse_ipv6::ipv6_groups;

/// True for a well-formed IPv4 (prefix 0-32) or IPv6 (prefix 0-128) block; never panics.
pub fn is_cidr(text: &str) -> bool {
    cidr_block(text).is_some()
}

// Exported for the other functions of this group; not part of its contract.

/// The block as (version, bits, prefix): bits is [address] for version 4 and
/// the eight groups for version 6. None when the text is not address/prefix
/// with a strict decimal prefix.
pub fn cidr_block(text: &str) -> Option<(i64, Vec<i64>, i64)> {
    let mut halves = text.split('/');
    let address = halves.next()?;
    let digits = halves.next()?;
    if halves.next().is_some() {
        return None;
    }
    let bytes = digits.as_bytes();
    if bytes.is_empty() || bytes.len() > 3 || !bytes.iter().all(|b| b.is_ascii_digit()) {
        return None;
    }
    if bytes.len() > 1 && bytes[0] == b'0' {
        return None;
    }
    let prefix = bytes.iter().fold(0i64, |acc, b| acc * 10 + (b - b'0') as i64);
    if let Some(v4) = ipv4_value(address) {
        return if prefix <= 32 { Some((4, vec![v4], prefix)) } else { None };
    }
    if let Some(v6) = ipv6_groups(address) {
        return if prefix <= 128 { Some((6, v6, prefix)) } else { None };
    }
    None
}

pub fn fune_vector(args: &[Value]) -> Value {
    Value::Bool(is_cidr(args[0].as_str()))
}

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_ipv4_format_ipv4::format_ipv4;

/// The dotted-quad mask for a prefix length: 24 is 255.255.255.0.
///
/// # Panics
/// Panics when the prefix is outside 0 to 32.
pub fn prefix_to_netmask(prefix: i64) -> String {
    if !(0..=32).contains(&prefix) {
        panic!("prefix must be an integer from 0 to 32, received {}", prefix);
    }
    format_ipv4(4294967296 - (1i64 << (32 - prefix)))
}

pub fn fune_vector(args: &[Value]) -> Value {
    let prefix = match &args[0] {
        Value::Int(i) => *i,
        other => panic!("prefix must be an integer from 0 to 32, received {}", other),
    };
    Value::str(&prefix_to_netmask(prefix))
}

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_ipv4_parse_ipv4::parse_ipv4;

/// The prefix length of a dotted-quad mask; a mask with a gap in its one bits is refused.
///
/// # Panics
/// Panics on text that is not a dotted quad, or a non-contiguous mask.
pub fn netmask_to_prefix(netmask: &str) -> i64 {
    let value = parse_ipv4(netmask);
    let host_part = 4294967295 - value + 1;
    for prefix in 0..=32i64 {
        if (1i64 << (32 - prefix)) == host_part {
            return prefix;
        }
    }
    panic!("\"{}\" is not a contiguous netmask", netmask);
}

pub fn fune_vector(args: &[Value]) -> Value {
    Value::Int(netmask_to_prefix(args[0].as_str()))
}