eculocate

commit bba38102a4e124023f68ae5f9e7dcd7639f503f7
parent b65218b0f4de62eb66f6977a6b6d495b108908d3
Author: Daniel Barlow <dan@telent.net>
Date:   Sun,  4 Jan 2026 23:22:38 +0000

new fn mdns::responder()

wraps up everything including socket creation. this was supposed to be
a thread but I haven't figured that out yet: it doesn't matter yet as
there isn't anmything else we're doing at the same time

Diffstat:
M
ecu-esp32/src/mdns.rs
 | 
62
+++++++++++++++++++++++++++++++++++++++++++++-----------------
M
ecu-esp32/src/wifi.rs
 | 
62
+++++++++++++-------------------------------------------------

2 files changed, 58 insertions(+), 66 deletions(-)
diff --git a/ecu-esp32/src/mdns.rs b/ecu-esp32/src/mdns.rs
@@ -4,13 +4,13 @@ use alloc::collections::BTreeSet;
 use crate::alloc::string::ToString;
 
 use embassy_net::{
-    udp::{UdpSocket, UdpMetadata},
+    udp::{UdpSocket, UdpMetadata, PacketMetadata},
     IpAddress,
     IpEndpoint,
     Stack
 };
 
-use embassy_time::{Duration, Instant};
+use embassy_time::{Timer, Duration, Instant};
 use esp_alloc as _;
 use esp_backtrace as _;
 
@@ -36,23 +36,15 @@ pub enum ResponderState {
 }
 
 pub struct Responder<'a> {
-    sock : UdpSocket<'a>,
+    sock : &'a UdpSocket<'a>,
     database : Database,
-    pub state : ResponderState
+    pub state : ResponderState,
 }
 
 impl<'a> Responder<'a> {
-    pub fn new(stack : Stack<'a>,
-	       mut sock: UdpSocket<'a>,
+    pub fn new(sock: &'a UdpSocket<'a>,
 	       records: Vec<Resource>) -> Responder<'a> {
 
-	sock.set_hop_limit(Some(255));
-	log::info!("sock.bind(5353) res: {:?}", sock.bind(MDNS_PORT));
-	log::info!(
-            "multicast_res: {:?}",
-            stack.join_multicast_group(MDNS_IP)
-	);
-
 	Self {
 	    sock: sock,
 	    database: Database(records),
@@ -60,10 +52,6 @@ impl<'a> Responder<'a> {
 	}
     }
 
-    pub fn set_records(&mut self, records: Vec<Resource>) {
-	self.database = Database(records);
-    }
-
     async fn advance_state(&mut self) {
 	match self.state {
 	    ResponderState::Probing(next_when, number_sent) => {
@@ -460,3 +448,43 @@ impl Database {
 	collect
     }
 }
+
+pub async fn responder(stack: Stack<'_>, records: Vec<Resource>)  {
+    let mut rx_buffer = [0u8; 4096];
+    let mut tx_buffer = [0u8; 4096];
+    let mut rx_meta = [PacketMetadata::EMPTY; 512];
+    let mut tx_meta = [PacketMetadata::EMPTY; 512];
+
+    let mut sock = UdpSocket::new(
+        stack,
+        &mut rx_meta,
+        &mut rx_buffer,
+        &mut tx_meta,
+        &mut tx_buffer,
+    );
+    sock.set_hop_limit(Some(255));
+    log::info!("sock.bind(5353) res: {:?}", sock.bind(MDNS_PORT));
+    log::info!(
+        "multicast_res: {:?}",
+        stack.join_multicast_group(MDNS_IP)
+    );
+
+    let mut mdns_responder = Responder::new(&mut sock, records);
+
+    loop {
+	match mdns_responder.state {
+	    ResponderState::ProbeFailed =>  {
+		sock.close();
+		_ = stack.leave_multicast_group(MDNS_IP);
+		return ;
+	    },
+	    _ => {
+		if mdns_responder.may_recv().await {
+		    mdns_responder.process_packet().await;
+		} else {
+		    Timer::after(Duration::from_millis(50)).await;
+		}
+	    }
+	}
+    }
+}
diff --git a/ecu-esp32/src/wifi.rs b/ecu-esp32/src/wifi.rs
@@ -10,11 +10,10 @@ use alloc::format;
 use embassy_executor::Spawner;
 use embassy_net::{
     Runner,
-    StackResources,
-    udp::{PacketMetadata, UdpSocket},
+    StackResources
 };
 
-use embassy_time::{Duration, Timer, Instant};
+use embassy_time::{Duration, Timer};
 use esp_alloc as _;
 use esp_backtrace as _;
 use esp_hal::{
@@ -34,6 +33,8 @@ use esp_radio::{
     },
 };
 
+use log::info;
+
 use crate::mdns::Resource as DnsResource;
 use crate::mdns;
 
@@ -130,54 +131,17 @@ pub async fn start_wifi(spawner: &Spawner,
         Timer::after(Duration::from_millis(500)).await;
     }
 
-    let mut rx_buffer = [0u8; 4096];
-    let mut tx_buffer = [0u8; 4096];
-    let mut rx_meta = [PacketMetadata::EMPTY; 512];
-    let mut tx_meta = [PacketMetadata::EMPTY; 512];
-    let mdns_sock = UdpSocket::new(
-        stack,
-        &mut rx_meta,
-        &mut rx_buffer,
-        &mut tx_meta,
-        &mut tx_buffer,
-    );
-
     let mut serial = None;
-    let mut mdns_responder = mdns::Responder::new(
-	stack, mdns_sock,
-	dns_records(my_address, serial)
-    );
-
     loop {
-	loop {
-	    match mdns_responder.state {
-		mdns::ResponderState::ProbeFailed =>  {
-		    serial = match serial { None => Some(2), Some(n) => Some(n+1) };
-		    mdns_responder.set_records(dns_records(my_address, serial));
-		    mdns_responder.state = mdns::ResponderState::Probing(
-			Instant::now() + Duration::from_millis(5000),
-			0
-		    );
-		},
-		_ => ()
-	    };
-	    if mdns_responder.may_recv().await {
-		mdns_responder.process_packet().await;
-	    } else {
-		Timer::after(Duration::from_millis(50)).await;
-            }
-	}
-    }
-
-    // _ = stack.leave_multicast_group(MDNS_IP);
-    // sock.close();
-    // drop(sock);
-
-    // loop {
-    //     Timer::after(Duration::from_millis(1_000)).await;
-    //     log::info!("bump");
-    // }
-
+	let mdns_thread = mdns::responder(
+	    stack,
+	    dns_records(my_address, serial)
+	);
+	mdns_thread.await;
+	serial = match serial { None => Some(2), Some(n) => Some(n+1) };
+	info!("probe failed, restarting with incremented serial {:?}", serial);
+        Timer::after(Duration::from_millis(5000)).await;
+    };
 }
 
 #[embassy_executor::task]