Use the hop_limit field of MeshPacket to limit max delivery depth in

the mesh.

src/mesh/FloodingRouter.cpp

@@ -2,8 +2,6 @@
 #include "configuration.h"
 #include "mesh-pb-constants.h"
 
-static bool supportFlooding = true; // Sometimes to simplify debugging we want jusT simple broadcast only
-
 FloodingRouter::FloodingRouter() : toResend(MAX_NUM_NODES) {}
 
 /**
@@ -13,9 +11,7 @@ FloodingRouter::FloodingRouter() : toResend(MAX_NUM_NODES) {}
  */
 ErrorCode FloodingRouter::send(MeshPacket *p)
 {
-    // We update our table of recent broadcasts, even for messages we send
-    if (supportFlooding)
-        wasSeenRecently(p);
+    wasSeenRecently(p);
 
     return Router::send(p);
 }
@@ -29,28 +25,28 @@ ErrorCode FloodingRouter::send(MeshPacket *p)
  */
 void FloodingRouter::handleReceived(MeshPacket *p)
 {
-    if (supportFlooding) {
-        if (wasSeenRecently(p)) {
-            DEBUG_MSG("Ignoring incoming floodmsg, because we've already seen it\n");
-            packetPool.release(p);
-        } else {
-            if (p->to == NODENUM_BROADCAST) {
-                if (p->id != 0) {
-                    MeshPacket *tosend = packetPool.allocCopy(*p); // keep a copy because we will be sending it
+    if (wasSeenRecently(p)) {
+        DEBUG_MSG("Ignoring incoming msg, because we've already seen it\n");
+        packetPool.release(p);
+    } else {
+        if (p->to == NODENUM_BROADCAST && p->hop_limit > 0) {
+            if (p->id != 0) {
+                MeshPacket *tosend = packetPool.allocCopy(*p); // keep a copy because we will be sending it
 
-                    DEBUG_MSG("Rebroadcasting received floodmsg to neighbors, fr=0x%x,to=0x%x,id=%d\n", p->from, p->to, p->id);
-                    // 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);
+                tosend->hop_limit--; // bump down the hop count
 
-                } else {
-                    DEBUG_MSG("Ignoring a simple (0 hop) broadcast\n");
-                }
+                DEBUG_MSG("Rebroadcasting received floodmsg to neighbors, fr=0x%x,to=0x%x,id=%d,hop_limit=%d\n", p->from, p->to,
+                          p->id, tosend->hop_limit);
+                // 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);
+
+            } else {
+                DEBUG_MSG("Ignoring a simple (0 id) broadcast\n");
             }
-
-            // handle the packet as normal
-            Router::handleReceived(p);
         }
-    } else
+
+        // handle the packet as normal
         Router::handleReceived(p);
+    }
 }

src/mesh/MeshService.cpp

@@ -285,6 +285,7 @@ MeshPacket *MeshService::allocForSending()
     p->which_payload = MeshPacket_decoded_tag; // Assume payload is decoded at start.
     p->from = nodeDB.getNodeNum();
     p->to = NODENUM_BROADCAST;
+    p->hop_limit = HOP_MAX;
     p->id = generatePacketId();
     p->rx_time = getValidTime(); // Just in case we process the packet locally - make sure it has a valid timestamp
 

src/mesh/MeshTypes.h

@@ -14,6 +14,15 @@ typedef uint8_t PacketId; // A packet sequence number
 #define ERRNO_NO_INTERFACES 33
 #define ERRNO_UNKNOWN 32 // pick something that doesn't conflict with RH_ROUTER_ERROR_UNABLE_TO_DELIVER
 
+/**
+ * the max number of hops a message can pass through, used as the default max for hop_limit in MeshPacket.
+ *
+ * We reserve 3 bits in the header so this could be up to 7, but given the high range of lora and typical usecases, keeping
+ * maxhops to 3 should be fine for a while.  This also serves to prevent routing/flooding attempts to be attempted for
+ * too long.
+ **/
+#define HOP_MAX 3
+
 typedef int ErrorCode;
 
 /// Alloc and free packets to our global, ISR safe pool

src/mesh/RadioInterface.cpp

@@ -115,8 +115,9 @@ size_t RadioInterface::beginSending(MeshPacket *p)
 
     h->from = p->from;
     h->to = p->to;
-    h->flags = 0;
     h->id = p->id;
+    assert(p->hop_limit <= HOP_MAX);
+    h->flags = p->hop_limit;
 
     // if the sender nodenum is zero, that means uninitialized
     assert(h->from);

src/mesh/RadioInterface.h

@@ -16,7 +16,14 @@
  * wtih the old radiohead implementation.
  */
 typedef struct {
-    uint8_t to, from, id, flags;
+    uint8_t to, from, id;
+
+    /**
+     * Usage of flags:
+     *
+     * The bottom three bits of flags are use to store hop_limit when sent over the wire.
+     **/
+    uint8_t flags;
 } PacketHeader;
 
 typedef enum {

src/mesh/RadioLibInterface.cpp

@@ -288,13 +288,16 @@ void RadioLibInterface::handleReceiveInterrupt()
 
             rxGood++;
             if (h->to != 255 && h->to != ourAddr) {
-                DEBUG_MSG("ignoring packet not sent to us\n");
+                DEBUG_MSG("FIXME - should snoop packet not sent to us\n");
             } else {
                 MeshPacket *mp = packetPool.allocZeroed();
 
                 mp->from = h->from;
                 mp->to = h->to;
                 mp->id = h->id;
+                assert(HOP_MAX <= 0x07); // If hopmax changes, carefully check this code
+                mp->hop_limit = h->flags & 0x07;
+
                 addReceiveMetadata(mp);
 
                 mp->which_payload = MeshPacket_encrypted_tag; // Mark that the payload is still encrypted at this point

src/mesh/Router.h

@@ -59,7 +59,8 @@ class Router
      * Handle any packet that is received by an interface on this node.
      * Note: some packets may merely being passed through this node and will be forwarded elsewhere.
      *
-     * Note: this method will free the provided packet
+     * Note: this packet will never be called for messages sent/generated by this node.
+     * Note: this method will free the provided packet.
      */
     virtual void handleReceived(MeshPacket *p);
 };