use std::net::{IpAddr, SocketAddr};
pub struct NoProxyMatcher {
entries: Vec<NoProxyEntry>,
match_all: bool,
}
enum NoProxyEntry {
Domain(String), IpAddr(IpAddr), IpNetwork(IpAddr, u8), }
impl NoProxyMatcher {
pub fn from_env_value(value: &str) -> Self {
let mut entries = Vec::new();
let mut match_all = false;
for pattern in value.split(',') {
let pattern = pattern.trim();
if pattern.is_empty() {
continue;
}
if pattern == "*" {
match_all = true;
continue;
}
if let Some(slash_pos) = pattern.rfind('/') {
let addr_str = &pattern[..slash_pos];
let prefix_str = &pattern[slash_pos + 1..];
if let Ok(addr) = addr_str.parse::<IpAddr>()
&& let Ok(prefix) = prefix_str.parse::<u8>()
{
entries.push(NoProxyEntry::IpNetwork(addr, prefix));
continue;
}
}
if let Ok(addr) = pattern.parse::<IpAddr>() {
entries.push(NoProxyEntry::IpAddr(addr));
continue;
}
let normalized = if pattern.starts_with("*.") {
&pattern[1..]
} else {
pattern
};
entries.push(NoProxyEntry::Domain(normalized.to_lowercase()));
}
Self { entries, match_all }
}
pub fn should_bypass(&self, target: &SocketAddr) -> bool {
if self.match_all {
return true;
}
let ip = target.ip();
for entry in &self.entries {
match entry {
NoProxyEntry::IpAddr(entry_ip) if *entry_ip == ip => return true,
NoProxyEntry::IpNetwork(network_addr, prefix_len)
if Self::ip_in_network(ip, *network_addr, *prefix_len) =>
{
return true;
}
_ => {}
}
}
false
}
pub fn should_bypass_hostname(&self, hostname: &str) -> bool {
if self.match_all {
return true;
}
let hostname_lower = hostname.to_lowercase();
for entry in &self.entries {
if let NoProxyEntry::Domain(pattern) = entry {
if let Some(stripped) = pattern.strip_prefix('.') {
if hostname_lower.ends_with(pattern.as_str()) || hostname_lower == stripped {
return true;
}
} else {
if hostname_lower == *pattern {
return true;
}
}
}
}
false
}
fn ip_in_network(ip: IpAddr, network: IpAddr, prefix_len: u8) -> bool {
match (ip, network) {
(std::net::IpAddr::V4(ip_v4), std::net::IpAddr::V4(net_v4)) => {
let ip_u32 = u32::from_be_bytes(ip_v4.octets());
let net_u32 = u32::from_be_bytes(net_v4.octets());
let mask = if prefix_len >= 32 {
0xFFFFFFFFu32
} else {
!(0xFFFFFFFF >> prefix_len)
};
(ip_u32 & mask) == (net_u32 & mask)
}
(std::net::IpAddr::V6(ip_v6), std::net::IpAddr::V6(net_v6)) => {
let ip_octets = ip_v6.octets();
let net_octets = net_v6.octets();
let full_bytes = (prefix_len as usize) / 8;
let remaining_bits = (prefix_len as usize) % 8;
if ip_octets[..full_bytes] != net_octets[..full_bytes] {
return false;
}
if remaining_bits > 0 && full_bytes < 16 {
let mask = !(0xFFu8 >> remaining_bits);
if (ip_octets[full_bytes] & mask) != (net_octets[full_bytes] & mask) {
return false;
}
}
true
}
_ => false,
}
}
}