tunnet-core 0.7.0

Core mesh runtime for Tunnet (identity, routing, streams, sync)
Documentation
use std::collections::{HashMap, HashSet};
use std::net::Ipv4Addr;
use std::sync::Arc;

use mdns_sd::{ServiceDaemon, ServiceEvent};
use parking_lot::Mutex;
use tokio::sync::mpsc;

use super::types::{LocalService, is_mesh_ipv4};

const META_QUERY: &str = "_services._dns-sd._udp.local.";
pub const DEFAULT_TTL: u32 = 120;

#[derive(Debug, Clone)]
pub enum ScanEvent {
    Upsert(LocalService),
    Remove { fullname: String },
}

pub type AdvertisedSet = Arc<Mutex<HashSet<String>>>;

pub fn spawn_scanner(
    daemon: ServiceDaemon,
    mesh_ip: Ipv4Addr,
    advertised: AdvertisedSet,
    tx: mpsc::UnboundedSender<ScanEvent>,
) -> anyhow::Result<()> {
    let meta_rx = daemon
        .browse(META_QUERY)
        .map_err(|e| anyhow::anyhow!("mdns browse meta: {e}"))?;

    let browsing: Arc<Mutex<HashSet<String>>> = Arc::new(Mutex::new(HashSet::new()));

    tokio::spawn(async move {
        loop {
            match meta_rx.recv_async().await {
                Ok(ServiceEvent::ServiceFound(_meta, service_type)) => {
                    let ty = normalize_type(&service_type);
                    if ty == META_QUERY || !ty.contains("._") {
                        continue;
                    }
                    {
                        let mut guard = browsing.lock();
                        if !guard.insert(ty.clone()) {
                            continue;
                        }
                    }
                    spawn_type_browser(daemon.clone(), ty, mesh_ip, advertised.clone(), tx.clone());
                }
                Ok(other) => {
                    tracing::trace!(?other, "mdns meta event");
                }
                Err(_) => {
                    tracing::debug!("mdns meta browse ended");
                    break;
                }
            }
        }
    });

    Ok(())
}

fn spawn_type_browser(
    daemon: ServiceDaemon,
    service_type: String,
    mesh_ip: Ipv4Addr,
    advertised: AdvertisedSet,
    tx: mpsc::UnboundedSender<ScanEvent>,
) {
    let Ok(rx) = daemon.browse(&service_type) else {
        tracing::warn!(%service_type, "mdns browse service type failed");
        return;
    };
    tracing::debug!(%service_type, "browsing mDNS service type");
    tokio::spawn(async move {
        while let Ok(ev) = rx.recv_async().await {
            handle_service_event(ev, mesh_ip, &advertised, &tx);
        }
    });
}

fn handle_service_event(
    event: ServiceEvent,
    mesh_ip: Ipv4Addr,
    advertised: &AdvertisedSet,
    tx: &mpsc::UnboundedSender<ScanEvent>,
) {
    match event {
        ServiceEvent::ServiceResolved(info) => {
            let fullname = info.get_fullname().to_string();
            if advertised.lock().contains(&fullname.to_lowercase()) {
                return;
            }
            let addrs = info.get_addresses_v4();
            if addrs.iter().any(|a| *a == mesh_ip || is_mesh_ipv4(*a)) {
                tracing::trace!(%fullname, "skip mesh/relayed mDNS service");
                return;
            }
            let Some(lan_ip) = addrs.into_iter().next() else {
                return;
            };
            let service_type = info.ty_domain.clone();
            let instance_name = super::types::instance_name_from_fullname(&fullname, &service_type);
            let mut txt = HashMap::new();
            for prop in info.get_properties().iter() {
                txt.insert(prop.key().to_string(), prop.val_str().to_string());
            }
            let svc = LocalService {
                service_type,
                instance_name,
                fullname,
                lan_ip,
                port: info.get_port(),
                txt_records: txt,
                host: info.get_hostname().to_string(),
            };
            tracing::info!(
                fullname = %svc.fullname,
                lan = %svc.lan_ip,
                port = svc.port,
                "mDNS service discovered"
            );
            let _ = tx.send(ScanEvent::Upsert(svc));
        }
        ServiceEvent::ServiceRemoved(_ty, fullname) => {
            if advertised.lock().contains(&fullname.to_lowercase()) {
                return;
            }
            tracing::info!(%fullname, "mDNS service removed");
            let _ = tx.send(ScanEvent::Remove { fullname });
        }
        _ => {}
    }
}

fn normalize_type(s: &str) -> String {
    let mut t = s.trim().to_lowercase();
    if !t.ends_with('.') {
        t.push('.');
    }
    t
}