Something went wrong. Try again.
Bevy+Ratutui powered Monitoring of Pico-Strike devices
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221use 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<Res<DiscoverResponse>>, mut unique: ResMut<UniqueDevices>, 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::<DiscoverResponse>(); 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<Label<'a>>, srv: Option<&'a SRV<'a>>, txt: Option<&'a str>, ip: Option<IpAddr>,}
fn build_device_instance<'a>(resp: &'a Response<'a>) -> Option<InstanceDetails<'a>> { 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<FindDevices>, signal: Res<MdnsSignaler>, 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<Sender<Bytes>>);
fn create_mdns_socket() -> std::io::Result<Async<UdpSocket>> { 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::<Sender<Bytes>>(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::<UniqueDevices>() .add_systems(Startup, setup_mdns_task) .add_systems(PreUpdate, register_devices) .add_observer(on_find_devices); }}