meshtastic_firmware/src/mesh/NextHopRouter.cpp

#include "NextHopRouter.h"
#include "MeshTypes.h"
#include "meshUtils.h"
#if !MESHTASTIC_EXCLUDE_TRACEROUTE
#include "modules/TraceRouteModule.h"
#endif
#if HAS_TRAFFIC_MANAGEMENT
#include "modules/TrafficManagementModule.h"
#endif
#include "NodeDB.h"

NextHopRouter::NextHopRouter() {}

PendingPacket::PendingPacket(meshtastic_MeshPacket *p, uint8_t numRetransmissions)
{
    packet = p;
    this->numRetransmissions = numRetransmissions - 1; // We subtract one, because we assume the user just did the first send
}

/**
 * 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)
    p->relay_node = nodeDB->getLastByteOfNodeNum(getNodeNum()); // First set the relayer to us
    wasSeenRecently(p);                                         // FIXME, move this to a sniffSent method

    p->next_hop = getNextHop(p->to, p->relay_node).value_or(NO_NEXT_HOP_PREFERENCE); // set the next hop
    LOG_DEBUG("Setting next hop for packet with dest %x to %x", p->to, p->next_hop);

    // If it's from us, ReliableRouter already handles retransmissions if want_ack is set. If a next hop is set and hop limit is
    // not 0 or want_ack is set, start retransmissions
    if ((!isFromUs(p) || !p->want_ack) && p->next_hop != NO_NEXT_HOP_PREFERENCE && (p->hop_limit > 0 || p->want_ack))
        startRetransmission(packetPool.allocCopy(*p)); // start retransmission for relayed packet

    return Router::send(p);
}

bool NextHopRouter::shouldFilterReceived(const meshtastic_MeshPacket *p)
{
    bool wasFallback = false;
    bool weWereNextHop = false;
    bool wasUpgraded = false;
    bool seenRecently = wasSeenRecently(p, true, &wasFallback, &weWereNextHop,
                                        &wasUpgraded); // Updates history; returns false when an upgrade is detected

    // Handle hop_limit upgrade scenario for rebroadcasters
    if (wasUpgraded && perhapsHandleUpgradedPacket(p)) {
        return true; // we handled it, so stop processing
    }

    if (seenRecently) {
        printPacket("Ignore dupe incoming msg", p);

        if (p->transport_mechanism == meshtastic_MeshPacket_TransportMechanism_TRANSPORT_LORA) {
            rxDupe++;
            stopRetransmission(p->from, p->id);
        }

        // If it was a fallback to flooding, try to relay again
        if (wasFallback) {
            LOG_INFO("Fallback to flooding from relay_node=0x%x", p->relay_node);
            // Check if it's still in the Tx queue, if not, we have to relay it again
            if (!findInTxQueue(p->from, p->id)) {
                reprocessPacket(p);
                perhapsRebroadcast(p);
            }
        } else {
            bool isRepeated = getHopsAway(*p) == 0;
            // If repeated and not in Tx queue anymore, try relaying again, or if we are the destination, send the ACK again
            if (isRepeated) {
                if (!findInTxQueue(p->from, p->id)) {
                    reprocessPacket(p);
                    if (!perhapsRebroadcast(p) && isToUs(p) && p->want_ack) {
                        sendAckNak(meshtastic_Routing_Error_NONE, getFrom(p), p->id, p->channel, 0);
                    }
                }
            } else if (!weWereNextHop) {
                perhapsCancelDupe(p); // If it's a dupe, cancel relay if we were not explicitly asked to relay
            }
        }
        return true;
    }

    return Router::shouldFilterReceived(p);
}

void NextHopRouter::sniffReceived(const meshtastic_MeshPacket *p, const meshtastic_Routing *c)
{
    NodeNum ourNodeNum = getNodeNum();
    uint8_t ourRelayID = nodeDB->getLastByteOfNodeNum(ourNodeNum);
    bool isAckorReply = (p->which_payload_variant == meshtastic_MeshPacket_decoded_tag) &&
                        (p->decoded.request_id != 0 || p->decoded.reply_id != 0);
    if (isAckorReply) {
        // Update next-hop for the original transmitter of this successful transmission to the relay node, but ONLY if "from"
        // is not 0 (means implicit ACK) and original packet was also relayed by this node, or we sent it directly to the
        // destination
        if (p->from != 0) {
            meshtastic_NodeInfoLite *origTx = nodeDB->getMeshNode(p->from);
            // Either relayer of ACK was also a relayer of the packet, or we were the *only* relayer and the ACK came
            // directly from the destination. checkRelayers is read-only on PacketHistory and O(1), so we run it even
            // when origTx is absent — that lets us still capture the confirmed hop into the TMM overflow cache below.
            // Single lookup for both relayer checks on the same (request_id, to) pair
            bool wasAlreadyRelayer = false;
            bool weWereSoleRelayer = false;
            bool weWereRelayer = false;
            checkRelayers(p->relay_node, ourRelayID, p->decoded.request_id, p->to, &wasAlreadyRelayer, &weWereRelayer,
                          &weWereSoleRelayer);
            if ((weWereRelayer && wasAlreadyRelayer) || (getHopsAway(*p) == 0 && weWereSoleRelayer)) {
                // M1/M2: only learn a next hop whose last byte maps to a single plausible relay. On a dense
                // mesh the byte may be ambiguous; storing it would aim future DMs at the wrong node. This gate
                // now protects BOTH the hot-store route (NodeInfoLite.next_hop) AND the TMM overflow cache —
                // the overflow cache deliberately holds many more next-hop bytes (long-tail nodes), so it is
                // even more collision-prone and must never store an ambiguous byte either. Ambiguous/unknown
                // -> store nothing and keep flooding (safe).
                if (nodeDB->resolveUniqueLastByte(p->relay_node, /*requireDirectNeighbor=*/false)) {
                    if (origTx && origTx->next_hop != p->relay_node) { // Not already set
                        LOG_INFO("Update next hop of 0x%x to 0x%x based on ACK/reply (was relayer %d we were sole %d)", p->from,
                                 p->relay_node, wasAlreadyRelayer, weWereSoleRelayer);
                        origTx->next_hop = p->relay_node;
                    }
                    noteRouteLearned(p->from, p->relay_node, millis()); // M3: anchor freshness (hot or overflow route)
#if HAS_TRAFFIC_MANAGEMENT
                    // Mirror the confirmed (and now unique-resolved) hop into the TMM overflow cache so it
                    // survives even when the source isn't (or is no longer) in the hot NodeDB.
                    if (trafficManagementModule)
                        trafficManagementModule->setNextHop(p->from, p->relay_node);
#endif
                } else {
                    LOG_DEBUG("Not learning next hop for 0x%x: relay byte 0x%x ambiguous/unknown; keep flooding", p->from,
                              p->relay_node);
                }
            }
        }
        if (!isToUs(p)) {
            Router::cancelSending(p->to, p->decoded.request_id); // cancel rebroadcast for this DM
            // stop retransmission for the original packet
            stopRetransmission(p->to, p->decoded.request_id); // for original packet, from = to and id = request_id
        }
    }

    perhapsRebroadcast(p);

    // handle the packet as normal
    Router::sniffReceived(p, c);
}

/* Check if we should be rebroadcasting this packet if so, do so. */
bool NextHopRouter::perhapsRebroadcast(const meshtastic_MeshPacket *p)
{
    // Check if traffic management wants to exhaust this packet's hops
    bool exhaustHops = false;
#if HAS_TRAFFIC_MANAGEMENT
    if (trafficManagementModule && trafficManagementModule->shouldExhaustHops(*p)) {
        exhaustHops = true;
    }
#endif

    // Allow rebroadcast if hop_limit > 0 OR if we're exhausting hops (which sets hop_limit = 0 but still needs one relay)
    if (!isToUs(p) && !isFromUs(p) && (p->hop_limit > 0 || exhaustHops)) {
        if (p->id != 0) {
            if (isRebroadcaster()) {
                // NOTE: this is a self-identity match (is the addressed next_hop OUR last byte?), so it
                // cannot be hardened with resolveLastByte() — a remote node that legitimately shares our
                // last byte will also match here and rebroadcast. That residual collision needs a wider
                // on-wire field to fix. M1/M2 instead shrink the blast radius by reducing how often an
                // ambiguous next_hop byte is ever learned (sniffReceived) or originated (getNextHop).
                if (p->next_hop == NO_NEXT_HOP_PREFERENCE || p->next_hop == nodeDB->getLastByteOfNodeNum(getNodeNum())) {
                    meshtastic_MeshPacket *tosend = packetPool.allocCopy(*p); // keep a copy because we will be sending it
                    LOG_INFO("Rebroadcast received message coming from %x", p->relay_node);

                    // If exhausting hops, force hop_limit = 0 regardless of other logic
                    if (exhaustHops) {
                        tosend->hop_limit = 0;
                        LOG_INFO("Traffic management: exhausting hops for 0x%08x, setting hop_limit=0", getFrom(p));
                    } else if (shouldDecrementHopLimit(p)) {
                        // Use shared logic to determine if hop_limit should be decremented
                        tosend->hop_limit--; // bump down the hop count
                    } else {
                        LOG_INFO("favorite-ROUTER/CLIENT_BASE-to-ROUTER/CLIENT_BASE rebroadcast: preserving hop_limit");
                    }
#if USERPREFS_EVENT_MODE
                    if (tosend->hop_limit > 2) {
                        // if we are "correcting" the hop_limit, "correct" the hop_start by the same amount to preserve hops away.
                        tosend->hop_start -= (tosend->hop_limit - 2);
                        tosend->hop_limit = 2;
                    }
#endif

                    if (p->next_hop == NO_NEXT_HOP_PREFERENCE) {
                        FloodingRouter::send(tosend);
                    } else {
                        NextHopRouter::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;
}

/**
 * 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)
 */
std::optional<uint8_t> NextHopRouter::getNextHop(NodeNum to, uint8_t relay_node)
{
    if (isBroadcast(to))
        return std::nullopt;

    // Hot store first: a direct array hit on the live NodeDB entry.
    meshtastic_NodeInfoLite *node = nodeDB->getMeshNode(to);
    if (node && node->next_hop) {
        // M3: proactively decay a stale or repeatedly-failing route back to flooding, so a dead hop
        // isn't trusted on the next DM's first (and on dense meshes, slowest) attempt. We only act on
        // a health record that still matches the stored byte; a next_hop set by another path (e.g.
        // TraceRouteModule) with no matching record is left authoritative.
        const RouteHealth *h = findRouteHealth(to);
        if (h && h->lastNextHop == node->next_hop && isRouteStale(*h, millis())) {
            LOG_INFO("Next hop 0x%x for 0x%x is stale (age/fails); flood and clear", node->next_hop, to);
            node->next_hop = NO_NEXT_HOP_PREFERENCE; // clear persisted route
            clearRouteHealth(to);                    // clear RAM health
            return std::nullopt;
        }

        // We are careful not to return the relay node as the next hop
        if (node->next_hop != relay_node) {
            // M1/M2: only emit a stored next_hop if its last byte still maps to a UNIQUE, currently
            // reachable direct neighbor. On a dense mesh the last byte collides, so an ambiguous byte
            // would unicast a hint toward the wrong physical node; if the neighbor has gone away we'd
            // unicast into a void. In both cases flood instead (managed flooding still delivers).
            ResolvedNode r = nodeDB->resolveLastByte(node->next_hop, /*requireDirectNeighbor=*/true);
            if (r.status == LastByteResolution::Unique)
                return node->next_hop;
            LOG_WARN("Next hop 0x%x for 0x%x %s; set no pref", node->next_hop, to,
                     r.status == LastByteResolution::Ambiguous ? "ambiguous among neighbors" : "not a known neighbor");
        } else
            LOG_WARN("Next hop for 0x%x is 0x%x, same as relayer; set no pref", to, node->next_hop);
    }

#if HAS_TRAFFIC_MANAGEMENT
    // Fallback: TMM overflow cache holds confirmed hops for nodes that have aged out of the hot store.
    // It is the same byte source/confidence as NodeInfoLite.next_hop, so it gets the same M1/M2/M3
    // protection: decay a stale/failing route, then only emit a byte that still resolves to a unique
    // reachable neighbor. Without this the overflow cache (which holds MORE bytes for MORE nodes) would
    // reintroduce exactly the silent-misroute that M1/M2 closes on the hot path.
    if (trafficManagementModule) {
        uint8_t hint = trafficManagementModule->getNextHopHint(to);
        if (hint && hint != relay_node) {
            const RouteHealth *h = findRouteHealth(to);
            if (h && h->lastNextHop == hint && isRouteStale(*h, millis())) {
                LOG_INFO("TMM next hop 0x%x for 0x%x is stale (age/fails); flood and clear", hint, to);
                trafficManagementModule->clearNextHop(to); // clear overflow route (setNextHop won't store 0)
                clearRouteHealth(to);                      // clear RAM health
                return std::nullopt;
            }
            ResolvedNode r = nodeDB->resolveLastByte(hint, /*requireDirectNeighbor=*/true);
            if (r.status == LastByteResolution::Unique) {
                LOG_DEBUG("Next hop for 0x%x is 0x%x (TMM cache)", to, hint);
                return hint;
            }
            LOG_WARN("TMM next hop 0x%x for 0x%x %s; set no pref", hint, to,
                     r.status == LastByteResolution::Ambiguous ? "ambiguous among neighbors" : "not a known neighbor");
        }
    }
#endif

    return std::nullopt;
}

PendingPacket *NextHopRouter::findPendingPacket(GlobalPacketId key)
{
    auto old = pending.find(key); // If we have an old record, someone messed up because id got reused
    if (old != pending.end()) {
        return &old->second;
    } else
        return NULL;
}

/**
 * Stop any retransmissions we are doing of the specified node/packet ID pair
 */
bool NextHopRouter::stopRetransmission(NodeNum from, PacketId id)
{
    auto key = GlobalPacketId(from, id);
    return stopRetransmission(key);
}

bool NextHopRouter::roleAllowsCancelingFromTxQueue(const meshtastic_MeshPacket *p)
{
    // Return true if we're allowed to cancel a packet in the txQueue (so we may never transmit it even once)

    // Return false for roles like ROUTER, ROUTER_LATE which should always transmit the packet at least once.

    return roleAllowsCancelingDupe(p); // same logic as FloodingRouter::roleAllowsCancelingDupe
}

bool NextHopRouter::stopRetransmission(GlobalPacketId key)
{
    auto old = findPendingPacket(key);
    if (old) {
        auto p = old->packet;
        /* Only when we already transmitted a packet via LoRa, we will cancel the packet in the Tx queue
          to avoid canceling a transmission if it was ACKed super fast via MQTT */
        if (old->numRetransmissions < NUM_RELIABLE_RETX - 1) {
            // We only cancel it if we are the original sender or if we're not a router(_late)
            if (isFromUs(p) || roleAllowsCancelingFromTxQueue(p)) {
                // remove the 'original' (identified by originator and packet->id) from the txqueue and free it
                cancelSending(getFrom(p), p->id);
            }
        }

        // Regardless of whether or not we canceled this packet from the txQueue, remove it from our pending list so it
        // doesn't get scheduled again. (This is the core of stopRetransmission.)
        auto numErased = pending.erase(key);
        assert(numErased == 1);

        // When we remove an entry from pending, always be sure to release the copy of the packet that was allocated in the
        // call to startRetransmission.
        packetPool.release(p);

        return true;
    } else
        return false;
}

/**
 * Add p to the list of packets to retransmit occasionally.  We will free it once we stop retransmitting.
 */
PendingPacket *NextHopRouter::startRetransmission(meshtastic_MeshPacket *p, uint8_t numReTx)
{
    auto id = GlobalPacketId(p);
    auto rec = PendingPacket(p, numReTx);

    stopRetransmission(getFrom(p), p->id);

    setNextTx(&rec);
    pending[id] = rec;

    return &pending[id];
}

/**
 * Do any retransmissions that are scheduled (FIXME - for the time being called from loop)
 */
int32_t NextHopRouter::doRetransmissions()
{
    uint32_t now = millis();
    int32_t d = INT32_MAX;

    // FIXME, we should use a better datastructure rather than walking through this map.
    // for(auto el: pending) {
    for (auto it = pending.begin(), nextIt = it; it != pending.end(); it = nextIt) {
        ++nextIt; // we use this odd pattern because we might be deleting it...
        auto &p = it->second;

        bool stillValid = true; // assume we'll keep this record around

        // FIXME, handle 51 day rolloever here!!!
        if (p.nextTxMsec <= now) {
            if (p.numRetransmissions == 0) {
                if (isFromUs(p.packet)) {
                    LOG_DEBUG("Reliable send failed, returning a nak for fr=0x%x,to=0x%x,id=0x%x", p.packet->from, p.packet->to,
                              p.packet->id);
                    sendAckNak(meshtastic_Routing_Error_MAX_RETRANSMIT, getFrom(p.packet), p.packet->id, p.packet->channel);
                }
                // Note: we don't stop retransmission here, instead the Nak packet gets processed in sniffReceived
                stopRetransmission(it->first);
                stillValid = false; // just deleted it
            } else {
                LOG_DEBUG("Sending retransmission fr=0x%x,to=0x%x,id=0x%x, tries left=%d", p.packet->from, p.packet->to,
                          p.packet->id, p.numRetransmissions);

                if (!isBroadcast(p.packet->to)) {
                    if (p.numRetransmissions == 1) {
                        // Last retransmission: this directed delivery went un-ACKed. Record the failure
                        // (M3 — accumulates across DMs to age out a flapping/dead route) and reset
                        // next_hop so the final try falls back to FloodingRouter.
                        noteRouteFailure(p.packet->to);
                        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_INFO("Resetting next hop for packet with dest 0x%x\n", p.packet->to);
                            sentTo->next_hop = NO_NEXT_HOP_PREFERENCE;
                        }
#if HAS_TRAFFIC_MANAGEMENT
                        if (trafficManagementModule) {
                            trafficManagementModule->clearNextHop(p.packet->to);
                        }
#endif
                        FloodingRouter::send(packetPool.allocCopy(*p.packet));
                    } else {
#if NEXTHOP_EARLY_FLOOD_ON_UNVERIFIED
                        // M4 (gated): if the route isn't proven healthy, don't spend a second directed
                        // attempt — start flooding one retry sooner to cut recovery latency. A verified
                        // route (fresh, zero recent failures) keeps the unchanged directed-retry path so
                        // the sparse-mesh happy path is untouched.
                        RouteHealth *h = findRouteHealth(p.packet->to);
                        bool verified = h && h->consecutiveFailures == 0 && !isRouteStale(*h, now);
                        if (!verified) {
                            p.packet->next_hop = NO_NEXT_HOP_PREFERENCE;
                            meshtastic_NodeInfoLite *sentTo = nodeDB->getMeshNode(p.packet->to);
                            if (sentTo)
                                sentTo->next_hop = NO_NEXT_HOP_PREFERENCE;
                            FloodingRouter::send(packetPool.allocCopy(*p.packet));
                        } else {
                            NextHopRouter::send(packetPool.allocCopy(*p.packet));
                        }
#else
                        NextHopRouter::send(packetPool.allocCopy(*p.packet));
#endif
                    }
                } 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;
                setNextTx(&p);
            }
        }

        if (stillValid) {
            // Update our desired sleep delay
            int32_t t = p.nextTxMsec - now;

            d = min(t, d);
        }
    }

    return d;
}

void NextHopRouter::setNextTx(PendingPacket *pending)
{
    assert(iface);
    auto d = iface->getRetransmissionMsec(pending->packet);
    pending->nextTxMsec = millis() + d;
    LOG_DEBUG("Setting next retransmission in %u msecs: ", d);
    printPacket("", pending->packet);
    setReceivedMessage(); // Run ASAP, so we can figure out our correct sleep time
}

// ---------------------------------------------------------------------------
// M3: RAM route-health table. Bounded array with reuse-oldest eviction (same discipline as
// PacketHistory). All age comparisons use unsigned subtraction so they survive the 49.7-day millis()
// rollover. dest == 0 marks an empty slot; learnedAtMsec is normalized to 1 on write so an occupied
// slot is never read as infinitely old.
// ---------------------------------------------------------------------------

RouteHealth *NextHopRouter::findRouteHealth(NodeNum dest)
{
    if (dest == 0)
        return nullptr;
    for (auto &h : routeHealth)
        if (h.dest == dest)
            return &h;
    return nullptr;
}

RouteHealth *NextHopRouter::getOrAllocRouteHealth(NodeNum dest, uint32_t now)
{
    if (dest == 0)
        return nullptr;

    RouteHealth *oldest = &routeHealth[0];
    RouteHealth *freeSlot = nullptr;
    for (auto &h : routeHealth) {
        if (h.dest == dest)
            return &h; // existing record
        if (h.dest == 0) {
            if (!freeSlot)
                freeSlot = &h; // remember the first free slot; prefer it over evicting
            continue;
        }
        // Track the oldest occupied slot in case the table is full (rollover-safe).
        if ((uint32_t)(now - h.learnedAtMsec) > (uint32_t)(now - oldest->learnedAtMsec))
            oldest = &h;
    }
    // Claim the free slot if there is one, else reuse the oldest. Reset before use and stamp the dest
    // so the record is findable.
    RouteHealth *slot = freeSlot ? freeSlot : oldest;
    *slot = RouteHealth{};
    slot->dest = dest;
    return slot;
}

void NextHopRouter::noteRouteLearned(NodeNum dest, uint8_t nextHop, uint32_t now)
{
    if (dest == 0 || nextHop == NO_NEXT_HOP_PREFERENCE)
        return;
    RouteHealth *h = getOrAllocRouteHealth(dest, now);
    if (!h)
        return;
    // A genuinely new next hop earns a clean slate; re-learning the SAME hop keeps the accumulated
    // failure count so an asymmetric reverse path that keeps re-teaching a dead forward hop still ages
    // out instead of resetting the counter every time.
    if (h->lastNextHop != nextHop) {
        h->lastNextHop = nextHop;
        h->consecutiveFailures = 0;
    }
    h->learnedAtMsec = now ? now : 1;
}

void NextHopRouter::noteRouteSuccess(NodeNum dest, uint32_t now)
{
    RouteHealth *h = findRouteHealth(dest);
    if (!h)
        return; // only routes we actually learned have health to refresh
    h->consecutiveFailures = 0;
    h->learnedAtMsec = now ? now : 1;
}

void NextHopRouter::noteRouteFailure(NodeNum dest)
{
    RouteHealth *h = findRouteHealth(dest);
    if (!h)
        return; // nothing to penalize (we were flooding, or never learned a route here)
    if (h->consecutiveFailures < 255)
        h->consecutiveFailures++;
}

bool NextHopRouter::isRouteStale(const RouteHealth &h, uint32_t now) const
{
    if (h.consecutiveFailures >= ROUTE_FAILURE_THRESHOLD)
        return true;
    return (uint32_t)(now - h.learnedAtMsec) >= ROUTE_TTL_MSEC;
}

void NextHopRouter::clearRouteHealth(NodeNum dest)
{
    RouteHealth *h = findRouteHealth(dest);
    if (h)
        *h = RouteHealth{};
}