use std::net::IpAddr;
use anyhow::Result;
use super::{Advert, Found, on_local_network, read_strings, txt_map};
pub(super) trait Registry {
type Handle;
fn register(&mut self, advert: &Advert) -> Result<Self::Handle>;
}
pub(super) struct Registrations<R: Registry> {
registry: R,
held: Vec<(Advert, R::Handle)>,
failing: Vec<Advert>,
}
impl<R: Registry> Registrations<R> {
pub(super) fn new(registry: R) -> Self {
Self {
registry,
held: Vec::new(),
failing: Vec::new(),
}
}
pub(super) fn update(&mut self, wanted: &[Advert]) {
self.held.retain(|(advert, _)| wanted.contains(advert));
self.failing.retain(|advert| wanted.contains(advert));
for advert in wanted {
if self.held.iter().any(|(held, _)| held == advert) {
continue;
}
match self.registry.register(advert) {
Ok(handle) => {
self.failing.retain(|failed| failed != advert);
self.held.push((advert.clone(), handle));
}
Err(e) if !self.failing.contains(advert) => {
tracing::warn!(
"cannot advertise {} {:?} through the system's DNS-SD service: {e:#}",
advert.service,
advert.instance
);
self.failing.push(advert.clone());
}
Err(_) => {}
}
}
}
pub(super) fn handles(&self) -> impl Iterator<Item = &R::Handle> {
self.held.iter().map(|(_, handle)| handle)
}
pub(super) fn retain(&mut self, mut keep: impl FnMut(&mut R::Handle) -> bool) {
self.held.retain_mut(|(_, handle)| keep(handle));
}
}
pub(super) fn resolved(instance: &str, port: u16, txt: &[u8], addresses: &[IpAddr]) -> Vec<Found> {
let Some(strings) = read_strings(txt) else {
return Vec::new();
};
if instance.is_empty() {
return Vec::new();
}
let txt = txt_map(&strings);
let mut out = Vec::new();
for &address in addresses {
let found = Found {
instance: instance.to_string(),
address,
port,
txt: txt.clone(),
};
if on_local_network(address) && !out.contains(&found) {
out.push(found);
}
}
out
}
#[cfg(test)]
mod tests {
use std::cell::RefCell;
use std::net::{Ipv4Addr, Ipv6Addr};
use std::rc::Rc;
use anyhow::bail;
use super::*;
use crate::mdns::{TXT_ID, TXT_LOGIN, device_advert, pairing_advert, txt_record};
type Log = Rc<RefCell<Vec<String>>>;
struct Fake {
log: Log,
refused: Rc<RefCell<Vec<u16>>>,
}
struct Handle {
port: u16,
log: Log,
}
impl Drop for Handle {
fn drop(&mut self) {
self.log
.borrow_mut()
.push(format!("withdraw {}", self.port));
}
}
impl Registry for Fake {
type Handle = Handle;
fn register(&mut self, advert: &Advert) -> Result<Handle> {
if self.refused.borrow().contains(&advert.port) {
bail!("refused");
}
self.log
.borrow_mut()
.push(format!("register {}", advert.port));
Ok(Handle {
port: advert.port,
log: self.log.clone(),
})
}
}
fn registrations() -> (Registrations<Fake>, Log, Rc<RefCell<Vec<u16>>>) {
let log = Log::default();
let refused = Rc::new(RefCell::new(Vec::new()));
let fake = Fake {
log: log.clone(),
refused: refused.clone(),
};
(Registrations::new(fake), log, refused)
}
fn taken(log: &Log) -> Vec<String> {
std::mem::take(&mut *log.borrow_mut())
}
#[test]
fn an_update_registers_each_new_advert_once_and_withdraws_dropped_ones() {
let (mut registrations, log, _) = registrations();
let device = device_advert("peer-1", "me", 22);
let pairing = pairing_advert("desk", "peer-1", 7201);
registrations.update(&[device.clone(), pairing.clone(), device.clone()]);
assert_eq!(taken(&log), ["register 22", "register 7201"]);
registrations.update(&[device.clone(), pairing.clone()]);
assert_eq!(taken(&log), Vec::<String>::new());
registrations.update(std::slice::from_ref(&device));
assert_eq!(taken(&log), ["withdraw 7201"]);
registrations.update(&[]);
assert_eq!(taken(&log), ["withdraw 22"]);
assert_eq!(registrations.handles().count(), 0);
}
#[test]
fn a_changed_advert_is_withdrawn_before_it_is_registered_again() {
let (mut registrations, log, _) = registrations();
registrations.update(&[device_advert("peer-1", "me", 22)]);
taken(&log);
registrations.update(&[device_advert("peer-1", "me", 2222)]);
assert_eq!(taken(&log), ["withdraw 22", "register 2222"]);
}
#[test]
fn a_refused_or_ended_registration_is_registered_on_a_later_update() {
let (mut registrations, log, refused) = registrations();
let device = device_advert("peer-1", "me", 22);
refused.borrow_mut().push(22);
registrations.update(std::slice::from_ref(&device));
registrations.update(std::slice::from_ref(&device));
assert_eq!(registrations.handles().count(), 0);
refused.borrow_mut().clear();
registrations.update(std::slice::from_ref(&device));
assert_eq!(taken(&log), ["register 22"]);
registrations.retain(|_| false);
assert_eq!(taken(&log), ["withdraw 22"]);
registrations.update(std::slice::from_ref(&device));
assert_eq!(taken(&log), ["register 22"]);
}
#[test]
fn a_resolved_instance_counts_once_per_local_ipv4_address() {
let advert = device_advert("peer-1", "me", 2222);
let lan = IpAddr::V4(Ipv4Addr::new(192, 168, 1, 5));
let link = IpAddr::V4(Ipv4Addr::new(169, 254, 3, 4));
let found = resolved(
"peer-1",
2222,
&txt_record(&advert),
&[
lan,
IpAddr::V4(Ipv4Addr::new(8, 8, 8, 8)),
IpAddr::V4(Ipv4Addr::new(100, 64, 0, 1)),
IpAddr::V6(Ipv6Addr::LOCALHOST),
link,
lan,
],
);
let addresses: Vec<IpAddr> = found.iter().map(|f| f.address).collect();
assert_eq!(addresses, [lan, link]);
for found in &found {
assert_eq!(found.instance, "peer-1");
assert_eq!(found.port, 2222);
assert_eq!(found.get(TXT_ID), Some("peer-1"));
assert_eq!(found.get(TXT_LOGIN), Some("me"));
}
}
#[test]
fn a_resolved_instance_with_a_cut_txt_record_or_no_name_is_not_found() {
let txt = txt_record(&device_advert("peer-1", "me", 22));
let lan = [IpAddr::V4(Ipv4Addr::new(10, 0, 0, 2))];
assert!(resolved("peer-1", 22, &txt[..txt.len() - 1], &lan).is_empty());
assert!(resolved("", 22, &txt, &lan).is_empty());
let shadowed = [
5, b'I', b'D', b'=', b'a', b'b', 5, b'i', b'd', b'=', b'c', b'd',
];
let found = resolved("peer", 22, &shadowed, &lan);
assert_eq!(found[0].get(TXT_ID), Some("ab"));
}
}