net.ipv6

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;

/// The eight 16-bit groups of an IPv6 address written as RFC 4291 allows.
///
/// Hex groups of one to four digits in either case, at most one "::" standing
/// for one or more zero groups, and optionally a dotted IPv4 address as the
/// last 32 bits. A zone id ("%eth0") or a prefix ("/64") is not part of an
/// address and is refused, as is anything around it (spaces, newlines).
///
/// # Panics
/// Panics when the text is not an IPv6 address.
pub fn parse_ipv6(text: &str) -> Vec<i64> {
    match ipv6_groups(text) {
        Some(groups) => groups,
        None => panic!("\"{}\" is not an IPv6 address", text),
    }
}

// Exported for is_ipv6 and for capabilities that parse IPv6 text without
// wanting a panic; not part of the group's contract.

/// The eight groups, or None when the text is not an IPv6 address.
pub fn ipv6_groups(text: &str) -> Option<Vec<i64>> {
    if text.is_empty() || !text.bytes().all(|b| b.is_ascii_hexdigit() || b == b':' || b == b'.') {
        return None;
    }
    let at = match text.find("::") {
        None => {
            let groups = pieces(&text.split(':').collect::<Vec<_>>(), true)?;
            return if groups.len() == 8 { Some(groups) } else { None };
        }
        Some(at) => at,
    };
    let before = &text[..at];
    let after = &text[at + 2..];
    if after.contains("::") {
        return None;
    }
    let split = |s: &str| -> Vec<String> {
        if s.is_empty() {
            Vec::new()
        } else {
            s.split(':').map(str::to_string).collect()
        }
    };
    let head = pieces(&split(before), false)?;
    let tail = pieces(&split(after), true)?;
    // "::" stands for at least one group, so at most seven are written.
    if head.len() + tail.len() > 7 {
        return None;
    }
    let mut groups = head.clone();
    groups.extend(std::iter::repeat(0).take(8 - head.len() - tail.len()));
    groups.extend(tail);
    Some(groups)
}

fn pieces<S: AsRef<str>>(parts: &[S], may_end_with_ipv4: bool) -> Option<Vec<i64>> {
    let mut groups = Vec::new();
    for (i, part) in parts.iter().enumerate() {
        let part = part.as_ref();
        if part.contains('.') {
            if !may_end_with_ipv4 || i != parts.len() - 1 {
                return None;
            }
            let v4 = ipv4_value(part)?;
            groups.push(v4 / 65536);
            groups.push(v4 % 65536);
            continue;
        }
        if part.is_empty() || part.len() > 4 {
            return None;
        }
        groups.push(i64::from_str_radix(part, 16).ok()?);
    }
    Some(groups)
}

pub fn fune_vector(args: &[Value]) -> Value {
    Value::Arr(parse_ipv6(args[0].as_str()).into_iter().map(Value::Int).collect())
}

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;

/// RFC 5952 canonical text for eight 16-bit groups.
///
/// Lower-case hex, no leading zeros, the longest run of two or more zero
/// groups written "::" (the first on a tie, never a single group). An
/// IPv4-mapped address (::ffff:0:0/96) keeps its dotted-quad tail.
///
/// # Panics
/// Panics unless there are exactly eight groups, each 0 to 65535.
pub fn format_ipv6(groups: &[i64]) -> String {
    if groups.len() != 8 || groups.iter().any(|g| !(0..=65535).contains(g)) {
        panic!("IPv6 groups must be eight integers from 0 to 65535");
    }
    if groups[..6] == [0, 0, 0, 0, 0, 0xffff] {
        return format!("::ffff:{}", format_ipv4(groups[6] * 65536 + groups[7]));
    }
    let (mut best_start, mut best_length) = (0usize, 0usize);
    let mut i = 0;
    while i < 8 {
        if groups[i] != 0 {
            i += 1;
            continue;
        }
        let mut j = i;
        while j < 8 && groups[j] == 0 {
            j += 1;
        }
        // Strictly longer, so the first of two equal runs wins.
        if j - i > best_length {
            best_start = i;
            best_length = j - i;
        }
        i = j;
    }
    let hex: Vec<String> = groups.iter().map(|g| format!("{:x}", g)).collect();
    if best_length < 2 {
        return hex.join(":");
    }
    format!(
        "{}::{}",
        hex[..best_start].join(":"),
        hex[best_start + best_length..].join(":")
    )
}

pub fn fune_vector(args: &[Value]) -> Value {
    let groups: Vec<i64> = args[0]
        .as_arr()
        .iter()
        .map(|g| match g {
            Value::Int(i) => *i,
            _ => panic!("IPv6 groups must be eight integers from 0 to 65535"),
        })
        .collect();
    Value::str(&format_ipv6(&groups))
}

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_ipv6_parse_ipv6::ipv6_groups;  ← parseIpv6, another function of this group · built into the same file, even by a slim install

/// True exactly when parse_ipv6 would accept the text; never panics.
pub fn is_ipv6(text: &str) -> bool {
    ipv6_groups(text).is_some()
}

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