Implement final hop ACK handling for direct packets to allow cancellable resends

Author: usrflo

src/Dispatcher.cpp

@@ -439,7 +439,13 @@ bool Dispatcher::resendPacket(mesh::Packet *packet) {
   // prepare error correction via potential retransmit:
   // re-send only direct routed packets that carry at least one relay hash, so that a
   // downstream relay's forward can be overheard to cancel this re-send.
-  if (packet->isRouteDirect() && packet->getPathHashCount() > 0 && packet->sending_attempts < getMaxResendAttempts()) {
+  // The final relay hop (path empty after removeSelfFromPath, flagged via
+  // final_hop_ack_resend) is the exception: there is no downstream forward to overhear, but
+  // the destination ACKs receipt. Allow exactly one resend there (sending_attempts == 0),
+  // cancellable by the returning ACK (see Mesh::cancelPendingFinalHopResend).
+  if (packet->isRouteDirect() && packet->sending_attempts < getMaxResendAttempts() &&
+      (packet->getPathHashCount() > 0 ||
+       (packet->final_hop_ack_resend && packet->sending_attempts == 0))) {
     packet->sending_attempts++;
 
     MESH_DEBUG_PRINTLN("Dispatcher::resendPacket %s attempt=%d", packet->getHashHex(),

src/Mesh.cpp

@@ -128,8 +128,20 @@ DispatcherAction Mesh::onRecvPacket(Packet* pkt) {
     }
 
     // For direct packets with no relay hashes (zero-hop, addressed straight to us),
-    // no further path-based processing applies
-    if (pkt->getPathHashCount() == 0) goto direct_path_done;
+    // no further path-based processing applies.
+    // A destination's receipt-ACK for a TXT_MSG we delivered as the final relay hop arrives
+    // exactly this way: zero-path direct, because the destination ACKs its immediate
+    // neighbour (it has no usable multi-hop return path to the originator, so the ACK only
+    // travels one hop). The ACK-relay branch below is gated on is_next_hop, which requires
+    // getPathHashCount() > 0 — unreachable for such an ACK. Cancel any pending final-hop
+    // resend here, before the early-exit, so the resend does not fire after a delivery the
+    // destination has already acknowledged.
+    if (pkt->getPathHashCount() == 0) {
+      if (pkt->getPayloadType() == PAYLOAD_TYPE_ACK) {
+        cancelPendingFinalHopResend();
+      }
+      goto direct_path_done;
+    }
 
     // check for 'early received' ACK
     if (pkt->getPayloadType() == PAYLOAD_TYPE_ACK) {
@@ -145,6 +157,12 @@ DispatcherAction Mesh::onRecvPacket(Packet* pkt) {
       if (pkt->getPayloadType() == PAYLOAD_TYPE_MULTIPART) {
         return forwardMultipartDirect(pkt);
       } else if (pkt->getPayloadType() == PAYLOAD_TYPE_ACK) {
+        // This ACK is addressed back along the return path with us as the next hop, i.e. it
+        // transits back through the very relay that delivered the original message. That is
+        // proof the destination received it: cancel any pending final-hop resend so we do not
+        // needlessly retransmit to the destination.
+        cancelPendingFinalHopResend();
+
         if (!_tables->wasSeen(pkt)) {  // don't retransmit!
           _tables->markSeen(pkt);
           removeSelfFromPath(pkt);
@@ -155,12 +173,25 @@ DispatcherAction Mesh::onRecvPacket(Packet* pkt) {
 
       if (!_tables->wasSeen(pkt)) {
         _tables->markSeen(pkt);
+
+        // Detect the final relay hop: only our own hash remained in the path, so after
+        // removeSelfFromPath() the destination is reached implicitly (it lives in the payload
+        // dest_hash, not as a relay hash) and getPathHashCount() becomes 0. The normal resend
+        // guard (getPathHashCount() > 0) would then suppress any retransmit, leaving a lost
+        // final-hop TX unrecoverable at the relay layer. TXT_MSG destinations ACK receipt, so
+        // mark this packet to allow exactly one ACK-cancellable resend (see resendPacket() and
+        // cancelPendingFinalHopResend()): the resend self-cancels on the returning ACK, so the
+        // destination is not flooded.
+        if (pkt->getPathHashCount() == 1 && pkt->getPayloadType() == PAYLOAD_TYPE_TXT_MSG) {
+          pkt->final_hop_ack_resend = true;
+        }
+
         removeSelfFromPath(pkt);
 
         MESH_DEBUG_PRINTLN("Mesh::onRecvPacket(): prepare to repeat packet %s", pkt->getHashHex());
 
         uint32_t d = getDirectRetransmitDelay(pkt);
-        return ACTION_RETRANSMIT_DELAYED(0, d);  // Routed traffic is HIGHEST priority 
+        return ACTION_RETRANSMIT_DELAYED(0, d);  // Routed traffic is HIGHEST priority
       }
     }
     return ACTION_RELEASE;   // this node is NOT the next hop (OR this packet has already been forwarded), so discard.
@@ -399,6 +430,34 @@ void Mesh::removeSelfFromPath(Packet* pkt) {
   }
 }
 
+void Mesh::cancelPendingFinalHopResend() {
+  // The destination has ACKed receipt. ACKs are produced in delivery order and (for the
+  // direct zero-path ACKs a companion sends) travel only one hop back to us, so the OLDEST
+  // pending final-hop resend corresponds to the message this ACK acknowledges (FIFO). Cancel
+  // exactly one — the earliest still-queued resend.
+  //
+  // The sending_attempts > 0 guard is essential: it selects only actual resends (the attempt
+  // counter is bumped in resendPacket() before re-queueing) and never the original final-hop
+  // forward, which is also flagged final_hop_ack_resend while it sits in the queue waiting to
+  // be TXed. Without it, an ACK arriving in that brief pre-TX window would cancel the delivery
+  // itself. (send_queue.add() appends, so index 0 is the oldest entry.)
+  //
+  // An in-flight resend (the 'outbound' packet, already on-air) is deliberately NOT touched:
+  // aborting a mid-TX send risks radio state, and the duplicate it delivers is harmless (the
+  // destination dedups via wasSeen). Only queued, not-yet-sent resends are cancelled.
+  for (int i = 0; i < _mgr->getOutboundTotal(); i++) {
+    Packet* queued = _mgr->getOutboundByIdx(i);
+    if (queued && queued->final_hop_ack_resend && queued->sending_attempts > 0 &&
+        queued->isRouteDirect() && queued->getPayloadType() == PAYLOAD_TYPE_TXT_MSG) {
+      MESH_DEBUG_PRINTLN("%s Mesh::cancelPendingFinalHopResend(): ACK heard, canceling oldest "
+                         "final-hop resend (queued) %s", getLogDateTime(), queued->getHashHex());
+      Packet* removed = _mgr->removeOutboundByIdx(i);
+      if (removed) _mgr->free(removed);
+      return;
+    }
+  }
+}
+
 DispatcherAction Mesh::routeRecvPacket(Packet* packet) {
   uint8_t n = packet->getPathHashCount();
   if (packet->isRouteFlood() && !packet->isMarkedDoNotRetransmit()

src/Mesh.h

@@ -31,6 +31,7 @@ class Mesh : public Dispatcher {
 
   void removeSelfFromPath(Packet* packet);
   void routeDirectRecvAcks(Packet* packet, uint32_t delay_millis);
+  void cancelPendingFinalHopResend();  // drop a queued final-hop resend when the destination's ACK transits back
   //void routeRecvAcks(Packet* packet, uint32_t delay_millis);
   DispatcherAction forwardMultipartDirect(Packet* pkt);
 

src/Packet.cpp

@@ -14,6 +14,7 @@ Packet::Packet() {
   memcpy(hash, ZERO_HASH, MAX_HASH_SIZE);
   memset(hash_hex, 0, sizeof(hash_hex));
   sending_attempts = 0;
+  final_hop_ack_resend = false;
 }
 
 bool Packet::isValidPathLen(uint8_t path_len) {

src/Packet.h

@@ -52,6 +52,9 @@ class Packet {
   uint8_t hash[MAX_HASH_SIZE];
   mutable char hash_hex[MAX_HASH_SIZE * 2 + 1];
   uint8_t sending_attempts;
+  bool final_hop_ack_resend;  // runtime-only: set when this node forwards the final relay hop
+                              // of an ACK-producing direct packet (e.g. TXT_MSG). Allows exactly
+                              // one ACK-cancellable resend from resendPacket(); not wire-serialized.
 
   /**
    * \brief calculate the hash of payload + type