Shorter nodeinfo timeout redux (#4458)

* Add shorterTimeout bool to sendOurNodeInfo

* Respond to likely PKI decode errors with a quick nodeinfo

* Protbufs

* Move to PKI_UNKNOWN_PUBKEY for PKI decode error

protobufs

@@ -1 +1 @@
-Subproject commit 97fa34517f80332a11046a73f26d55100fbee9e2
+Subproject commit 8b5b2faf662b364754809f923271022f4f1492ed

src/mesh/ReliableRouter.cpp

@@ -4,6 +4,7 @@
 #include "MeshTypes.h"
 #include "configuration.h"
 #include "mesh-pb-constants.h"
+#include "modules/NodeInfoModule.h"
 
 // ReliableRouter::ReliableRouter() {}
 
@@ -109,13 +110,24 @@ void ReliableRouter::sniffReceived(const meshtastic_MeshPacket *p, const meshtas
                 LOG_DEBUG("Some other module has replied to this message, no need for a 2nd ack\n");
             } else if (p->which_payload_variant == meshtastic_MeshPacket_decoded_tag) {
                 sendAckNak(meshtastic_Routing_Error_NONE, getFrom(p), p->id, p->channel, p->hop_start, p->hop_limit);
+            } else if (p->which_payload_variant == meshtastic_MeshPacket_encrypted_tag && p->channel == 0 &&
+                       (nodeDB->getMeshNode(p->from) != nullptr || nodeDB->getMeshNode(p->from)->user.public_key.size == 0)) {
+                // This looks like it might be a PKI packet from an unknown node, so send PKI_UNKNOWN_PUBKEY
+                sendAckNak(meshtastic_Routing_Error_PKI_UNKNOWN_PUBKEY, getFrom(p), p->id, channels.getPrimaryIndex(),
+                           p->hop_start, p->hop_limit);
             } else {
                 // Send a 'NO_CHANNEL' error on the primary channel if want_ack packet destined for us cannot be decoded
                 sendAckNak(meshtastic_Routing_Error_NO_CHANNEL, getFrom(p), p->id, channels.getPrimaryIndex(), p->hop_start,
                            p->hop_limit);
             }
         }
-
+        if (p->which_payload_variant == meshtastic_MeshPacket_decoded_tag && c &&
+            c->error_reason == meshtastic_Routing_Error_PKI_UNKNOWN_PUBKEY) {
+            if (owner.public_key.size == 32) {
+                LOG_INFO("This seems like a remote PKI decrypt failure, so send a NodeInfo");
+                nodeInfoModule->sendOurNodeInfo(p->from, false, p->channel, true);
+            }
+        }
         // We consider an ack to be either a !routing packet with a request ID or a routing packet with !error
         PacketId ackId = ((c && c->error_reason == meshtastic_Routing_Error_NONE) || !c) ? p->decoded.request_id : 0;
 

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

@@ -302,7 +302,9 @@ typedef enum _meshtastic_Routing_Error {
  (i.e you did not send the request on the required bound channel) */
     meshtastic_Routing_Error_NOT_AUTHORIZED = 33,
     /* The client specified a PKI transport, but the node was unable to send the packet using PKI (and did not send the message at all) */
-    meshtastic_Routing_Error_PKI_FAILED = 34
+    meshtastic_Routing_Error_PKI_FAILED = 34,
+    /* The receiving node does not have a Public Key to decode with */
+    meshtastic_Routing_Error_PKI_UNKNOWN_PUBKEY = 35
 } meshtastic_Routing_Error;
 
 /* The priority of this message for sending.
@@ -995,8 +997,8 @@ extern "C" {
 #define _meshtastic_Position_AltSource_ARRAYSIZE ((meshtastic_Position_AltSource)(meshtastic_Position_AltSource_ALT_BAROMETRIC+1))
 
 #define _meshtastic_Routing_Error_MIN meshtastic_Routing_Error_NONE
-#define _meshtastic_Routing_Error_MAX meshtastic_Routing_Error_PKI_FAILED
-#define _meshtastic_Routing_Error_ARRAYSIZE ((meshtastic_Routing_Error)(meshtastic_Routing_Error_PKI_FAILED+1))
+#define _meshtastic_Routing_Error_MAX meshtastic_Routing_Error_PKI_UNKNOWN_PUBKEY
+#define _meshtastic_Routing_Error_ARRAYSIZE ((meshtastic_Routing_Error)(meshtastic_Routing_Error_PKI_UNKNOWN_PUBKEY+1))
 
 #define _meshtastic_MeshPacket_Priority_MIN meshtastic_MeshPacket_Priority_UNSET
 #define _meshtastic_MeshPacket_Priority_MAX meshtastic_MeshPacket_Priority_MAX

src/modules/NodeInfoModule.cpp

@@ -32,19 +32,22 @@ bool NodeInfoModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, mes
     return false; // Let others look at this message also if they want
 }
 
-void NodeInfoModule::sendOurNodeInfo(NodeNum dest, bool wantReplies, uint8_t channel)
+void NodeInfoModule::sendOurNodeInfo(NodeNum dest, bool wantReplies, uint8_t channel, bool _shorterTimeout)
 {
     // cancel any not yet sent (now stale) position packets
     if (prevPacketId) // if we wrap around to zero, we'll simply fail to cancel in that rare case (no big deal)
         service->cancelSending(prevPacketId);
-
+    shorterTimeout = _shorterTimeout;
     meshtastic_MeshPacket *p = allocReply();
     if (p) { // Check whether we didn't ignore it
         p->to = dest;
         p->decoded.want_response = (config.device.role != meshtastic_Config_DeviceConfig_Role_TRACKER &&
                                     config.device.role != meshtastic_Config_DeviceConfig_Role_SENSOR) &&
                                    wantReplies;
-        p->priority = meshtastic_MeshPacket_Priority_BACKGROUND;
+        if (_shorterTimeout)
+            p->priority = meshtastic_MeshPacket_Priority_DEFAULT;
+        else
+            p->priority = meshtastic_MeshPacket_Priority_BACKGROUND;
         if (channel > 0) {
             LOG_DEBUG("sending ourNodeInfo to channel %d\n", channel);
             p->channel = channel;
@@ -53,6 +56,7 @@ void NodeInfoModule::sendOurNodeInfo(NodeNum dest, bool wantReplies, uint8_t cha
         prevPacketId = p->id;
 
         service->sendToMesh(p);
+        shorterTimeout = false;
     }
 }
 
@@ -65,10 +69,14 @@ meshtastic_MeshPacket *NodeInfoModule::allocReply()
     }
     uint32_t now = millis();
     // If we sent our NodeInfo less than 5 min. ago, don't send it again as it may be still underway.
-    if (lastSentToMesh && (now - lastSentToMesh) < (5 * 60 * 1000)) {
+    if (!shorterTimeout && lastSentToMesh && (now - lastSentToMesh) < (5 * 60 * 1000)) {
         LOG_DEBUG("Skip sending NodeInfo since we just sent it less than 5 minutes ago.\n");
         ignoreRequest = true; // Mark it as ignored for MeshModule
         return NULL;
+    } else if (shorterTimeout && lastSentToMesh && (now - lastSentToMesh) < (60 * 1000)) {
+        LOG_DEBUG("Skip sending actively requested NodeInfo since we just sent it less than 60 seconds ago.\n");
+        ignoreRequest = true; // Mark it as ignored for MeshModule
+        return NULL;
     } else {
         ignoreRequest = false; // Don't ignore requests anymore
         meshtastic_User &u = owner;

src/modules/NodeInfoModule.h

@@ -20,7 +20,8 @@ class NodeInfoModule : public ProtobufModule<meshtastic_User>, private concurren
     /**
      * Send our NodeInfo into the mesh
      */
-    void sendOurNodeInfo(NodeNum dest = NODENUM_BROADCAST, bool wantReplies = false, uint8_t channel = 0);
+    void sendOurNodeInfo(NodeNum dest = NODENUM_BROADCAST, bool wantReplies = false, uint8_t channel = 0,
+                         bool _shorterTimeout = false);
 
   protected:
     /** Called to handle a particular incoming message
@@ -38,6 +39,7 @@ class NodeInfoModule : public ProtobufModule<meshtastic_User>, private concurren
 
   private:
     uint32_t lastSentToMesh = 0; // Last time we sent our NodeInfo to the mesh
+    bool shorterTimeout = false;
 };
 
 extern NodeInfoModule *nodeInfoModule;