Next Hop-based routing with fallback to flooding

src/main.cpp

@@ -662,6 +662,9 @@ void setup()
     }
     nodeStatus->observe(&nodeDB.newStatus);
 
+    config.lora.next_hop_routing = true; // FIXME - remove this before merging
+    LOG_INFO("USING NEXT-HOP ROUTING\n");
+
     service.init();
 
     // Now that the mesh service is created, create any modules

src/mesh/FloodingRouter.cpp

@@ -71,4 +71,4 @@ void FloodingRouter::sniffReceived(const meshtastic_MeshPacket *p, const meshtas
     }
     // handle the packet as normal
     Router::sniffReceived(p, c);
-}
+}

src/mesh/NextHopRouter.cpp

@@ -0,0 +1,101 @@
+#include "NextHopRouter.h"
+
+NextHopRouter::NextHopRouter() {}
+
+/**
+ * Send a packet
+ */
+ErrorCode NextHopRouter::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->next_hop = getNextHop(p->to, p->relay_node); // set the next hop
+    LOG_DEBUG("Setting next hop for packet with dest %x to %x\n", p->to, p->next_hop);
+
+    return Router::send(p);
+}
+
+bool NextHopRouter::shouldFilterReceived(const meshtastic_MeshPacket *p)
+{
+    if (wasSeenRecently(p)) { // Note: this will also add a recent packet record
+        if (p->next_hop == nodeDB.getLastByteOfNodeNum(getNodeNum())) {
+            LOG_DEBUG("Ignoring incoming msg, because we've already seen it.\n");
+        } else {
+            LOG_DEBUG("Ignoring incoming msg, because we've already seen it and cancel any outgoing packets.\n");
+            Router::cancelSending(p->from, p->id);
+        }
+        return true;
+    }
+
+    return Router::shouldFilterReceived(p);
+}
+
+void NextHopRouter::sniffReceived(const meshtastic_MeshPacket *p, const meshtastic_Routing *c)
+{
+    bool isAck =
+        ((c && c->error_reason == meshtastic_Routing_Error_NONE)); // consider only ROUTING_APP message without error as ACK
+    if (isAck) {
+        // Update next-hop of this successful transmission to the relay node, but ONLY if "from" is not 0 or ourselves (means
+        // implicit ACK or someone is relaying our ACK)
+        if (p->from != 0 && p->from != getNodeNum()) {
+            if (p->relay_node) {
+                meshtastic_NodeInfoLite *sentTo = nodeDB.getMeshNode(p->from);
+                if (sentTo) {
+                    LOG_DEBUG("Update next hop of 0x%x to 0x%x based on received ACK.\n", p->from, p->relay_node);
+                    sentTo->next_hop = p->relay_node;
+                }
+            }
+        }
+    }
+
+    if (config.device.role != meshtastic_Config_DeviceConfig_Role_CLIENT_MUTE) {
+        if ((p->to != getNodeNum()) && (getFrom(p) != getNodeNum())) {
+            if (p->next_hop == nodeDB.getLastByteOfNodeNum(getNodeNum())) {
+                meshtastic_MeshPacket *tosend = packetPool.allocCopy(*p); // keep a copy because we will be sending it
+                LOG_INFO("Relaying received next-hop message coming from %x\n", p->relay_node);
+
+                if (p->which_payload_variant == meshtastic_MeshPacket_decoded_tag) {
+                    // If it is a traceRoute request, update the route that it went via me
+                    if (traceRouteModule && traceRouteModule->wantPacket(tosend))
+                        traceRouteModule->updateRoute(tosend);
+                    // If it is a neighborInfo packet, update last_sent_by_id
+                    if (neighborInfoModule && neighborInfoModule->wantPacket(tosend))
+                        neighborInfoModule->updateLastSentById(tosend);
+                }
+
+                tosend->hop_limit--; // bump down the hop count
+                NextHopRouter::send(tosend);
+            } else if (p->next_hop == NO_NEXT_HOP_PREFERENCE) {
+                // No preference for next hop, use FloodingRouter
+                LOG_DEBUG("No preference for next hop, using FloodingRouter\n");
+                FloodingRouter::sniffReceived(p, c);
+            } // else don't relay
+        }
+    } else {
+        LOG_DEBUG("Not rebroadcasting. Role = Role_ClientMute\n");
+    }
+    // handle the packet as normal
+    Router::sniffReceived(p, c);
+}
+
+/**
+ * Get the next hop for a destination, given the relay node
+ * @return the node number of the next hop, 0 if no preference (fallback to FloodingRouter)
+ */
+uint8_t NextHopRouter::getNextHop(NodeNum to, uint8_t relay_node)
+{
+    meshtastic_NodeInfoLite *node = nodeDB.getMeshNode(to);
+    if (node) {
+        // We are careful not to return the relay node as the next hop
+        if (node->next_hop != relay_node) {
+            LOG_DEBUG("Next hop for 0x%x is 0x%x\n", to, node->next_hop);
+            return node->next_hop;
+        } else {
+            LOG_WARN("Next hop for 0x%x is 0x%x, same as relayer; setting as no preference\n", to, node->next_hop);
+            return NO_NEXT_HOP_PREFERENCE;
+        }
+    } else {
+        return NO_NEXT_HOP_PREFERENCE;
+    }
+}

src/mesh/NextHopRouter.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#include "FloodingRouter.h"
+
+/*
+  Router which only relays if it is the next hop for a packet.
+  The next hop is set by the relay node of a packet, which bases this on information from either the NeighborInfoModule, or a
+  previous successful delivery via flooding. It is only used for DMs and not used for broadcasts. Using the NeighborInfoModule, it
+  can derive the next hop of neighbors and that of neighbors of neighbors. For others, it has no information in the beginning,
+  which results into falling back to the FloodingRouter. Upon successful delivery via flooding, it updates the next hop of the
+  recipient to the node that last relayed the ACK to us. When the ReliableRouter is doing retransmissions, at the last retry, it
+  will reset the next hop, in order to fall back to the FloodingRouter.
+*/
+class NextHopRouter : public FloodingRouter
+{
+  public:
+    /**
+     * Constructor
+     *
+     */
+    NextHopRouter();
+
+    /**
+     * Send a packet
+     * @return an error code
+     */
+    virtual ErrorCode send(meshtastic_MeshPacket *p) override;
+
+  protected:
+    /**
+     * Should this incoming filter be dropped?
+     *
+     * Called immediately on reception, before any further processing.
+     * @return true to abandon the packet
+     */
+    virtual bool shouldFilterReceived(const meshtastic_MeshPacket *p) override;
+
+    /**
+     * Look for packets we need to relay
+     */
+    virtual void sniffReceived(const meshtastic_MeshPacket *p, const meshtastic_Routing *c) override;
+
+    constexpr static uint8_t NO_NEXT_HOP_PREFERENCE = 0;
+
+  private:
+    /**
+     * Get the next hop for a destination, given the relay node
+     * @return the node number of the next hop, 0 if no preference (fallback to FloodingRouter)
+     */
+    uint8_t getNextHop(NodeNum to, uint8_t relay_node);
+};

src/mesh/NodeDB.cpp

@@ -821,6 +821,14 @@ void NodeDB::updateFrom(const meshtastic_MeshPacket &mp)
         if (mp.decoded.portnum == meshtastic_PortNum_NODEINFO_APP) {
             info->channel = mp.channel;
         }
+
+        // If this packet didn't travel any hops, then it was sent directly to us, so we know what to use as next hop to this node
+        if (mp.original_hop_limit == mp.hop_limit) {
+            info->next_hop = getLastByteOfNodeNum(mp.from);
+        } else if (mp.relay_node && (mp.original_hop_limit - mp.hop_limit == 1)) {
+            // This packet traveled one hop, so we can use the relay_node as next_hop
+            info->next_hop = getLastByteOfNodeNum(mp.relay_node);
+        }
     }
 }
 

src/mesh/NodeDB.h

@@ -91,6 +91,9 @@ class NodeDB
     /// @return our node number
     NodeNum getNodeNum() { return myNodeInfo.my_node_num; }
 
+    // @return last byte of a NodeNum, 0xFF if it ended at 0x00
+    uint8_t getLastByteOfNodeNum(NodeNum num) { return (uint8_t)((num & 0xFF) ? (num & 0xFF) : 0xFF); }
+
     /// if returns false, that means our node should send a DenyNodeNum response.  If true, we think the number is okay for use
     // bool handleWantNodeNum(NodeNum n);
 
@@ -250,4 +253,4 @@ extern uint32_t error_address;
 #define Module_Config_size                                                                                                       \
     (ModuleConfig_CannedMessageConfig_size + ModuleConfig_ExternalNotificationConfig_size + ModuleConfig_MQTTConfig_size +       \
      ModuleConfig_RangeTestConfig_size + ModuleConfig_SerialConfig_size + ModuleConfig_StoreForwardConfig_size +                 \
-     ModuleConfig_TelemetryConfig_size + ModuleConfig_size)
+     ModuleConfig_TelemetryConfig_size + ModuleConfig_size)

src/mesh/RadioInterface.cpp

@@ -540,6 +540,9 @@ size_t RadioInterface::beginSending(meshtastic_MeshPacket *p)
         p->hop_limit = HOP_RELIABLE;
     }
     h->flags = p->hop_limit | (p->want_ack ? PACKET_FLAGS_WANT_ACK_MASK : 0);
+    h->flags |= (p->original_hop_limit & PACKET_FLAGS_HOP_MASK) << PACKET_FLAGS_ORIG_HOP_SHIFT;
+    h->next_hop = p->next_hop;
+    h->relay_node = p->relay_node;
 
     // if the sender nodenum is zero, that means uninitialized
     assert(h->from);
@@ -548,4 +551,4 @@ size_t RadioInterface::beginSending(meshtastic_MeshPacket *p)
 
     sendingPacket = p;
     return p->encrypted.size + sizeof(PacketHeader);
-}
+}

src/mesh/RadioInterface.h

@@ -12,6 +12,8 @@
 
 #define PACKET_FLAGS_HOP_MASK 0x07
 #define PACKET_FLAGS_WANT_ACK_MASK 0x08
+#define PACKET_FLAGS_ORIG_HOP_MASK 0x70
+#define PACKET_FLAGS_ORIG_HOP_SHIFT 4
 
 /**
  * This structure has to exactly match the wire layout when sent over the radio link.  Used to keep compatibility
@@ -31,6 +33,12 @@ typedef struct {
 
     /** The channel hash - used as a hint for the decoder to limit which channels we consider */
     uint8_t channel;
+
+    // Last byte of the NodeNum of the next-hop for this packet
+    uint8_t next_hop;
+
+    // Last byte of the NodeNum of the node that will relay/relayed this packet
+    uint8_t relay_node;
 } PacketHeader;
 
 /**

src/mesh/RadioLibInterface.cpp

@@ -361,7 +361,10 @@ void RadioLibInterface::handleReceiveInterrupt()
             mp->channel = h->channel;
             assert(HOP_MAX <= PACKET_FLAGS_HOP_MASK); // If hopmax changes, carefully check this code
             mp->hop_limit = h->flags & PACKET_FLAGS_HOP_MASK;
+            mp->original_hop_limit = (h->flags & PACKET_FLAGS_ORIG_HOP_MASK) >> PACKET_FLAGS_ORIG_HOP_SHIFT;
             mp->want_ack = !!(h->flags & PACKET_FLAGS_WANT_ACK_MASK);
+            mp->next_hop = h->next_hop;
+            mp->relay_node = h->relay_node;
 
             addReceiveMetadata(mp);
 

src/mesh/ReliableRouter.cpp

@@ -33,7 +33,7 @@ ErrorCode ReliableRouter::send(meshtastic_MeshPacket *p)
         }
     }
 
-    return FloodingRouter::send(p);
+    return (config.lora.next_hop_routing && p->to != NODENUM_BROADCAST) ? NextHopRouter::send(p) : FloodingRouter::send(p);
 }
 
 bool ReliableRouter::shouldFilterReceived(const meshtastic_MeshPacket *p)
@@ -71,19 +71,19 @@ bool ReliableRouter::shouldFilterReceived(const meshtastic_MeshPacket *p)
         i->second.nextTxMsec += iface->getPacketTime(p);
     }
 
-    /* Resend implicit ACKs for repeated packets (assuming the original packet was sent with HOP_RELIABLE)
-     * this way if an implicit ACK is dropped and a packet is resent we'll rebroadcast again.
-     * Resending real ACKs is omitted, as you might receive a packet multiple times due to flooding and
-     * flooding this ACK back to the original sender already adds redundancy. */
-    if (wasSeenRecently(p, false) && p->hop_limit == HOP_RELIABLE && !MeshModule::currentReply && p->to != nodeDB.getNodeNum()) {
+    /* Resend implicit ACKs for repeated packets (hop limit is the original setting) this way if an implicit ACK is dropped and a
+     * packet is resent we'll rebroadcast again. Resending real ACKs is omitted, as you might receive a packet multiple times due
+     * to flooding and flooding this ACK back to the original sender already adds redundancy. */
+    if (wasSeenRecently(p, false) && (p->original_hop_limit == p->hop_limit) && !MeshModule::currentReply &&
+        p->to != nodeDB.getNodeNum()) {
         // retransmission on broadcast has hop_limit still equal to HOP_RELIABLE
         LOG_DEBUG("Resending implicit ack for a repeated floodmsg\n");
         meshtastic_MeshPacket *tosend = packetPool.allocCopy(*p);
         tosend->hop_limit--; // bump down the hop count
         Router::send(tosend);
     }
 
-    return FloodingRouter::shouldFilterReceived(p);
+    return config.lora.next_hop_routing ? NextHopRouter::shouldFilterReceived(p) : FloodingRouter::shouldFilterReceived(p);
 }
 
 /**
@@ -132,8 +132,9 @@ void ReliableRouter::sniffReceived(const meshtastic_MeshPacket *p, const meshtas
         }
     }
 
-    // handle the packet as normal
-    FloodingRouter::sniffReceived(p, c);
+    // For DMs, we use the NextHopRouter, whereas for broadcasts, we use the FloodingRouter
+    config.lora.next_hop_routing && (p->to != NODENUM_BROADCAST) ? NextHopRouter::sniffReceived(p, c)
+                                                                 : FloodingRouter::sniffReceived(p, c);
 }
 
 #define NUM_RETRANSMISSIONS 3
@@ -222,9 +223,23 @@ int32_t ReliableRouter::doRetransmissions()
                 LOG_DEBUG("Sending reliable retransmission fr=0x%x,to=0x%x,id=0x%x, tries left=%d\n", p.packet->from,
                           p.packet->to, p.packet->id, p.numRetransmissions);
 
-                // Note: we call the superclass version because we don't want to have our version of send() add a new
-                // retransmission record
-                FloodingRouter::send(packetPool.allocCopy(*p.packet));
+                if (config.lora.next_hop_routing && p.packet->to != NODENUM_BROADCAST) {
+                    if (p.numRetransmissions == 1) {
+                        // Last retransmission, reset next_hop (fallback to FloodingRouter)
+                        p.packet->next_hop = NO_NEXT_HOP_PREFERENCE;
+                        // Also reset it in the nodeDB
+                        meshtastic_NodeInfoLite *sentTo = nodeDB.getMeshNode(p.packet->to);
+                        if (sentTo) {
+                            LOG_DEBUG("Resetting next hop for packet with dest 0x%x\n", p.packet->to);
+                            sentTo->next_hop = NO_NEXT_HOP_PREFERENCE;
+                        }
+                    }
+                    NextHopRouter::send(packetPool.allocCopy(*p.packet));
+                } else {
+                    // Note: we call the superclass version because we don't want to have our version of send() add a new
+                    // retransmission record
+                    FloodingRouter::send(packetPool.allocCopy(*p.packet));
+                }
 
                 // Queue again
                 --p.numRetransmissions;
@@ -251,4 +266,4 @@ void ReliableRouter::setNextTx(PendingPacket *pending)
     LOG_DEBUG("Setting next retransmission in %u msecs: ", d);
     printPacket("", pending->packet);
     setReceivedMessage(); // Run ASAP, so we can figure out our correct sleep time
-}
+}

src/mesh/ReliableRouter.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "FloodingRouter.h"
+#include "NextHopRouter.h"
 #include <unordered_map>
 
 /**
@@ -51,7 +51,7 @@ class GlobalPacketIdHashFunction
 /**
  * This is a mixin that extends Router with the ability to do (one hop only) reliable message sends.
  */
-class ReliableRouter : public FloodingRouter
+class ReliableRouter : public NextHopRouter
 {
   private:
     std::unordered_map<GlobalPacketId, PendingPacket, GlobalPacketIdHashFunction> pending;
@@ -120,4 +120,4 @@ class ReliableRouter : public FloodingRouter
     int32_t doRetransmissions();
 
     void setNextTx(PendingPacket *pending);
-};
+};

src/mesh/Router.cpp

@@ -240,6 +240,12 @@ ErrorCode Router::send(meshtastic_MeshPacket *p)
     // the lora we need to make sure we have replaced it with our local address
     p->from = getFrom(p);
 
+    // If we are the original transmitter, set the original hop limit
+    if (p->from == getNodeNum())
+        p->original_hop_limit = config.lora.hop_limit ? config.lora.hop_limit : HOP_RELIABLE;
+
+    p->relay_node = nodeDB.getLastByteOfNodeNum(getNodeNum()); // set the relayer to us
+
     // If the packet hasn't yet been encrypted, do so now (it might already be encrypted if we are just forwarding it)
 
     assert(p->which_payload_variant == meshtastic_MeshPacket_encrypted_tag ||

src/mesh/generated/meshtastic/apponly.pb.h

@@ -54,7 +54,7 @@ extern const pb_msgdesc_t meshtastic_ChannelSet_msg;
 #define meshtastic_ChannelSet_fields &meshtastic_ChannelSet_msg
 
 /* Maximum encoded size of messages (where known) */
-#define meshtastic_ChannelSet_size               591
+#define meshtastic_ChannelSet_size               593
 
 #ifdef __cplusplus
 } /* extern "C" */