use a HashMap to list interfaces of each resolved address

modify query example to use the new ServiceDetailed

Author: keepsimple1

examples/query.rs

@@ -18,36 +18,42 @@ use mdns_sd::{ServiceDaemon, ServiceEvent};
 fn main() {
     env_logger::builder().format_timestamp_millis().init();
 
-    // Create a daemon
-    let mdns = ServiceDaemon::new().expect("Failed to create daemon");
-
     let mut service_type = match std::env::args().nth(1) {
         Some(arg) => arg,
         None => {
             print_usage();
             return;
         }
     };
-
-    // Browse for a service type.
     service_type.push_str(".local.");
+
+    // Create a daemon
+    let mdns = ServiceDaemon::new().expect("Failed to create daemon");
+    mdns.use_service_detailed(true)
+        .expect("Failed to use service detailed");
+
+    // Browse for the service type
     let receiver = mdns.browse(&service_type).expect("Failed to browse");
 
     let now = std::time::Instant::now();
     while let Ok(event) = receiver.recv() {
         match event {
-            ServiceEvent::ServiceResolved(info) => {
+            ServiceEvent::ServiceDetailed(info) => {
                 println!(
                     "At {:?}: Resolved a new service: {}\n host: {}\n port: {}",
                     now.elapsed(),
-                    info.get_fullname(),
-                    info.get_hostname(),
-                    info.get_port(),
+                    info.fullname,
+                    info.host,
+                    info.port,
                 );
-                for addr in info.get_addresses().iter() {
-                    println!(" Address: {}", addr);
+                for (addr, interfaces) in info.addresses.iter() {
+                    println!(
+                        " Address: {} ({:?})",
+                        addr,
+                        interfaces.iter().map(|i| i.name()).collect::<Vec<_>>()
+                    );
                 }
-                for prop in info.get_properties().iter() {
+                for prop in info.txt_properties.iter() {
                     println!(" Property: {}", prop);
                 }
             }

src/service_daemon.rs

@@ -39,8 +39,7 @@ use crate::{
     },
     error::{e_fmt, Error, Result},
     service_info::{
-        split_sub_domain, valid_ip_on_intf, DnsRegistry, Probe, ScopedAddr, ServiceInfo,
-        ServiceStatus,
+        split_sub_domain, valid_ip_on_intf, DnsRegistry, Probe, ServiceInfo, ServiceStatus,
     },
     Receiver, ResolvedService, TxtProperties,
 };
@@ -1899,7 +1898,7 @@ impl Zeroconf {
             fullname: fullname.to_string(),
             host: String::new(),
             port: 0,
-            addresses: HashSet::new(),
+            addresses: HashMap::new(),
             txt_properties: TxtProperties::new(),
         };
 
@@ -1942,9 +1941,11 @@ impl Zeroconf {
                     if dns_a.expires_soon(now) {
                         trace!("Addr expired or expires soon: {}", dns_a.address());
                     } else {
-                        let intf_addr =
-                            ScopedAddr::new(dns_a.address(), dns_a.interface_id().clone());
-                        resolved_service.addresses.insert(intf_addr);
+                        resolved_service
+                            .addresses
+                            .entry(dns_a.address())
+                            .or_default()
+                            .push(dns_a.interface_id().clone());
                     }
                 }
             }

src/service_info.rs

@@ -12,7 +12,6 @@ use std::{
     collections::{HashMap, HashSet},
     convert::TryInto,
     fmt,
-    hash::Hash,
     net::{IpAddr, Ipv4Addr},
     str::FromStr,
 };
@@ -50,68 +49,6 @@ pub struct ServiceInfo {
     requires_probe: bool,
 }
 
-/// An IP address that is scoped to a specific interface.
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ScopedAddr {
-    addr: IpAddr,
-
-    /// The interface that this address is scoped to.
-    scope: InterfaceId,
-}
-
-impl ScopedAddr {
-    pub(crate) fn new(addr: IpAddr, interface: InterfaceId) -> Self {
-        Self {
-            addr,
-            scope: interface,
-        }
-    }
-
-    pub fn is_ipv4(&self) -> bool {
-        self.addr.is_ipv4()
-    }
-
-    pub fn is_ipv6(&self) -> bool {
-        self.addr.is_ipv6()
-    }
-
-    pub fn is_loopback(&self) -> bool {
-        self.addr.is_loopback()
-    }
-
-    pub fn ip(&self) -> &IpAddr {
-        &self.addr
-    }
-
-    /// Returns the interface which this address is scoped to.
-    ///
-    /// I.e. via which interface this address is detected.
-    pub fn scope(&self) -> &InterfaceId {
-        &self.scope
-    }
-}
-
-impl From<IpAddr> for ScopedAddr {
-    fn from(addr: IpAddr) -> Self {
-        Self {
-            addr,
-            scope: InterfaceId::default(), // Default interface ID, can be set later.
-        }
-    }
-}
-
-impl From<ScopedAddr> for IpAddr {
-    fn from(intf_addr: ScopedAddr) -> Self {
-        intf_addr.addr
-    }
-}
-
-impl fmt::Display for ScopedAddr {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{} ({})", self.addr, self.scope)
-    }
-}
-
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(crate) enum ServiceStatus {
     Probing,
@@ -435,11 +372,11 @@ impl ServiceInfo {
 
     /// Consumes self and returns a resolved service, i.e. a lite version of `ServiceInfo`.
     pub fn as_resolved_service(self) -> ResolvedService {
-        let addresses = self
+        let addresses: HashMap<IpAddr, Vec<InterfaceId>> = self
             .addresses
             .into_iter()
-            .map(|a| a.into())
-            .collect::<HashSet<ScopedAddr>>();
+            .map(|a| (a, Vec::new()))
+            .collect();
         ResolvedService {
             ty_domain: self.ty_domain,
             sub_ty_domain: self.sub_domain,
@@ -1239,8 +1176,10 @@ pub struct ResolvedService {
     /// Port of the service. I.e. TCP or UDP port.
     pub port: u16,
 
-    /// Addresses of the service. IPv4 or IPv6 addresses.
-    pub addresses: HashSet<ScopedAddr>,
+    /// Addresses of the service.
+    /// Each address maps to the list of interfaces on which the address is found.
+    /// The interface list is particularly useful for link-local IPv6 addresses.
+    pub addresses: HashMap<IpAddr, Vec<InterfaceId>>,
 
     /// Properties of the service, decoded from TXT record.
     pub txt_properties: TxtProperties,

tests/mdns_test.rs

@@ -2635,10 +2635,10 @@ fn test_use_service_detailed_v6() {
                     resolved.addresses.len() > 0,
                     "Should have at least one address"
                 );
-                let first_addr = resolved.addresses.into_iter().next().unwrap();
+                let (first_addr, interfaces) = resolved.addresses.into_iter().next().unwrap();
                 assert!(first_addr.is_ipv6(), "Address should be IPv6");
-                let interface_id = first_addr.scope();
-                println!("Resolved address: {:?}", first_addr.ip());
+                let interface_id = interfaces.get(0).unwrap();
+                println!("Resolved address: {:?}", first_addr);
                 println!(
                     "Interface ID of the first addr: {} index: {}",
                     interface_id.name(),