fix consecutive renew packets being treated like retransmissions0.3.8

4 files changed, 21 insertions, 15 deletions

diff --git a/Cargo.lock b/Cargo.lock
index 4f4ebac..c04a5bd 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -384,7 +384,7 @@ dependencies = [
 
 [[package]]
 name = "rsdsl_dhcp6"
-version = "0.3.7"
+version = "0.3.8"
 dependencies = [
  "dhcproto",
  "rand",
diff --git a/Cargo.toml b/Cargo.toml
index 55866d4..e53ac7b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "rsdsl_dhcp6"
-version = "0.3.7"
+version = "0.3.8"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
diff --git a/src/client.rs b/src/client.rs
index 30e616c..47daf6f 100644
--- a/src/client.rs
+++ b/src/client.rs
@@ -147,19 +147,20 @@ impl Dhcp6c {
         }
     }
 
-    /// Waits for and returns the next packet to send.
-    pub async fn to_send(&mut self) -> Packet {
+    /// Waits for and returns the next packet to send
+    /// and a boolean indicating whether it is a retransmission.
+    pub async fn to_send(&mut self) -> (Packet, bool) {
         loop {
             tokio::select! {
-                packet = self.output_rx.recv() => return packet.expect("output channel is closed"),
+                packet = self.output_rx.recv() => return (packet.expect("output channel is closed"), false),
                 _ = self.restart_timer.tick() => if self.restart_counter > 0 { // TO+ event
-                    if let Some(packet) = self.timeout_positive() { return packet; }
+                    if let Some(packet) = self.timeout_positive() { return (packet, true); }
                 } else { // TO- event
-                    if let Some(packet) = self.timeout_negative() { return packet; }
+                    if let Some(packet) = self.timeout_negative() { return (packet, true); }
                 },
-                Some(_) = option_wait_renew(self.lease.as_ref()) => if let Some(packet) = self.t1() { return packet; },
-                Some(_) = option_wait_rebind(self.lease.as_ref()) => if let Some(packet) = self.t2() { return packet; },
-                Some(_) = option_wait_expire(self.lease.as_ref()) => if let Some(packet) = self.expire() { return packet; },
+                Some(_) = option_wait_renew(self.lease.as_ref()) => if let Some(packet) = self.t1() { return (packet, false); },
+                Some(_) = option_wait_rebind(self.lease.as_ref()) => if let Some(packet) = self.t2() { return (packet, false); },
+                Some(_) = option_wait_expire(self.lease.as_ref()) => if let Some(packet) = self.expire() { return (packet, false); },
             }
         }
     }
diff --git a/src/main.rs b/src/main.rs
index 6e5973b..20bf052 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -186,7 +186,7 @@ async fn main() -> Result<()> {
                 }
             },
 
-            packet = dhcp6c.to_send() => send_dhcp6(&mut dhcp6, &sock, packet).await,
+            packet = dhcp6c.to_send() => send_dhcp6(&mut dhcp6, &sock, packet.0, packet.1).await,
 
             result = dhcp6c_rx.changed() => {
                 result?;
@@ -407,15 +407,20 @@ fn handle(dhcp6: &mut Dhcp6, dhcp6c: &mut Dhcp6c, buf: &[u8]) -> Result<()> {
     Ok(())
 }
 
-async fn send_dhcp6(dhcp6: &mut Dhcp6, sock: &UdpSocket, packet: Packet) {
-    match do_send_dhcp6(dhcp6, sock, packet).await {
+async fn send_dhcp6(dhcp6: &mut Dhcp6, sock: &UdpSocket, packet: Packet, re_tx: bool) {
+    match do_send_dhcp6(dhcp6, sock, packet, re_tx).await {
         Ok(_) => {}
         Err(e) => println!("[warn] -> send error: {}", e),
     }
 }
 
-async fn do_send_dhcp6(dhcp6: &mut Dhcp6, sock: &UdpSocket, packet: Packet) -> Result<()> {
-    if packet != dhcp6.last_sent {
+async fn do_send_dhcp6(
+    dhcp6: &mut Dhcp6,
+    sock: &UdpSocket,
+    packet: Packet,
+    re_tx: bool,
+) -> Result<()> {
+    if !re_tx {
         dhcp6.xid = rand::random();
         dhcp6.xts = Instant::now();
     }