mirror of
https://github.com/meshtastic/firmware.git
synced 2026-09-23 06:45:24 -04:00
Benjamin Faershtein
0fef83d434
* feat: resolve event mode hop limit * feat: bake event mode hop limit * fix: honor event mode hop cap in routing * docs: expose event mode hop limit preference * fix: enforce event hop defaults across routing * docs: clarify event hop override behavior * refactor: simplify event mode hop preference * fix: cap equal event hop limit
98 lines
4.1 KiB
C++
98 lines
4.1 KiB
C++
#include "RoutingModule.h"
|
|
#include "Default.h"
|
|
#include "MeshService.h"
|
|
#include "NodeDB.h"
|
|
#include "Router.h"
|
|
#include "configuration.h"
|
|
#include "main.h"
|
|
|
|
RoutingModule *routingModule;
|
|
|
|
bool RoutingModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshtastic_Routing *r)
|
|
{
|
|
bool maybePKI = mp.which_payload_variant == meshtastic_MeshPacket_encrypted_tag && mp.channel == 0 && !isBroadcast(mp.to);
|
|
// Beginning of logic whether to drop the packet based on Rebroadcast mode
|
|
if (mp.which_payload_variant == meshtastic_MeshPacket_encrypted_tag &&
|
|
(config.device.rebroadcast_mode == meshtastic_Config_DeviceConfig_RebroadcastMode_LOCAL_ONLY ||
|
|
config.device.rebroadcast_mode == meshtastic_Config_DeviceConfig_RebroadcastMode_KNOWN_ONLY)) {
|
|
if (!maybePKI)
|
|
return false;
|
|
if (!nodeInfoLiteHasUser(nodeDB->getMeshNode(mp.from)) && !nodeInfoLiteHasUser(nodeDB->getMeshNode(mp.to)))
|
|
return false;
|
|
} else if (owner.is_licensed && ((nodeDB->getLicenseStatus(mp.from) == UserLicenseStatus::NotLicensed) ||
|
|
(nodeDB->getLicenseStatus(mp.to) == UserLicenseStatus::NotLicensed))) {
|
|
// Don't let licensed users to rebroadcast packets to or from unlicensed users
|
|
// If we know they are in-fact unlicensed
|
|
LOG_DEBUG("Packet to or from unlicensed user, ignoring packet");
|
|
return false;
|
|
}
|
|
|
|
printPacket("Routing sniffing", &mp);
|
|
router->sniffReceived(&mp, r);
|
|
|
|
// FIXME - move this to a non promsicious PhoneAPI module?
|
|
// Note: we are careful not to send back packets that started with the phone back to the phone
|
|
if ((isBroadcast(mp.to) || isToUs(&mp)) && (mp.from != 0)) {
|
|
printPacket("Delivering rx packet", &mp);
|
|
service->handleFromRadio(&mp);
|
|
}
|
|
|
|
return false; // Let others look at this message also if they want
|
|
}
|
|
|
|
meshtastic_MeshPacket *RoutingModule::allocReply()
|
|
{
|
|
assert(currentRequest);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void RoutingModule::sendAckNak(meshtastic_Routing_Error err, NodeNum to, PacketId idFrom, ChannelIndex chIndex, uint8_t hopLimit,
|
|
bool ackWantsAck)
|
|
{
|
|
auto p = allocAckNak(err, to, idFrom, chIndex, hopLimit);
|
|
if (!p)
|
|
return;
|
|
|
|
// Allow the caller to set want_ack on this ACK packet if it's important that the ACK be delivered reliably
|
|
p->want_ack = ackWantsAck;
|
|
|
|
if (router->sendLocal(p) == ERRNO_SHOULD_RELEASE) // we sometimes send directly to the local node
|
|
packetPool.release(p);
|
|
}
|
|
|
|
uint8_t RoutingModule::getHopLimitForResponse(const meshtastic_MeshPacket &mp)
|
|
{
|
|
const int8_t hopsUsed = getHopsAway(mp);
|
|
const uint8_t responseHopLimit = Default::getConfiguredOrDefaultHopLimit(config.lora.hop_limit);
|
|
if (hopsUsed >= 0) {
|
|
if (hopsUsed > static_cast<int32_t>(responseHopLimit)) {
|
|
// In event mode, never exceed the configured event hop limit.
|
|
#if !USERPREFS_EVENT_MODE // This falls through to the default.
|
|
return hopsUsed; // If the request used more hops than the limit, use the same amount of hops
|
|
#endif
|
|
} else if (mp.hop_start == 0) {
|
|
return 0; // The requesting node wanted 0 hops, so the response also uses a direct/local path.
|
|
} else if (static_cast<uint8_t>(hopsUsed + 2) < responseHopLimit) {
|
|
return hopsUsed + 2; // Use only the amount of hops needed with some margin as the way back may be different
|
|
}
|
|
}
|
|
return responseHopLimit;
|
|
}
|
|
|
|
meshtastic_MeshPacket *RoutingModule::allocAckNak(meshtastic_Routing_Error err, NodeNum to, PacketId idFrom, ChannelIndex chIndex,
|
|
uint8_t hopLimit)
|
|
{
|
|
return MeshModule::allocAckNak(err, to, idFrom, chIndex, hopLimit);
|
|
}
|
|
|
|
RoutingModule::RoutingModule() : ProtobufModule("routing", meshtastic_PortNum_ROUTING_APP, &meshtastic_Routing_msg)
|
|
{
|
|
isPromiscuous = true;
|
|
|
|
// moved the RebroadcastMode logic into handleReceivedProtobuf
|
|
// LocalOnly requires either the from or to to be a known node
|
|
// knownOnly specifically requires the from to be a known node.
|
|
encryptedOk = true;
|
|
}
|