Next Hop-based routing with fallback to flooding

src/main.cpp

@@ -653,9 +653,9 @@ void setup()
     // but we need to do this after main cpu init (esp32setup), because we need the random seed set
     nodeDB = new NodeDB;
 
-    // If we're taking on the repeater role, use flood router and turn off 3V3_S rail because peripherals are not needed
+    // If we're taking on the repeater role, use NextHopRouter and turn off 3V3_S rail because peripherals are not needed
     if (config.device.role == meshtastic_Config_DeviceConfig_Role_REPEATER) {
-        router = new FloodingRouter();
+        router = new NextHopRouter();
 #ifdef PIN_3V3_EN
         digitalWrite(PIN_3V3_EN, LOW);
 #endif

src/mesh/FloodingRouter.cpp

@@ -13,31 +13,25 @@ FloodingRouter::FloodingRouter() {}
 ErrorCode FloodingRouter::send(meshtastic_MeshPacket *p)
 {
     // Add any messages _we_ send to the seen message list (so we will ignore all retransmissions we see)
-    wasSeenRecently(p); // FIXME, move this to a sniffSent method
+    p->relay_node = nodeDB->getLastByteOfNodeNum(getNodeNum()); // First set the relayer to us
+    wasSeenRecently(p);                                         // FIXME, move this to a sniffSent method
 
     return Router::send(p);
 }
 
 bool FloodingRouter::shouldFilterReceived(const meshtastic_MeshPacket *p)
 {
     if (wasSeenRecently(p)) { // Note: this will also add a recent packet record
-        printPacket("Ignore dupe incoming msg", p);
-        rxDupe++;
-        if (config.device.role != meshtastic_Config_DeviceConfig_Role_ROUTER &&
-            config.device.role != meshtastic_Config_DeviceConfig_Role_REPEATER) {
-            // cancel rebroadcast of this message *if* there was already one, unless we're a router/repeater!
-            if (Router::cancelSending(p->from, p->id))
-                txRelayCanceled++;
-        }
-
         /* If the original transmitter is doing retransmissions (hopStart equals hopLimit) for a reliable transmission, e.g., when
-        the ACK got lost, we will handle the packet again to make sure it gets an ACK to its packet. */
+        the ACK got lost, we will handle the packet again to make sure it gets an implicit ACK. */
         bool isRepeated = p->hop_start > 0 && p->hop_start == p->hop_limit;
         if (isRepeated) {
             LOG_DEBUG("Repeated reliable tx");
-            if (!perhapsRebroadcast(p) && isToUs(p) && p->want_ack) {
-                sendAckNak(meshtastic_Routing_Error_NONE, getFrom(p), p->id, p->channel, 0);
-            }
+            // Check if it's still in the Tx queue, if not, we have to relay it again
+            if (!findInTxQueue(p->from, p->id))
+                perhapsRebroadcast(p);
+        } else {
+            perhapsCancelDupe(p);
         }
 
         return true;
@@ -46,13 +40,25 @@ bool FloodingRouter::shouldFilterReceived(const meshtastic_MeshPacket *p)
     return Router::shouldFilterReceived(p);
 }
 
+void FloodingRouter::perhapsCancelDupe(const meshtastic_MeshPacket *p)
+{
+    printPacket("Ignore dupe incoming msg", p);
+    rxDupe++;
+    if (config.device.role != meshtastic_Config_DeviceConfig_Role_ROUTER &&
+        config.device.role != meshtastic_Config_DeviceConfig_Role_REPEATER) {
+        // cancel rebroadcast of this message *if* there was already one, unless we're a router/repeater!
+        if (Router::cancelSending(p->from, p->id))
+            txRelayCanceled++;
+    }
+}
+
 bool FloodingRouter::isRebroadcaster()
 {
     return config.device.role != meshtastic_Config_DeviceConfig_Role_CLIENT_MUTE &&
            config.device.rebroadcast_mode != meshtastic_Config_DeviceConfig_RebroadcastMode_NONE;
 }
 
-bool FloodingRouter::perhapsRebroadcast(const meshtastic_MeshPacket *p)
+void FloodingRouter::perhapsRebroadcast(const meshtastic_MeshPacket *p)
 {
     if (!isToUs(p) && (p->hop_limit > 0) && !isFromUs(p)) {
         if (p->id != 0) {
@@ -72,17 +78,13 @@ bool FloodingRouter::perhapsRebroadcast(const meshtastic_MeshPacket *p)
                 // Note: we are careful to resend using the original senders node id
                 // We are careful not to call our hooked version of send() - because we don't want to check this again
                 Router::send(tosend);
-
-                return true;
             } else {
                 LOG_DEBUG("No rebroadcast: Role = CLIENT_MUTE or Rebroadcast Mode = NONE");
             }
         } else {
             LOG_DEBUG("Ignore 0 id broadcast");
         }
     }
-
-    return false;
 }
 
 void FloodingRouter::sniffReceived(const meshtastic_MeshPacket *p, const meshtastic_Routing *c)

src/mesh/FloodingRouter.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include "PacketHistory.h"
 #include "Router.h"
 
 /**
@@ -26,14 +25,11 @@
   Any entries in recentBroadcasts that are older than X seconds (longer than the
   max time a flood can take) will be discarded.
  */
-class FloodingRouter : public Router, protected PacketHistory
+class FloodingRouter : public Router
 {
   private:
-    bool isRebroadcaster();
-
-    /** Check if we should rebroadcast this packet, and do so if needed
-     * @return true if rebroadcasted */
-    bool perhapsRebroadcast(const meshtastic_MeshPacket *p);
+    /* Check if we should rebroadcast this packet, and do so if needed */
+    void perhapsRebroadcast(const meshtastic_MeshPacket *p);
 
   public:
     /**
@@ -62,4 +58,10 @@ class FloodingRouter : public Router, protected PacketHistory
      * Look for broadcasts we need to rebroadcast
      */
     virtual void sniffReceived(const meshtastic_MeshPacket *p, const meshtastic_Routing *c) override;
+
+    /* Call when receiving a duplicate packet to check whether we should cancel a packet in the Tx queue */
+    void perhapsCancelDupe(const meshtastic_MeshPacket *p);
+
+    // Return true if we are a rebroadcaster
+    bool isRebroadcaster();
 };

src/mesh/MeshPacketQueue.cpp

@@ -107,6 +107,19 @@ meshtastic_MeshPacket *MeshPacketQueue::remove(NodeNum from, PacketId id)
     return NULL;
 }
 
+/* Attempt to find a packet from this queue. Return true if it was found. */
+bool MeshPacketQueue::find(NodeNum from, PacketId id)
+{
+    for (auto it = queue.begin(); it != queue.end(); it++) {
+        auto p = (*it);
+        if (getFrom(p) == from && p->id == id) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
 /** Attempt to find and remove a packet from this queue.  Returns the packet which was removed from the queue */
 bool MeshPacketQueue::replaceLowerPriorityPacket(meshtastic_MeshPacket *p)
 {

src/mesh/MeshPacketQueue.h

@@ -37,4 +37,7 @@ class MeshPacketQueue
 
     /** Attempt to find and remove a packet from this queue.  Returns the packet which was removed from the queue */
     meshtastic_MeshPacket *remove(NodeNum from, PacketId id);
-};
+
+    /* Attempt to find a packet from this queue. Return true if it was found. */
+    bool find(NodeNum from, PacketId id);
+};

src/mesh/MeshService.cpp

@@ -190,7 +190,9 @@ void MeshService::handleToRadio(meshtastic_MeshPacket &p)
         return;
     }
 #endif
-    p.from = 0; // We don't let phones assign nodenums to their sent messages
+    p.from = 0;                          // We don't let clients assign nodenums to their sent messages
+    p.next_hop = NO_NEXT_HOP_PREFERENCE; // We don't let clients assign next_hop to their sent messages
+    p.relay_node = NO_RELAY_NODE;        // We don't let clients assign relay_node to their sent messages
 
     if (p.id == 0)
         p.id = generatePacketId(); // If the phone didn't supply one, then pick one

src/mesh/MeshTypes.h

@@ -40,6 +40,11 @@ enum RxSource {
 /// We normally just use max 3 hops for sending reliable messages
 #define HOP_RELIABLE 3
 
+// For old firmware or when falling back to flooding, there is no next-hop preference
+#define NO_NEXT_HOP_PREFERENCE 0
+// For old firmware there is no relay node set
+#define NO_RELAY_NODE 0
+
 typedef int ErrorCode;
 
 /// Alloc and free packets to our global, ISR safe pool