eculocate

commit b65218b0f4de62eb66f6977a6b6d495b108908d3
parent 7e5e7c201d54c6ad078ed8e0f177bf756038ebcf
Author: Daniel Barlow <dan@telent.net>
Date:   Fri,  2 Jan 2026 21:50:16 +0000

remove Mdns prefix from Responder{,State}

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

2 files changed, 22 insertions(+), 22 deletions(-)
diff --git a/ecu-esp32/src/mdns.rs b/ecu-esp32/src/mdns.rs
@@ -28,23 +28,23 @@ const MDNS_ENDPOINT: IpEndpoint = IpEndpoint::new(MDNS_IP, MDNS_PORT);
 
 const CACHE_FLUSH : u16 = 1<<15;
 
-pub enum MdnsResponderState {
+pub enum ResponderState {
     Probing(Instant, usize),
     ProbeFailed,
     Announcing(Instant, usize),
     Running
 }
 
-pub struct MdnsResponder<'a> {
+pub struct Responder<'a> {
     sock : UdpSocket<'a>,
     database : Database,
-    pub state : MdnsResponderState
+    pub state : ResponderState
 }
 
-impl<'a> MdnsResponder<'a> {
+impl<'a> Responder<'a> {
     pub fn new(stack : Stack<'a>,
 	       mut sock: UdpSocket<'a>,
-	       records: Vec<Resource>) -> MdnsResponder<'a> {
+	       records: Vec<Resource>) -> Responder<'a> {
 
 	sock.set_hop_limit(Some(255));
 	log::info!("sock.bind(5353) res: {:?}", sock.bind(MDNS_PORT));
@@ -56,7 +56,7 @@ impl<'a> MdnsResponder<'a> {
 	Self {
 	    sock: sock,
 	    database: Database(records),
-	    state: MdnsResponderState::Probing(Instant::now(), 0)
+	    state: ResponderState::Probing(Instant::now(), 0)
 	}
     }
 
@@ -66,30 +66,30 @@ impl<'a> MdnsResponder<'a> {
 
     async fn advance_state(&mut self) {
 	match self.state {
-	    MdnsResponderState::Probing(next_when, number_sent) => {
+	    ResponderState::Probing(next_when, number_sent) => {
 		let ts = Instant::now();
 		if next_when < ts {
 		    if number_sent >= 3 {
-			self.state = MdnsResponderState::Announcing(ts, 0);
+			self.state = ResponderState::Announcing(ts, 0);
 		    } else {
 			self.send_probe().await;
-			self.state = MdnsResponderState::Probing(ts + Duration::from_millis(250), number_sent + 1);
+			self.state = ResponderState::Probing(ts + Duration::from_millis(250), number_sent + 1);
 		    }
 		}
 	    },
-	    MdnsResponderState::Announcing(next_when, number_sent) => {
+	    ResponderState::Announcing(next_when, number_sent) => {
 		let ts = Instant::now();
 		if next_when < ts {
 		    if number_sent > 6 {
-			self.state = MdnsResponderState::Running;
+			self.state = ResponderState::Running;
 		    } else {
 			self.advertise().await;
-			self.state = MdnsResponderState::Announcing(ts + Duration::from_millis(1000), number_sent + 1);
+			self.state = ResponderState::Announcing(ts + Duration::from_millis(1000), number_sent + 1);
 		    }
 		}
 	    },
-	    MdnsResponderState::Running => (),
-	    MdnsResponderState::ProbeFailed => (),
+	    ResponderState::Running => (),
+	    ResponderState::ProbeFailed => (),
 	}
     }
 
@@ -145,7 +145,7 @@ impl<'a> MdnsResponder<'a> {
     pub async fn may_recv(&mut self) -> bool {
 	self.advance_state().await;
 	match self.state {
-	    MdnsResponderState::ProbeFailed => false,
+	    ResponderState::ProbeFailed => false,
 	    _ => self.sock.may_recv()
 	}
     }
@@ -214,17 +214,17 @@ impl<'a> MdnsResponder<'a> {
 			     meta: &UdpMetadata) {
 
 	match self.state {
-	    MdnsResponderState::Probing(_,_) => {
+	    ResponderState::Probing(_,_) => {
 		for rr in message.answers() {
 		    info!("received answer {:?}", rr.name());
 		    if self.database.find(rr.name().to_string(), ResourceType::Wildcard)
 			.iter().any(|record| record.is_unique()) {
 			    info!("probe failed, received answer for {:?}", rr.name());
-			    self.state = MdnsResponderState::ProbeFailed;
+			    self.state = ResponderState::ProbeFailed;
 			}
 		}
 	    },
-	    MdnsResponderState::ProbeFailed => (),
+	    ResponderState::ProbeFailed => (),
 	    _ => {
 		let q_id = message.id();
 
diff --git a/ecu-esp32/src/wifi.rs b/ecu-esp32/src/wifi.rs
@@ -35,7 +35,7 @@ use esp_radio::{
 };
 
 use crate::mdns::Resource as DnsResource;
-use crate::mdns::{MdnsResponder, MdnsResponderState, RData, DISCOVERY_NAME};
+use crate::mdns;
 
 // When you are okay with using a nightly compiler it's better to use https://docs.rs/static_cell/2.1.0/static_cell/macro.make_static.html
 macro_rules! mk_static {
@@ -143,7 +143,7 @@ pub async fn start_wifi(spawner: &Spawner,
     );
 
     let mut serial = None;
-    let mut mdns_responder = MdnsResponder::new(
+    let mut mdns_responder = mdns::Responder::new(
 	stack, mdns_sock,
 	dns_records(my_address, serial)
     );
@@ -151,10 +151,10 @@ pub async fn start_wifi(spawner: &Spawner,
     loop {
 	loop {
 	    match mdns_responder.state {
-		MdnsResponderState::ProbeFailed =>  {
+		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 = MdnsResponderState::Probing(
+		    mdns_responder.state = mdns::ResponderState::Probing(
 			Instant::now() + Duration::from_millis(5000),
 			0
 		    );