use std::collections::{BTreeMap, HashMap};
use serde_json::{Map, Value};
use crate::js::{js_space, js_trim, js_value, utf16_cmp};
use crate::types::{Attrs, Node, Object};
pub const HOST_POLICY_KEY: &str = "host-integrations";
pub const AUTHOR_POLICY_KEY: &str = "integrations";
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub enum ToolDefault {
#[default]
Allowed,
Blocked,
}
impl ToolDefault {
pub fn as_str(self) -> &'static str {
match self {
ToolDefault::Allowed => "allowed",
ToolDefault::Blocked => "blocked",
}
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct ServerTools {
pub allowed: Option<Vec<String>>,
pub blocked: Option<Vec<String>>,
pub default: Option<ToolDefault>,
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct PolicyLayer {
pub allowed: Option<Vec<String>>,
pub servers: Option<BTreeMap<String, ServerTools>>,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ServerPolicy {
pub blocked: Vec<String>,
pub default: ToolDefault,
pub allowed: Option<Vec<String>>,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct PolicyFrom {
pub host: bool,
pub author: bool,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Policy {
pub allowed: Option<Vec<String>>,
pub servers: BTreeMap<String, ServerPolicy>,
pub from: PolicyFrom,
}
impl Policy {
pub fn tool_blocked<S: AsRef<str>>(&self, targets: &[S], tool: &str) -> bool {
targets.iter().any(|t| {
self.servers.get(&normalize_target(t.as_ref())).is_some_and(|s| {
s.blocked.iter().any(|x| x == tool)
|| (s.default == ToolDefault::Blocked && !s.allowed.as_deref().unwrap_or_default().iter().any(|x| x == tool))
})
})
}
pub fn targets_allowed<S: AsRef<str>>(&self, targets: &[S]) -> bool {
let Some(allowed) = &self.allowed else { return true };
targets.iter().all(|t| allowed.contains(&normalize_target(t.as_ref())))
}
pub fn to_json(&self) -> Value {
let list = |xs: &[String]| Value::Array(xs.iter().cloned().map(Value::String).collect());
let mut m = Map::new();
if let Some(a) = &self.allowed {
m.insert("allowed".into(), list(a));
}
let mut servers = Map::new();
for (t, s) in &self.servers {
let mut e = Map::new();
e.insert("blocked".into(), list(&s.blocked));
e.insert("default".into(), s.default.as_str().into());
if let Some(a) = &s.allowed {
e.insert("allowed".into(), list(a));
}
servers.insert(t.clone(), Value::Object(e));
}
m.insert("servers".into(), Value::Object(servers));
let mut from = Map::new();
from.insert("host".into(), self.from.host.into());
from.insert("author".into(), self.from.author.into());
m.insert("from".into(), Value::Object(from));
Value::Object(m)
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct LayerProblem {
pub key: String,
pub message: String,
}
fn sorted(xs: impl IntoIterator<Item = String>) -> Vec<String> {
let mut v: Vec<String> = xs.into_iter().collect();
v.sort_by(|a, b| utf16_cmp(a, b));
v.dedup();
v
}
fn names(v: Option<&Value>) -> Option<Vec<String>> {
let Some(Value::Array(a)) = v else { return None };
a.iter().map(|x| x.as_str().map(js_trim).filter(|s| !s.is_empty()).map(str::to_string)).collect()
}
fn array_index(k: &str) -> Option<u32> {
let n: u32 = k.parse().ok()?;
(n != u32::MAX && n.to_string() == k).then_some(n)
}
fn js_keys(written: Vec<String>) -> Vec<String> {
let (mut idx, rest): (Vec<String>, Vec<String>) = written.into_iter().partition(|k| array_index(k).is_some());
idx.sort_by_key(|k| array_index(k));
idx.extend(rest);
idx
}
type Order<'a> = &'a dyn Fn(&[&str], &Object) -> Vec<String>;
pub fn layer_of(value: &Value, key: &str) -> (Option<PolicyLayer>, Vec<LayerProblem>) {
layer_in_order(value, key, &|_, m| m.keys().cloned().collect())
}
pub(crate) fn layer_in_order(value: &Value, key: &str, order: Order<'_>) -> (Option<PolicyLayer>, Vec<LayerProblem>) {
let mut problems = Vec::new();
let mut bad =
|message: String| problems.push(LayerProblem { key: key.into(), message: format!("the front matter's {key}: {message}") });
let Value::Object(value) = value else {
bad("is a mapping of allowed and servers".into());
return (None, problems);
};
let mut layer = PolicyLayer::default();
for k in js_keys(order(&[], value)) {
if k != "allowed" && k != "servers" {
bad(format!("\"{k}\" is not one of its keys (allowed, servers)"));
}
}
if value.contains_key("allowed") {
match names(value.get("allowed")) {
None => bad("allowed is a list of targets (addresses or registry names)".into()),
Some(xs) => layer.allowed = Some(sorted(xs.iter().map(|x| normalize_target(x)))),
}
}
if let Some(servers) = value.get("servers") {
match servers {
Value::Object(servers) => {
let mut out: BTreeMap<String, ServerTools> = BTreeMap::new();
for target in js_keys(order(&["servers"], servers)) {
let Some(Value::Object(entry)) = servers.get(&target) else {
bad(format!("servers.\"{target}\" is a mapping of allowed, blocked and default"));
continue;
};
let mut t = ServerTools::default();
for k in js_keys(order(&["servers", &target], entry)) {
if !["allowed", "blocked", "default"].contains(&k.as_str()) {
bad(format!("servers.\"{target}\": \"{k}\" is not one of its keys (allowed, blocked, default)"));
}
}
for k in ["allowed", "blocked"] {
if entry.contains_key(k) {
match names(entry.get(k)) {
None => bad(format!("servers.\"{target}\".{k} is a list of tool names")),
Some(xs) => {
let xs = Some(sorted(xs));
if k == "allowed" { t.allowed = xs } else { t.blocked = xs }
}
}
}
}
if let Some(d) = entry.get("default") {
match d.as_str() {
Some("allowed") => t.default = Some(ToolDefault::Allowed),
Some("blocked") => t.default = Some(ToolDefault::Blocked),
_ => bad(format!("servers.\"{target}\".default is allowed or blocked")),
}
}
let n = normalize_target(&target);
let merged = match out.remove(&n) {
Some(was) => merge_tools(&[&was, &t]),
None => t,
};
out.insert(n, merged);
}
layer.servers = Some(out);
}
_ => bad("servers is a mapping of a server's target to its tools".into()),
}
}
(Some(layer), problems)
}
fn merge_tools(ts: &[&ServerTools]) -> ServerTools {
let blocked = sorted(ts.iter().flat_map(|t| t.blocked.iter().flatten().cloned()));
let closed: Vec<&&ServerTools> = ts.iter().filter(|t| t.default == Some(ToolDefault::Blocked)).collect();
let Some(first) = closed.first() else {
return ServerTools { allowed: None, blocked: Some(blocked), default: Some(ToolDefault::Allowed) };
};
let mut allowed: Vec<String> = first.allowed.clone().unwrap_or_default();
for t in &closed[1..] {
let theirs = t.allowed.as_deref().unwrap_or_default();
allowed.retain(|x| theirs.contains(x));
}
let allowed = sorted(allowed.into_iter().filter(|x| !blocked.contains(x)));
ServerTools { allowed: Some(allowed), blocked: Some(blocked), default: Some(ToolDefault::Blocked) }
}
pub fn merge_policy(host: Option<&PolicyLayer>, author: Option<&PolicyLayer>) -> Option<Policy> {
let layers: Vec<&PolicyLayer> = [host, author].into_iter().flatten().collect();
if layers.is_empty() {
return None;
}
let mut allowed: Option<Vec<String>> = None;
for l in &layers {
let Some(theirs) = &l.allowed else { continue };
allowed = Some(match allowed {
None => theirs.clone(),
Some(mut a) => {
a.retain(|t| theirs.contains(t));
a
}
});
}
let targets = sorted(layers.iter().flat_map(|l| l.servers.iter().flat_map(|s| s.keys().cloned())));
let mut servers = BTreeMap::new();
for target in targets {
let ts: Vec<&ServerTools> = layers.iter().filter_map(|l| l.servers.as_ref()?.get(&target)).collect();
let m = merge_tools(&ts);
let default = m.default.unwrap_or_default();
let allowed = (default == ToolDefault::Blocked).then(|| m.allowed.unwrap_or_default());
servers.insert(target, ServerPolicy { blocked: m.blocked.unwrap_or_default(), default, allowed });
}
Some(Policy { allowed: allowed.map(sorted), servers, from: PolicyFrom { host: host.is_some(), author: author.is_some() } })
}
pub const INTEGRATED_KINDS: &[&str] = &["mcp", "skill", "agent", "service"];
pub fn normalize_target(target: &str) -> String {
let t = js_trim(target);
if is_http(t)
&& let Some(u) = url::normalize(t)
{
return u;
}
t.to_lowercase()
}
fn is_http(s: &str) -> bool {
let b = s.as_bytes();
let starts = |p: &[u8]| b.len() >= p.len() && b[..p.len()].eq_ignore_ascii_case(p);
starts(b"http://") || starts(b"https://")
}
pub fn remote_targets(kind: &str, attrs: &Attrs) -> Vec<String> {
if !INTEGRATED_KINDS.contains(&kind) {
return Vec::new();
}
let mut out = Vec::new();
for key in ["src", "endpoint", "registry", "server"] {
let Some(Value::String(v)) = attrs.get(key) else { continue };
let t = js_trim(v);
if t.is_empty() || t.starts_with('#') {
continue;
}
let relative = t.starts_with('/') || t.starts_with("./") || t.starts_with("../");
if is_http(t) || ((key == "registry" || key == "server") && !relative) {
out.push(normalize_target(v));
}
}
out
}
fn names_of(v: Option<&Value>) -> Vec<String> {
let raw: Vec<String> = match v {
Some(Value::Array(a)) => a.iter().map(|x| js_value(Some(x))).collect(),
Some(Value::String(s)) => s.split(|c: char| c == ',' || js_space(c)).map(str::to_string).collect(),
_ => Vec::new(),
};
raw.iter().map(|x| js_trim(x)).filter(|x| !x.is_empty()).map(str::to_string).collect()
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct NamedTools {
pub targets: Vec<String>,
pub tools: Vec<String>,
}
pub fn named_tools(n: &Node, body: &[Node]) -> Option<NamedTools> {
let by_id = objects_by_id(body);
named_in(n, &by_id)
}
fn named_in(n: &Node, by_id: &HashMap<&str, &Node>) -> Option<NamedTools> {
if n.kind == "mcp" {
let mut tools: Vec<String> = Vec::new();
for t in names_of(n.attrs.get("tools")).into_iter().chain(names_of(n.attrs.get("allow"))) {
if !tools.contains(&t) {
tools.push(t);
}
}
return Some(NamedTools { targets: remote_targets("mcp", &n.attrs), tools });
}
let name = match n.attrs.get("name") {
Some(Value::String(s)) if n.kind == "tool" && !js_trim(s).is_empty() => js_trim(s).to_string(),
_ => return None,
};
let server = n.attrs.get("server").and_then(Value::as_str).map(js_trim).unwrap_or("");
let targets = if let Some(id) = server.strip_prefix('#') {
match by_id.get(id) {
Some(on) if on.kind == "mcp" || on.kind == "service" => remote_targets(&on.kind, &on.attrs),
Some(_) => Vec::new(),
None => remote_targets("mcp", &server_attrs(server)),
}
} else if !server.is_empty() {
remote_targets("mcp", &server_attrs(server))
} else {
Vec::new()
};
Some(NamedTools { targets, tools: vec![name] })
}
fn server_attrs(server: &str) -> Attrs {
let mut a = Attrs::new();
a.insert("server".into(), server.into());
a
}
fn objects_by_id(body: &[Node]) -> HashMap<&str, &Node> {
let mut all = HashMap::new();
crate::objects::walk(body, &mut |n, _| {
if let Some(Value::String(id)) = n.attrs.get("id") {
all.entry(id.as_str()).or_insert(n);
}
true
});
all
}
pub(crate) fn check(
front: &Object,
order: &crate::types::KeyOrder,
at: u32,
host_option: Option<&PolicyLayer>,
body: &[Node],
out: &mut Vec<crate::types::Diagnostic>,
) -> Option<Policy> {
use crate::types::{Diagnostic, Severity};
let mut layer = |key: &str| -> Option<PolicyLayer> {
let v = front.get(key)?;
let written = |path: &[&str], m: &Object| order.keys(&crate::types::KeyOrder::path(key, path), m);
let (l, problems) = layer_in_order(v, key, &written);
for p in problems {
out.push(Diagnostic::new("invalid-metadata", Severity::Error, p.message, at));
}
l
};
let from_matter = layer(HOST_POLICY_KEY);
let author = layer(AUTHOR_POLICY_KEY);
let host = from_matter.as_ref().or(host_option);
let policy = merge_policy(host, author.as_ref())?;
let host_only = merge_policy(host, None);
let by_id = objects_by_id(body);
crate::objects::walk(body, &mut |n, _| {
let line = n.range.map_or(0, |r| r.start);
if let Some(named) = named_in(n, &by_id) {
for tool in &named.tools {
if !policy.tool_blocked(&named.targets, tool) {
continue;
}
let by_host = host_only.as_ref().is_some_and(|p| p.tool_blocked(&named.targets, tool));
let whose = if by_host { "in your workspace" } else { "by this instruction's integrations" };
let mut d = Diagnostic::new("tool-blocked", Severity::Warning, format!("{tool}: this tool is blocked {whose}"), line);
d.target = tool.clone();
d.remedy = if by_host {
"Use another tool, or ask an admin to allow it in Integrations"
} else {
"Use another tool, or allow it in the front matter's integrations"
}
.into();
out.push(d);
}
}
let targets = remote_targets(&n.kind, &n.attrs);
if !policy.targets_allowed(&targets) {
let name = match (n.attrs.get("title"), n.attrs.get("id")) {
(Some(Value::String(t)), _) => t.clone(),
(_, Some(Value::String(id))) => format!("#{id}"),
_ => n.kind.clone(),
};
let noun = match n.kind.as_str() {
"mcp" => "MCP server",
k => k,
};
let by_host = host_only.as_ref().is_some_and(|p| !p.targets_allowed(&targets));
let whose = if by_host { "your workspace's" } else { "this instruction's" };
let mut d = Diagnostic::new(
"integration-not-allowed",
Severity::Warning,
format!("{name}: this {noun} is not one of {whose} integrations, so it is not used"),
line,
);
d.target = targets[0].clone();
d.remedy = if by_host {
"Use one of your integrations, or ask an admin to add it"
} else {
"Use one of the integrations the front matter allows"
}
.into();
out.push(d);
}
true
});
Some(policy)
}
fn json_string(s: &str) -> String {
serde_json::to_string(s).unwrap_or_default()
}
fn flow_list(xs: &[String]) -> String {
format!("[{}]", xs.iter().map(|x| json_string(x)).collect::<Vec<_>>().join(", "))
}
pub fn host_block(layer: Option<&PolicyLayer>) -> Option<String> {
let layer = layer?;
if layer.allowed.is_none() && layer.servers.is_none() {
return None;
}
let mut out = format!("{HOST_POLICY_KEY}:\n");
if let Some(a) = &layer.allowed {
out += &format!(" allowed: {}\n", flow_list(&sorted(a.iter().cloned())));
}
let servers = layer.servers.as_ref().map(|s| sorted(s.keys().cloned())).unwrap_or_default();
if !servers.is_empty() {
out += " servers:\n";
for s in servers {
let t = &layer.servers.as_ref().expect("servers")[&s];
let mut parts = Vec::new();
if let Some(a) = &t.allowed {
parts.push(format!("\"allowed\": {}", flow_list(&sorted(a.iter().cloned()))));
}
if let Some(b) = &t.blocked {
parts.push(format!("\"blocked\": {}", flow_list(&sorted(b.iter().cloned()))));
}
if let Some(d) = t.default {
parts.push(format!("\"default\": \"{}\"", d.as_str()));
}
out += &format!(" {}: {{{}}}\n", json_string(&s), parts.join(", "));
}
}
Some(out)
}
pub fn with_host_block(text: &str, block: Option<&str>) -> String {
let Some(block) = block else { return text.to_string() };
let bom = if text.starts_with('\u{feff}') { "\u{feff}" } else { "" };
let rest = &text[bom.len()..];
match fence(rest.as_bytes()) {
Some(n) => format!("{bom}{}{block}{}", &rest[..n], &rest[n..]),
None => format!("{bom}---\n{block}---\n{rest}"),
}
}
const BOM: &[u8] = "\u{feff}".as_bytes();
fn fence(b: &[u8]) -> Option<usize> {
let rest = b.strip_prefix(b"---")?;
match rest {
[b'\r', b'\n', ..] => Some(5),
[b'\r', ..] | [b'\n', ..] => Some(4),
_ => None,
}
}
fn lf_line(b: &[u8]) -> Option<usize> {
let end = b.iter().position(|&c| c == b'\n' || c == b'\r')?;
(b[end] == b'\n').then_some(end + 1)
}
pub fn authored_candidates(text: &[u8]) -> Vec<Vec<u8>> {
let bom = if text.starts_with(BOM) { BOM.len() } else { 0 };
let rest = &text[bom..];
let Some(open) = fence(rest) else { return vec![text.to_vec()] };
let after = &rest[open..];
let key = format!("{HOST_POLICY_KEY}:");
if !after.starts_with(key.as_bytes()) {
return vec![text.to_vec()];
}
let Some(mut n) = lf_line(after) else { return vec![text.to_vec()] };
while matches!(after.get(n), Some(b' ' | b'\t')) {
match lf_line(&after[n..]) {
Some(k) => n += k,
None => break,
}
}
let mut stripped = text[..bom + open].to_vec();
stripped.extend_from_slice(&after[n..]);
let mut out = vec![text.to_vec(), stripped.clone()];
if let Some(a) = fence(&stripped[bom..])
&& let Some(b) = fence(&stripped[bom + a..])
{
let mut empty = text[..bom].to_vec();
empty.extend_from_slice(&stripped[bom + a + b..]);
out.push(empty);
}
out
}
mod url {
const HEX: &[u8; 16] = b"0123456789ABCDEF";
fn encode(out: &mut String, s: &str, set: impl Fn(u8) -> bool) {
for &b in s.as_bytes() {
if !(0x20..=0x7e).contains(&b) || set(b) {
out.push('%');
out.push(HEX[(b >> 4) as usize] as char);
out.push(HEX[(b & 15) as usize] as char);
} else {
out.push(b as char);
}
}
}
fn path_set(b: u8) -> bool {
matches!(b, b' ' | b'"' | b'#' | b'<' | b'>' | b'?' | b'`' | b'{' | b'}')
}
fn query_set(b: u8) -> bool {
matches!(b, b' ' | b'"' | b'#' | b'<' | b'>' | b'\'')
}
fn percent_decode(s: &str) -> Vec<u8> {
let b = s.as_bytes();
let mut out = Vec::with_capacity(b.len());
let mut i = 0;
while i < b.len() {
if b[i] == b'%'
&& i + 2 < b.len()
&& let (Some(h), Some(l)) = ((b[i + 1] as char).to_digit(16), (b[i + 2] as char).to_digit(16))
{
out.push((h * 16 + l) as u8);
i += 3;
continue;
}
out.push(b[i]);
i += 1;
}
out
}
pub(super) fn normalize(input: &str) -> Option<String> {
let s: String = input.trim_matches(|c: char| c <= ' ').chars().filter(|c| !matches!(c, '\t' | '\n' | '\r')).collect();
let colon = s.find(':')?;
let scheme = s[..colon].to_ascii_lowercase();
let default_port = match scheme.as_str() {
"http" => "80",
"https" => "443",
_ => return None,
};
let rest = s[colon + 1..].trim_start_matches(['/', '\\']);
let end = rest.find(['/', '\\', '?', '#']).unwrap_or(rest.len());
let (authority, rest) = rest.split_at(end);
let host_port = match authority.rfind('@') {
Some(at) => &authority[at + 1..],
None => authority,
};
let (host, port) = split_port(host_port)?;
let host = parse_host(host)?;
let port = match port {
None | Some("") => String::new(),
Some(p) => {
if !p.bytes().all(|b| b.is_ascii_digit()) {
return None;
}
let digits = p.trim_start_matches('0');
if digits.len() > 5 {
return None;
}
let n: u32 = if digits.is_empty() { 0 } else { digits.parse().ok()? };
if n > 65535 {
return None;
}
let n = n.to_string();
if n == default_port { String::new() } else { format!(":{n}") }
}
};
let rest = rest.split('#').next().unwrap_or("");
let (path, query) = match rest.find('?') {
Some(q) => (&rest[..q], Some(&rest[q + 1..])),
None => (rest, None),
};
let pathname = pathname(path);
let mut out = format!("{scheme}://{host}{port}");
if pathname.len() > 1 {
out.push_str(pathname.trim_end_matches('/'));
}
if let Some(q) = query
&& !q.is_empty()
{
out.push('?');
encode(&mut out, q, query_set);
}
Some(out)
}
fn split_port(s: &str) -> Option<(&str, Option<&str>)> {
let mut inside = false;
for (i, c) in s.char_indices() {
match c {
'[' => inside = true,
']' => inside = false,
':' if !inside => return Some((&s[..i], Some(&s[i + 1..]))),
_ => {}
}
}
Some((s, None))
}
fn pathname(path: &str) -> String {
let mut segments: Vec<String> = Vec::new();
let raw: Vec<&str> = if path.is_empty() { vec![""] } else { path[1..].split(['/', '\\']).collect() };
let last = raw.len() - 1;
for (i, seg) in raw.iter().enumerate() {
let mut buf = String::new();
encode(&mut buf, seg, path_set);
let lower = buf.to_ascii_lowercase();
let double = matches!(lower.as_str(), ".." | ".%2e" | "%2e." | "%2e%2e");
let single = matches!(lower.as_str(), "." | "%2e");
if double {
segments.pop();
if i == last {
segments.push(String::new());
}
} else if single {
if i == last {
segments.push(String::new());
}
} else {
segments.push(buf);
}
}
format!("/{}", segments.join("/"))
}
fn parse_host(s: &str) -> Option<String> {
if let Some(inner) = s.strip_prefix('[') {
let inner = inner.strip_suffix(']')?;
return Some(format!("[{}]", ipv6(inner)?));
}
if s.is_empty() {
return None;
}
let decoded = String::from_utf8(percent_decode(s)).ok()?;
let domain = decoded.to_lowercase();
if domain.is_empty()
|| domain.chars().any(|c| {
c < ' ' || matches!(c, ' ' | '#' | '%' | '/' | ':' | '<' | '>' | '?' | '@' | '[' | '\\' | ']' | '^' | '|' | '\u{7f}')
})
{
return None;
}
if ends_in_number(&domain) {
return ipv4(&domain);
}
Some(domain)
}
fn ends_in_number(s: &str) -> bool {
let mut parts: Vec<&str> = s.split('.').collect();
if parts.last() == Some(&"") {
if parts.len() == 1 {
return false;
}
parts.pop();
}
let Some(last) = parts.last() else { return false };
if !last.is_empty() && last.bytes().all(|b| b.is_ascii_digit()) {
return true;
}
let hex = last.strip_prefix("0x").or_else(|| last.strip_prefix("0X"));
hex.is_some_and(|h| h.bytes().all(|b| b.is_ascii_hexdigit()))
}
fn ipv4_number(s: &str) -> Option<u64> {
if s.is_empty() {
return None;
}
let (digits, radix) = if let Some(h) = s.strip_prefix("0x").or_else(|| s.strip_prefix("0X")) {
(h, 16)
} else if s.len() > 1 && s.starts_with('0') {
(&s[1..], 8)
} else {
(s, 10)
};
if digits.is_empty() {
return Some(0);
}
if !digits.chars().all(|c| c.is_digit(radix)) {
return None;
}
let trimmed = digits.trim_start_matches('0');
if trimmed.len() > 12 {
return Some(u64::MAX);
}
u64::from_str_radix(if trimmed.is_empty() { "0" } else { trimmed }, radix).ok()
}
fn ipv4(s: &str) -> Option<String> {
let mut parts: Vec<&str> = s.split('.').collect();
if parts.last() == Some(&"") && parts.len() > 1 {
parts.pop();
}
if parts.len() > 4 {
return None;
}
let nums: Vec<u64> = parts.iter().map(|p| ipv4_number(p)).collect::<Option<_>>()?;
let (last, init) = nums.split_last()?;
if init.iter().any(|&n| n > 255) || *last >= 256u64.pow(5 - nums.len() as u32) {
return None;
}
let mut v = *last;
for (i, &n) in init.iter().enumerate() {
v += n * 256u64.pow(3 - i as u32);
}
Some(format!("{}.{}.{}.{}", v >> 24, (v >> 16) & 255, (v >> 8) & 255, v & 255))
}
fn ipv6(s: &str) -> Option<String> {
let mut addr = [0u16; 8];
let c: Vec<char> = s.chars().collect();
let (mut piece, mut compress, mut p) = (0usize, None::<usize>, 0usize);
if c.first() == Some(&':') {
if c.get(1) != Some(&':') {
return None;
}
p = 2;
piece = 1;
compress = Some(1);
}
while p < c.len() {
if piece == 8 {
return None;
}
if c[p] == ':' {
if compress.is_some() {
return None;
}
p += 1;
piece += 1;
compress = Some(piece);
continue;
}
let (mut value, mut length) = (0u32, 0);
while length < 4 && p < c.len() && c[p].is_ascii_hexdigit() {
value = value * 16 + c[p].to_digit(16)?;
p += 1;
length += 1;
}
if p < c.len() && c[p] == '.' {
if length == 0 || piece > 6 {
return None;
}
p -= length;
let mut seen = 0;
while p < c.len() {
let mut v4: Option<u32> = None;
if seen > 0 {
if c[p] == '.' && seen < 4 {
p += 1;
} else {
return None;
}
}
if p >= c.len() || !c[p].is_ascii_digit() {
return None;
}
while p < c.len() && c[p].is_ascii_digit() {
let n = c[p].to_digit(10)?;
v4 = match v4 {
None => Some(n),
Some(0) => return None,
Some(x) => Some(x * 10 + n),
};
if v4? > 255 {
return None;
}
p += 1;
}
addr[piece] = (addr[piece] as u32 * 256 + v4?) as u16;
seen += 1;
if seen == 2 || seen == 4 {
piece += 1;
}
}
if seen != 4 {
return None;
}
break;
} else if p < c.len() && c[p] == ':' {
p += 1;
if p >= c.len() {
return None;
}
} else if p < c.len() {
return None;
}
addr[piece] = value as u16;
piece += 1;
}
if let Some(cp) = compress {
let mut swaps = piece - cp;
piece = 7;
while piece != 0 && swaps > 0 {
addr.swap(piece, cp + swaps - 1);
piece -= 1;
swaps -= 1;
}
} else if piece != 8 {
return None;
}
let (mut best, mut best_len, mut i) = (None::<usize>, 1usize, 0usize);
while i < 8 {
if addr[i] == 0 {
let start = i;
while i < 8 && addr[i] == 0 {
i += 1;
}
if i - start > best_len {
best = Some(start);
best_len = i - start;
}
} else {
i += 1;
}
}
let mut out = String::new();
let mut ignore0 = false;
for (i, piece) in addr.iter().enumerate() {
if ignore0 && *piece == 0 {
continue;
}
ignore0 = false;
if best == Some(i) {
out.push_str(if i == 0 { "::" } else { ":" });
ignore0 = true;
continue;
}
out.push_str(&format!("{piece:x}"));
if i != 7 {
out.push(':');
}
}
Some(out)
}
}