use std::net::{IpAddr, Ipv4Addr, SocketAddr, SocketAddrV4, UdpSocket as StdUdpSocket};
use std::time::Duration;
use socket2::{Domain, Protocol, Socket, Type};
use tokio::net::UdpSocket;
use tokio::task::JoinSet;
use tokio::time::{Instant, timeout};
use crate::protocols::mdns::{self, PORT};
use crate::warn;
const GROUP_V4: Ipv4Addr = Ipv4Addr::new(224, 0, 0, 251);
const MULTICAST_TTL: u32 = 255;
const MAX_DATAGRAM: usize = 9000;
pub async fn resolve(name: &str, timeout_after: Duration) -> Vec<IpAddr> {
match query(name, timeout_after).await {
Ok(addresses) => addresses,
Err(e) => {
warn!("mDNS lookup of {name} failed: {e}");
Vec::new()
}
}
}
async fn query(name: &str, timeout_after: Duration) -> std::io::Result<Vec<IpAddr>> {
let interfaces = multicast_interfaces();
if interfaces.is_empty() {
return Err(std::io::Error::other(
"no interface holds an IPv4 address to query the mDNS group on",
));
}
let packet = mdns::build_query(name).map_err(std::io::Error::other)?;
let wanted = name.trim_end_matches('.').to_string();
let deadline = Instant::now() + timeout_after;
let target = SocketAddr::V4(SocketAddrV4::new(GROUP_V4, PORT));
let mut listeners: JoinSet<Vec<IpAddr>> = JoinSet::new();
for iface in interfaces {
let socket = match open_group_socket(iface) {
Ok(socket) => socket,
Err(e) => {
warn!("mDNS: could not join the group on {iface}: {e}");
continue;
}
};
if let Err(e) = socket.send_to(&packet, target).await {
warn!("mDNS: could not query the group on {iface}: {e}");
continue;
}
let wanted = wanted.clone();
listeners.spawn(listen(socket, wanted, deadline));
}
if listeners.is_empty() {
return Err(std::io::Error::other(
"no interface accepted the mDNS query",
));
}
let mut found = Vec::new();
while let Some(joined) = listeners.join_next().await {
if let Ok(addresses) = joined {
for ip in addresses {
if !found.contains(&ip) {
found.push(ip);
}
}
}
}
Ok(found)
}
async fn listen(socket: UdpSocket, wanted: String, deadline: Instant) -> Vec<IpAddr> {
let mut found = Vec::new();
let mut buf = [0u8; MAX_DATAGRAM];
loop {
let remaining = deadline.saturating_duration_since(Instant::now());
if remaining.is_zero() {
break;
}
match timeout(remaining, socket.recv_from(&mut buf)).await {
Ok(Ok((len, _from))) => collect_matching(&buf[..len], &wanted, &mut found),
_ => break,
}
}
found
}
fn open_group_socket(interface: Ipv4Addr) -> std::io::Result<UdpSocket> {
let socket = Socket::new(Domain::IPV4, Type::DGRAM, Some(Protocol::UDP))?;
socket.set_reuse_address(true)?;
#[cfg(unix)]
socket.set_reuse_port(true)?;
socket.set_multicast_ttl_v4(MULTICAST_TTL)?;
socket.set_multicast_if_v4(&interface)?;
let bind_addr: SocketAddr = SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::UNSPECIFIED, PORT));
socket.bind(&bind_addr.into()).map_err(|error| {
std::io::Error::new(
error.kind(),
format!("binding {bind_addr} for {interface}: {error}"),
)
})?;
socket
.join_multicast_v4(&GROUP_V4, &interface)
.map_err(|error| {
std::io::Error::new(
error.kind(),
format!("joining the mDNS group on {interface}: {error}"),
)
})?;
socket.set_nonblocking(true)?;
UdpSocket::from_std(StdUdpSocket::from(socket))
}
fn multicast_interfaces() -> Vec<Ipv4Addr> {
crate::system::interface::interfaces()
.into_iter()
.filter(|link| link.is_up() && !link.is_loopback())
.filter_map(|link| link.ipv4().map(|(v4, _)| v4).find(|v4| !v4.is_loopback()))
.collect()
}
fn collect_matching(datagram: &[u8], wanted: &str, found: &mut Vec<IpAddr>) {
let Ok(hosts) = mdns::extract_hosts(datagram) else {
return;
};
for host in hosts {
if !host.hostname.eq_ignore_ascii_case(wanted) {
continue;
}
for ip in host.ips {
if !found.contains(&ip) {
found.push(ip);
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
fn response(records: &[(&str, IpAddr)]) -> Vec<u8> {
let mut bytes = Vec::new();
bytes.extend_from_slice(&0u16.to_be_bytes()); bytes.extend_from_slice(&0x8400u16.to_be_bytes()); bytes.extend_from_slice(&0u16.to_be_bytes()); bytes.extend_from_slice(&(records.len() as u16).to_be_bytes()); bytes.extend_from_slice(&0u16.to_be_bytes()); bytes.extend_from_slice(&0u16.to_be_bytes());
for (owner, ip) in records {
for label in owner.split('.') {
bytes.push(label.len() as u8);
bytes.extend_from_slice(label.as_bytes());
}
bytes.push(0);
let (rtype, rdata): (u16, Vec<u8>) = match ip {
IpAddr::V4(v4) => (1, v4.octets().to_vec()),
IpAddr::V6(v6) => (28, v6.octets().to_vec()),
};
bytes.extend_from_slice(&rtype.to_be_bytes());
bytes.extend_from_slice(&1u16.to_be_bytes()); bytes.extend_from_slice(&120u32.to_be_bytes()); bytes.extend_from_slice(&(rdata.len() as u16).to_be_bytes());
bytes.extend_from_slice(&rdata);
}
bytes
}
fn ip(s: &str) -> IpAddr {
s.parse().expect("a valid address")
}
#[test]
fn both_families_of_the_named_host_are_collected() {
let datagram = response(&[
("raspberrypi.local", ip("192.0.2.150")),
("raspberrypi.local", ip("fe80::1")),
]);
let mut found = Vec::new();
collect_matching(&datagram, "raspberrypi.local", &mut found);
assert!(found.contains(&ip("192.0.2.150")));
assert!(found.contains(&ip("fe80::1")));
assert_eq!(found.len(), 2);
}
#[test]
fn a_reply_naming_other_hosts_contributes_only_the_match() {
let datagram = response(&[
("appletv.local", ip("192.0.2.40")),
("raspberrypi.local", ip("192.0.2.150")),
("printer.local", ip("192.0.2.30")),
]);
let mut found = Vec::new();
collect_matching(&datagram, "raspberrypi.local", &mut found);
assert_eq!(found, vec![ip("192.0.2.150")]);
}
#[test]
fn the_name_is_matched_without_regard_to_case() {
let datagram = response(&[("Raspberrypi.local", ip("192.0.2.150"))]);
let mut found = Vec::new();
collect_matching(&datagram, "raspberrypi.local", &mut found);
assert_eq!(found, vec![ip("192.0.2.150")]);
}
#[test]
fn a_datagram_that_is_not_dns_is_ignored() {
let mut found = Vec::new();
collect_matching(b"not a dns message", "raspberrypi.local", &mut found);
assert!(found.is_empty());
}
#[test]
fn an_address_two_responders_agree_on_is_recorded_once() {
let datagram = response(&[("nas.local", ip("192.0.2.5"))]);
let mut found = vec![ip("192.0.2.5")];
collect_matching(&datagram, "nas.local", &mut found);
assert_eq!(found, vec![ip("192.0.2.5")]);
}
}