use core::{ net::{IpAddr, Ipv4Addr, SocketAddr, SocketAddrV4}, time::Duration, }; use std::net::UdpSocket; use async_channel::{Sender, TryRecvError}; use async_io::{Async, Timer}; use bevy::{ app::{Plugin, PreUpdate, Startup}, ecs::{ error::Result, name::Name, observer::On, resource::Resource, system::{Commands, Res, ResMut}, }, tasks::IoTaskPool, }; use bytes::Bytes; use futures_concurrency::future::Race; use sachy_mdns::{ GROUP_SOCK_V4, MDNS_PORT, client::query_service, dns::{ label::Label, records::{QType, Record, SRV}, reqres::Response, traits::DnsParse, }, }; use socket2::{Domain, Protocol, Socket, Type}; use crate::device::{ Device, DeviceSocket, FindDevices, resources::{DiscoverResponse, UniqueDevices}, }; fn register_devices( incoming: Option>, mut unique: ResMut, mut commands: Commands, ) { if let Some(incoming) = incoming { let mut devices = Vec::new(); loop { match incoming.0.try_recv() { Ok(discovered) => { if let Ok(discovered) = Response::parse(&mut &discovered[..], &discovered) && let Some(instance) = build_device_instance(&discovered) { let device_addr = DeviceSocket { address: instance.srv.target.to_string(), port: instance.srv.port, ip: instance.ip, }; if !unique.0.contains(&device_addr) { unique.0.insert(device_addr.clone()); devices.push(( Device, Name::new(instance.host.to_string()), device_addr, )); } } } Err(TryRecvError::Closed) => { commands.remove_resource::(); break; } Err(TryRecvError::Empty) => break, } } if !devices.is_empty() { commands.spawn_batch(devices); } } } struct InstanceDetails<'a> { host: Label<'a>, srv: &'a SRV<'a>, ip: IpAddr, } #[derive(Debug, Default)] struct InstanceBuilder<'a> { name: Option>, srv: Option<&'a SRV<'a>>, txt: Option<&'a str>, ip: Option, } fn build_device_instance<'a>(resp: &'a Response<'a>) -> Option> { if resp .answers .iter() .any(|answer| answer.atype == QType::PTR && answer.name == "_picostrike._tcp.local") { let builder = resp.additional .iter() .fold(InstanceBuilder::default(), |mut instance, answer| { match &answer.record { Record::A(a) if instance.ip.is_none() => { instance.ip.replace(IpAddr::V4(a.address)); } Record::AAAA(aaaa) if instance.ip.is_none() => { instance.ip.replace(IpAddr::V6(aaaa.address)); } Record::SRV(srv) => { instance.name.replace(answer.name); instance.srv.replace(srv); } Record::TXT(txt) => { instance.txt = txt.text.first().copied(); } _ => {} } instance }); if let InstanceBuilder { name: Some(name), srv: Some(srv), ip: Some(ip), .. } = builder { return Some(InstanceDetails { host: name, srv, ip, }); } } None } fn on_find_devices(_trigger: On, signal: Res, mut commands: Commands) { let (resp_tx, resp_rx) = async_channel::bounded(64); signal.0.send_blocking(resp_tx).ok(); commands.insert_resource(DiscoverResponse(resp_rx)); } #[derive(Debug, Resource)] struct MdnsSignaler(pub Sender>); fn create_mdns_socket() -> std::io::Result> { let sock = Socket::new(Domain::IPV4, Type::DGRAM, Some(Protocol::UDP))?; sock.set_reuse_address(true)?; sock.set_nonblocking(true)?; sock.bind(&SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::UNSPECIFIED, MDNS_PORT)).into())?; let udp_socket = UdpSocket::from(sock); Async::new_nonblocking(udp_socket) } pub fn setup_mdns_task(mut commands: Commands) -> Result { let io = IoTaskPool::get(); let (signal_tx, signal_rx) = async_channel::bounded::>(1); let udp_socket = create_mdns_socket()?; io.spawn(async move { let mut buf = vec![0u8; 1028]; let mut query_buf = vec![0u8; 128]; let query = query_service("_picostrike._tcp.local", &mut query_buf).unwrap(); while let Ok(resp_tx) = signal_rx.recv().await { let send_fut = async { // Retry three times in case packets get lost coz UDP things for _ in 0..3 { udp_socket.send_to(query, GROUP_SOCK_V4).await.ok(); Timer::after(Duration::from_millis(250)).await; } }; let recv_fut = async { while let Ok((read, _)) = udp_socket.recv_from(&mut buf).await { let input = Bytes::copy_from_slice(&buf[..read]); if resp_tx.send(input).await.is_err() { break; } } }; let timer = async { Timer::after(Duration::from_millis(1000)).await; resp_tx.close(); }; (send_fut, recv_fut, timer, resp_tx.closed()).race().await; } }) .detach(); commands.insert_resource(MdnsSignaler(signal_tx)); Ok(()) } pub struct DevicesSetupPlugin; impl Plugin for DevicesSetupPlugin { fn build(&self, app: &mut bevy::app::App) { app.init_resource::() .add_systems(Startup, setup_mdns_task) .add_systems(PreUpdate, register_devices) .add_observer(on_find_devices); } }