use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, ToSocketAddrs};
use crate::error::{Error, Result};
pub fn is_blocked_ip(ip: IpAddr) -> bool {
match ip {
IpAddr::V4(v4) => is_blocked_ipv4(v4),
IpAddr::V6(v6) => is_blocked_ipv6(v6),
}
}
pub fn filter_peers_for_dial(
peers: impl IntoIterator<Item = SocketAddr>,
block_private: bool,
) -> Vec<SocketAddr> {
crate::net::DialGate::from_block_private(block_private).filter(peers)
}
fn is_blocked_ipv4(ip: Ipv4Addr) -> bool {
ip.is_private()
|| ip.is_loopback()
|| ip.is_link_local()
|| ip.is_unspecified()
|| ip.is_broadcast()
|| ip.is_multicast()
|| ip.octets()[0] == 0
|| ip.octets()[0] == 100 && (64..=127).contains(&ip.octets()[1]) || ip.octets()[0] >= 240 }
fn is_blocked_ipv6(ip: Ipv6Addr) -> bool {
if let Some(v4) = ip.to_ipv4_mapped() {
return is_blocked_ipv4(v4);
}
ip.is_loopback()
|| ip.is_unspecified()
|| ip.is_multicast()
|| ip.segments()[0] & 0xfe00 == 0xfc00 || ip.segments()[0] & 0xffc0 == 0xfe80 }
pub fn resolve_tracker_socket(host: &str, port: u16, block_private: bool) -> Result<SocketAddr> {
if let Ok(ip) = host.parse::<IpAddr>() {
if block_private && is_blocked_ip(ip) {
return Err(Error::Tracker(format!(
"tracker host {host} resolves to blocked address {ip}"
)));
}
return Ok(SocketAddr::new(ip, port));
}
let spec = format!("{host}:{port}");
let mut last_err = None;
for addr in spec.to_socket_addrs().map_err(|err| {
Error::Tracker(format!("resolve tracker {spec}: {err}"))
})? {
if block_private && is_blocked_ip(addr.ip()) {
last_err = Some(addr.ip());
continue;
}
return Ok(addr);
}
Err(if let Some(ip) = last_err {
Error::Tracker(format!(
"tracker {spec} resolved only to blocked address {ip}"
))
} else {
Error::Tracker(format!("could not resolve tracker {spec}"))
})
}
pub fn ensure_http_ok(response: &[u8]) -> Result<()> {
let line_end = response
.iter()
.position(|&b| b == b'\n')
.ok_or_else(|| Error::Tracker("tracker response missing status line".into()))?;
let status = std::str::from_utf8(&response[..line_end])
.map_err(|_| Error::Tracker("tracker status line is not utf-8".into()))?;
if status.starts_with("HTTP/1.1 301 ")
|| status.starts_with("HTTP/1.0 301 ")
|| status.starts_with("HTTP/1.1 302 ")
|| status.starts_with("HTTP/1.0 302 ")
|| status.starts_with("HTTP/1.1 303 ")
|| status.starts_with("HTTP/1.0 303 ")
|| status.starts_with("HTTP/1.1 307 ")
|| status.starts_with("HTTP/1.0 307 ")
|| status.starts_with("HTTP/1.1 308 ")
|| status.starts_with("HTTP/1.0 308 ")
{
return Err(Error::Tracker(
"tracker redirect responses are not followed".into(),
));
}
if !(status.starts_with("HTTP/1.1 2") || status.starts_with("HTTP/1.0 2")) {
return Err(Error::Tracker(format!("tracker returned non-success: {status}")));
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn blocks_loopback() {
assert!(is_blocked_ip("127.0.0.1".parse().expect("ip")));
assert!(is_blocked_ip("::1".parse().expect("ip")));
}
#[test]
fn blocks_rfc1918() {
assert!(is_blocked_ip("10.0.0.1".parse().expect("ip")));
assert!(is_blocked_ip("192.168.1.1".parse().expect("ip")));
}
#[test]
fn allows_public() {
assert!(!is_blocked_ip("203.0.113.1".parse().expect("ip")));
}
#[test]
fn blocks_ipv4_multicast() {
assert!(is_blocked_ip("224.0.0.1".parse().expect("ip")));
assert!(is_blocked_ip("239.255.255.250".parse().expect("ip")));
}
#[test]
fn filter_peers_for_dial_drops_blocked() {
let peers = [
"203.0.113.1:6881".parse().expect("pub"),
"10.0.0.1:6881".parse().expect("priv"),
"127.0.0.1:6881".parse().expect("loop"),
];
let kept = filter_peers_for_dial(peers, true);
assert_eq!(kept.len(), 1);
assert_eq!(kept[0].ip().to_string(), "203.0.113.1");
assert_eq!(filter_peers_for_dial(peers, false).len(), 3);
}
#[test]
fn rejects_redirect_status() {
assert!(ensure_http_ok(b"HTTP/1.1 302 Found\r\n\r\n").is_err());
assert!(ensure_http_ok(b"HTTP/1.1 200 OK\r\n\r\n").is_ok());
}
}