eculocate

commit ea6d7b32b4e167d84d563078b29c707f6108625d
parent d83e9871f9ac6db5a2bcb6d71b8594da06822566
Author: Daniel Barlow <dan@telent.net>
Date:   Thu,  1 Jan 2026 02:21:30 +0000

handle probe failures

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

1 file changed, 55 insertions(+), 32 deletions(-)
diff --git a/ecu-esp32/src/wifi.rs b/ecu-esp32/src/wifi.rs
@@ -74,8 +74,10 @@ enum MdnsResponderState {
 
 struct MdnsResponder<'a> {
     sock : UdpSocket<'a>,
+    serial: Option<u8>,
     database : DnsDatabase,
-    state : MdnsResponderState
+    state : MdnsResponderState,
+    my_address: [u8;4]
 }
 
 impl<'a> MdnsResponder<'a> {
@@ -102,8 +104,10 @@ impl<'a> MdnsResponder<'a> {
 
 	Self {
 	    sock,
+	    serial: None,
 	    database: DnsDatabase::create(my_address, None),
-	    state: MdnsResponderState::Probing(Instant::now(), 0)
+	    state: MdnsResponderState::Probing(Instant::now(), 0),
+	    my_address
 	}
     }
 
@@ -263,28 +267,54 @@ impl<'a> MdnsResponder<'a> {
 	}
     }
 
-    async fn send_responses(&self,
-			    message: &Message<'_,'_>,
-			    meta: &UdpMetadata) {
-
-	let q_id = message.id();
-
-	for q in message.questions() {
-	    let relevant = self.database.find(q.name().to_string(), q.ty());
-	    if relevant.len() > 0 {
-		log::info!("question {:?} {:?} {:?} flags {:?} from {:?}",
-			   q.name(), q.ty(), q.class(),
-			   message.flags().raw(),
-			   meta.endpoint);
-
-		let unicast = (q.class() & (1<<15)) != 0;
-		let legacy = meta.endpoint.port != 5353;
-		if legacy {
-		    self.send_response(q_id, meta.endpoint, Some(q), relevant).await
-		} else if unicast {
-		    self.send_response(0, meta.endpoint, None, relevant).await
-		} else {
-		    self.send_response(0, MDNS_ENDPOINT, None, relevant).await
+    pub fn increment_serial(&mut self) {
+	self.serial = match self.serial {
+	    None => Some(2),
+	    Some(n) => Some(n + 1)
+	};
+	info!("name collision, incremented serial {:?}", self.serial);
+	self.database = DnsDatabase::create(self.my_address, self.serial);
+    }
+
+    async fn process_message(&mut self,
+			     message: &Message<'_,'_>,
+			     meta: &UdpMetadata) {
+
+	match self.state {
+	    MdnsResponderState::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.increment_serial();
+			    self.state = MdnsResponderState::Probing(
+				Instant::now() + Duration::from_millis(5000), 0
+			    );
+			}
+		}
+	    },
+	    _ => {
+		let q_id = message.id();
+
+		for q in message.questions() {
+		    let relevant = self.database.find(q.name().to_string(), q.ty());
+		    if relevant.len() > 0 {
+			log::info!("question {:?} {:?} {:?} flags {:?} from {:?}",
+				   q.name(), q.ty(), q.class(),
+				   message.flags().raw(),
+				   meta.endpoint);
+
+			let unicast = (q.class() & (1<<15)) != 0;
+			let legacy = meta.endpoint.port != 5353;
+			if legacy {
+			    self.send_response(q_id, meta.endpoint, Some(q), relevant).await
+			} else if unicast {
+			    self.send_response(0, meta.endpoint, None, relevant).await
+			} else {
+			    self.send_response(0, MDNS_ENDPOINT, None, relevant).await
+			}
+		    }
 		}
 	    }
 	}
@@ -310,14 +340,7 @@ impl<'a> MdnsResponder<'a> {
 
 	    match message {
 		Result::Ok(message) => {
-		    match self.state {
-			MdnsResponderState::Probing(_,_) => {
-			    info!("probing. not responding to queries");
-			},
-			_ => {
-			    self.send_responses(&message, &meta).await;
-			}
-		    }
+		    self.process_message(&message, &meta).await;
 		},
 		Result::Err(err) => {
 		    log::error!("parsing dns message from {:?} : {:?}",