use libp2p::multiaddr::Protocol;
use libp2p::{Multiaddr, PeerId};
pub fn addr_peer(a: &Multiaddr) -> Option<PeerId> {
a.iter().filter_map(|p| if let Protocol::P2p(id) = p { Some(id) } else { None }).last()
}
pub fn circuit_relay(a: &Multiaddr) -> Option<(PeerId, Multiaddr)> {
let mut relay = Multiaddr::empty();
let mut peer = None;
for p in a.iter() {
if p == Protocol::P2pCircuit {
return peer.map(|id| (id, relay));
}
if let Protocol::P2p(id) = p {
peer = Some(id);
}
relay.push(p);
}
None
}
pub fn parse_addrs<S: AsRef<str>>(v: &[S]) -> Vec<Multiaddr> {
v.iter().filter_map(|s| s.as_ref().trim().parse().ok()).collect()
}
pub fn shareable(a: &Multiaddr) -> bool {
!a.iter().any(|p| match p {
Protocol::Ip4(ip) => ip.is_unspecified() || (ip.octets()[0] == 172 && matches!(ip.octets()[1], 17 | 18)),
Protocol::Ip6(ip) => ip.is_unspecified() || (ip.segments()[0] & 0xffc0) == 0xfe80,
_ => false,
})
}
pub fn routable(a: &Multiaddr) -> bool {
if !shareable(a) {
return false;
}
!a.iter().any(|p| match p {
Protocol::Ip4(ip) => {
let o = ip.octets();
ip.is_loopback() || ip.is_private() || ip.is_link_local() || (o[0] == 100 && (o[1] & 0xc0) == 64)
}
Protocol::Ip6(ip) => {
let s0 = ip.segments()[0];
ip.is_loopback() || (s0 & 0xfe00) == 0xfc00 || (s0 & 0xffc0) == 0xfe80
}
_ => false,
})
}
pub fn reach_rank(a: &Multiaddr) -> u8 {
let mut r = 1;
for p in a.iter() {
r = match p {
Protocol::Dns(_) | Protocol::Dns4(_) | Protocol::Dns6(_) => 0,
Protocol::Ip4(ip) if ip.is_loopback() => 5,
Protocol::Ip4(ip) if ip.octets()[0] == 100 && (ip.octets()[1] & 0xc0) == 64 => 3,
Protocol::Ip4(ip) if ip.is_private() => 2,
Protocol::Ip4(_) => 1,
Protocol::Ip6(ip) if ip.is_loopback() => 5,
Protocol::Ip6(ip) if (ip.segments()[0] & 0xfe00) == 0xfc00 => 4,
Protocol::Ip6(_) => 1,
_ => continue,
};
break;
}
let quic = a.iter().any(|p| matches!(p, Protocol::QuicV1));
r * 2 + quic as u8
}
pub fn one_circuit_per_relay(addrs: Vec<Multiaddr>, configured: &[Multiaddr]) -> Vec<Multiaddr> {
let rank = |a: &Multiaddr| {
let base: Multiaddr = a.iter().take_while(|p| *p != Protocol::P2pCircuit).collect();
(!configured.contains(&base), reach_rank(a))
};
let mut best: Vec<(PeerId, Multiaddr)> = vec![];
let mut out = vec![];
for a in addrs {
match circuit_relay(&a) {
None => out.push(a),
Some((r, _)) => match best.iter_mut().find(|(p, _)| *p == r) {
Some((_, b)) if rank(&a) < rank(b) => *b = a,
Some(_) => {}
None => best.push((r, a)),
},
}
}
out.extend(best.into_iter().map(|(_, a)| a));
out
}
#[cfg(test)]
#[test]
fn one_reachable_circuit_per_relay() {
let r = "12D3KooWC21S2Wxq3UCGcZYTsipGKjRitEar4nFARuvzpiUv2HH2";
let m = "12D3KooWPNK5evehBHG3pftjw1tN1VuH7CLjo8dZfMxes9tdQHTg";
let c = |base: &str| -> Multiaddr { format!("{base}/p2p/{r}/p2p-circuit").parse().unwrap() };
let direct: Multiaddr = "/ip4/192.168.50.230/tcp/4741".parse().unwrap();
let all = vec![
direct.clone(),
c("/ip4/127.0.0.1/tcp/4741"),
c("/ip4/100.75.141.6/udp/4741/quic-v1"),
c("/ip4/192.168.50.2/tcp/4741"),
c("/dns4/alien.example/udp/4741/quic-v1"),
c("/dns4/alien.example/tcp/4741"),
];
assert_eq!(one_circuit_per_relay(all.clone(), &[]), vec![direct.clone(), c("/dns4/alien.example/tcp/4741")]);
let named: Multiaddr = format!("/ip4/192.168.50.2/tcp/4741/p2p/{r}").parse().unwrap();
assert_eq!(one_circuit_per_relay(all, &[named]), vec![direct, c("/ip4/192.168.50.2/tcp/4741")]);
let docker: Multiaddr = format!("/ip4/172.17.0.1/tcp/4741/p2p/{r}/p2p-circuit/p2p/{m}").parse().unwrap();
let fe80: Multiaddr = format!("/ip6/fe80::1/tcp/4741/p2p/{r}/p2p-circuit/p2p/{m}").parse().unwrap();
assert!(!shareable(&docker) && !shareable(&fe80));
assert!(shareable(&"/ip4/127.0.0.1/tcp/1".parse().unwrap()) && shareable(&"/ip4/172.16.0.1/tcp/1".parse().unwrap()));
}
pub fn link_local(a: &str) -> bool {
a.strip_prefix("/ip6/").is_some_and(|r| r.get(..4).is_some_and(|p| p.eq_ignore_ascii_case("fe80")))
}
pub fn docker_bridge(a: &str) -> bool {
a.strip_prefix("/ip4/172.").is_some_and(|r| r.starts_with("17.") || r.starts_with("18."))
}
pub fn dnsaddr_name(name: &str) -> String {
format!("_dnsaddr.{}", name.trim().trim_end_matches('.'))
}
pub fn dnsaddr_txt(addr: &Multiaddr) -> crate::Result<String> {
if addr_peer(addr).is_none() {
return Err(crate::NetError::invalid("dnsaddr", "the address has no /p2p/ peer id"));
}
let v = format!("dnsaddr={addr}");
if v.len() > 255 {
return Err(crate::NetError::invalid("dnsaddr", "longer than one TXT string"));
}
Ok(v)
}
pub fn dnsaddr_record(name: &str, port: u16, peer: &PeerId) -> crate::Result<(String, String)> {
let host = crate::ingress::sni::host_name(name.as_bytes()).ok_or_else(|| crate::NetError::invalid("dnsaddr", "not a host name"))?;
let a: Multiaddr = format!("/dns/{host}/tcp/{port}/p2p/{peer}").parse().map_err(|e| crate::NetError::invalid("dnsaddr", format!("{e}")))?;
Ok((dnsaddr_name(&host), dnsaddr_txt(&a)?))
}
pub fn dnsaddr_dial(name: &str, peer: &PeerId) -> Multiaddr {
Multiaddr::empty().with(Protocol::Dnsaddr(name.trim().trim_end_matches('.').to_string().into())).with(Protocol::P2p(*peer))
}