Merge pull request #1258 from mc-hamster/router

Add role to generated proto

src/main.cpp

@@ -9,6 +9,7 @@
 #include "error.h"
 #include "power.h"
 // #include "rom/rtc.h"
+#include "DSRRouter.h"
 // #include "debug.h"
 #include "FSCommon.h"
 #include "RTC.h"
@@ -61,6 +62,8 @@ uint8_t screen_found;
 
 bool axp192_found;
 
+Router *router = NULL; // Users of router don't care what sort of subclass implements that API
+
 // -----------------------------------------------------------------------------
 // Application
 // -----------------------------------------------------------------------------
@@ -440,6 +443,8 @@ void setup()
 
     fsInit();
 
+    router = new DSRRouter();
+
 #ifdef I2C_SDA
     Wire.begin(I2C_SDA, I2C_SCL);
 #elif !defined(NO_WIRE)
@@ -657,6 +662,7 @@ void setup()
     if (!rIf)
         RECORD_CRITICALERROR(CriticalErrorCode_NoRadio);
     else{
+        router->addInterface(rIf);
 
         // Calculate and save the bit rate to myNodeInfo
         // TODO: This needs to be added what ever method changes the channel from the phone.

src/mesh/DSRRouter.cpp

@@ -0,0 +1,250 @@
+#include "configuration.h"
+#include "DSRRouter.h"
+
+/* when we receive any packet
+
+- sniff and update tables (especially useful to find adjacent nodes). Update user, network and position info.
+- if we need to route() that packet, resend it to the next_hop based on our nodedb.
+- if it is broadcast or destined for our node, deliver locally
+- handle routereply/routeerror/routediscovery messages as described below
+- then free it
+
+routeDiscovery
+
+- if we've already passed through us (or is from us), then it ignore it
+- use the nodes already mentioned in the request to update our routing table
+- if they were looking for us, send back a routereply
+- if max_hops is zero and they weren't looking for us, drop (FIXME, send back error - I think not though?)
+- if we receive a discovery packet, we use it to populate next_hop (if needed) towards the requester (after decrementing max_hops)
+- if we receive a discovery packet, and we have a next_hop in our nodedb for that destination we send a (reliable) we send a route
+reply towards the requester
+
+when sending any reliable packet
+
+- if timeout doing retries, send a routeError (nak) message back towards the original requester. all nodes eavesdrop on that
+packet and update their route caches.
+
+when we receive a routereply packet
+
+- update next_hop on the node, if the new reply needs fewer hops than the existing one (we prefer shorter paths). fixme, someday
+use a better heuristic
+
+when we receive a routeError packet
+
+- delete the route for that failed recipient, restartRouteDiscovery()
+- if we receive routeerror in response to a discovery,
+- fixme, eventually keep caches of possible other routes.
+*/
+
+ErrorCode DSRRouter::send(MeshPacket *p)
+{
+    // We only consider multihop routing packets (i.e. those with dest set)
+    if (p->decoded.dest) {
+        // add an entry for this pending message
+        auto pending = startRetransmission(p);
+        // FIXME - when acks come in for this packet, we should _not_ delete the record unless the ack was from
+        // the final dest.  We need to keep that record around until FIXME
+        // Also we should not retransmit multihop entries in that table at all
+
+        // If we have an entry in our routing tables, just send it, otherwise start a route discovery
+        NodeNum nextHop = getNextHop(p->decoded.dest);
+        if (nextHop) {
+            sendNextHop(nextHop, p); // start a reliable single hop send
+        } else {
+            pending->wantRoute = true;
+
+            // start discovery, but only if we don't already a discovery in progress for that node number
+            startDiscovery(p->decoded.dest);
+        }
+
+        return ERRNO_OK;
+    } else
+        return ReliableRouter::send(p);
+}
+
+void DSRRouter::sniffReceived(const MeshPacket *p, const Routing *c)
+{
+    // Learn 0 hop routes by just hearing any adjacent nodes
+    // But treat broadcasts carefully, because when flood broadcasts go out they keep the same original "from".  So we want to
+    // ignore rebroadcasts.
+    // this will also add records for any ACKs we receive for our messages
+    if (p->to != NODENUM_BROADCAST || p->hop_limit != HOP_RELIABLE) {
+        addRoute(getFrom(p), getFrom(p), 0); // We are adjacent with zero hops
+    }
+
+    if (c)
+        switch (c->which_variant) {
+        case Routing_route_request_tag:
+            // Handle route discovery packets (will be a broadcast message)
+            // FIXME - always start request with the senders nodenum
+            if (weAreInRoute(c->route_request)) {
+                DEBUG_MSG("Ignoring a route request that contains us\n");
+            } else {
+                updateRoutes(c->route_request,
+                             true); // Update our routing tables based on the route that came in so far on this request
+
+                if (p->decoded.dest == getNodeNum()) {
+                    // They were looking for us, send back a route reply (the sender address will be first in the list)
+                    sendRouteReply(c->route_request);
+                } else {
+                    // They were looking for someone else, forward it along (as a zero hop broadcast)
+                    NodeNum nextHop = getNextHop(p->decoded.dest);
+                    if (nextHop) {
+                        // in our route cache, reply to the requester (the sender address will be first in the list)
+                        sendRouteReply(c->route_request, nextHop);
+                    } else {
+                        // Not in our route cache, rebroadcast on their behalf (after adding ourselves to the request route)
+                        resendRouteRequest(p);
+                    }
+                }
+            }
+            break;
+        case Routing_route_reply_tag:
+            updateRoutes(c->route_reply, false);
+
+            // FIXME, if any of our current pending packets were waiting for this route, send them (and leave them as regular
+            // pending packets until ack arrives)
+            // FIXME, if we don't get a route reply at all (or a route error), timeout and generate a routeerror TIMEOUT on our
+            // own...
+            break;
+        case Routing_error_reason_tag:
+            removeRoute(p->decoded.dest);
+
+            // FIXME: if any pending packets were waiting on this route, delete them
+            break;
+        default:
+            break;
+        }
+
+    // We simply ignore ACKs - because ReliableRouter will delete the pending packet for us
+
+    // Handle regular packets
+    if (p->to == getNodeNum()) { // Destined for us (at least for this hop)
+
+        // We need to route this packet to some other node
+        if (p->decoded.dest && p->decoded.dest != p->to) {
+            // if we have a route out, resend the packet to the next hop, otherwise return RouteError no-route available
+
+            NodeNum nextHop = getNextHop(p->decoded.dest);
+            if (nextHop) {
+                sendNextHop(nextHop, p); // start a reliable single hop send
+            } else {
+                // We don't have a route out
+                assert(p->decoded.source); // I think this is guaranteed by now
+
+                // FIXME - what if the current packet _is_ a route error packet?
+                sendRouteError(p, Routing_Error_NO_ROUTE);
+            }
+
+            // FIXME, stop local processing of this packet
+        }
+
+        if (c) {
+            // handle naks - convert them to route error packets
+            // All naks are generated locally, because we failed resending the packet too many times
+            PacketId nakId = c->error_reason ? p->decoded.request_id : 0;
+            if (nakId) {
+                auto pending = findPendingPacket(p->to, nakId);
+                if (pending &&
+                    pending->packet->decoded.source) {          // if source not set, this was not a multihop packet, just ignore
+                    removeRoute(pending->packet->decoded.dest); // We no longer have a route to the specified node
+
+                    sendRouteError(p, Routing_Error_GOT_NAK);
+                }
+            }
+        }
+    }
+
+    ReliableRouter::sniffReceived(p, c);
+}
+
+/**
+ * Does our node appear in the specified route
+ */
+bool DSRRouter::weAreInRoute(const RouteDiscovery &route)
+{
+    return true; // FIXME
+}
+
+/**
+ * Given a DSR route, use that route to update our DB of possible routes
+ *
+ * Note: routes are always listed in the same order - from sender to receipient (i.e. route_replies also use this some order)
+ *
+ * @param isRequest is true if we are looking at a route request, else we are looking at a reply
+ **/
+void DSRRouter::updateRoutes(const RouteDiscovery &route, bool isRequest)
+{
+    DEBUG_MSG("FIXME not implemented updateRoutes\n");
+}
+
+/**
+ * send back a route reply (the sender address will be first in the list)
+ */
+void DSRRouter::sendRouteReply(const RouteDiscovery &route, NodeNum toAppend)
+{
+    DEBUG_MSG("FIXME not implemented sendRoute\n");
+}
+
+/**
+ * Given a nodenum return the next node we should forward to if we want to reach that node.
+ *
+ * @return 0 if no route found
+ */
+NodeNum DSRRouter::getNextHop(NodeNum dest)
+{
+    DEBUG_MSG("FIXME not implemented getNextHop\n");
+    return 0;
+}
+
+/** Not in our route cache, rebroadcast on their behalf (after adding ourselves to the request route)
+ *
+ * We will bump down hop_limit in this call.
+ */
+void DSRRouter::resendRouteRequest(const MeshPacket *p)
+{
+    DEBUG_MSG("FIXME not implemented resendRoute\n");
+}
+
+/**
+ * Record that forwarder can reach dest for us, but they will need numHops to get there.
+ * If our routing tables already have something that can reach that node in fewer hops we will keep the existing route
+ * instead.
+ */
+void DSRRouter::addRoute(NodeNum dest, NodeNum forwarder, uint8_t numHops)
+{
+    DEBUG_MSG("FIXME not implemented addRoute\n");
+}
+
+/**
+ * Record that we no longer have a route to the dest
+ */
+void DSRRouter::removeRoute(NodeNum dest)
+{
+    DEBUG_MSG("FIXME not implemented removeRoute\n");
+}
+
+/**
+ * Forward the specified packet to the specified node
+ */
+void DSRRouter::sendNextHop(NodeNum n, const MeshPacket *p)
+{
+    DEBUG_MSG("FIXME not implemented sendNextHop\n");
+}
+
+/**
+ * Send a route error packet towards whoever originally sent this message
+ */
+void DSRRouter::sendRouteError(const MeshPacket *p, Routing_Error err)
+{
+    DEBUG_MSG("FIXME not implemented sendRouteError\n");
+}
+
+/** make a copy of p, start discovery, but only if we don't
+ *  already a discovery in progress for that node number.  Caller has already scheduled this message for retransmission
+ *  when the discovery is complete.
+ */
+void DSRRouter::startDiscovery(NodeNum dest)
+{
+    DEBUG_MSG("FIXME not implemented startDiscovery\n");
+}

src/mesh/DSRRouter.h

@@ -0,0 +1,80 @@
+#include "ReliableRouter.h"
+
+class DSRRouter : public ReliableRouter
+{
+
+  protected:
+    /**
+     * Every (non duplicate) packet this node receives will be passed through this method.  This allows subclasses to
+     * update routing tables etc... based on what we overhear (even for messages not destined to our node)
+     */
+    virtual void sniffReceived(const MeshPacket *p, const Routing *c) override;
+
+    /**
+     * Send a packet on a suitable interface.  This routine will
+     * later free() the packet to pool.  This routine is not allowed to stall.
+     * If the txmit queue is full it might return an error
+     */
+    virtual ErrorCode send(MeshPacket *p) override;
+
+  private:
+    /**
+     * Does our node appear in the specified route
+     */
+    bool weAreInRoute(const RouteDiscovery &route);
+
+    /**
+     * Given a DSR route, use that route to update our DB of possible routes
+     *
+     * Note: routes are always listed in the same order - from sender to receipient (i.e. route_replies also use this some order)
+     *
+     * @param isRequest is true if we are looking at a route request, else we are looking at a reply
+     **/
+    void updateRoutes(const RouteDiscovery &route, bool isRequest);
+
+    /**
+     * send back a route reply (the sender address will be first in the list)
+     */
+    void sendRouteReply(const RouteDiscovery &route, NodeNum toAppend = 0);
+
+    /**
+     * Given a nodenum return the next node we should forward to if we want to reach that node.
+     *
+     * @return 0 if no route found
+     */
+    NodeNum getNextHop(NodeNum dest);
+
+    /** Not in our route cache, rebroadcast on their behalf (after adding ourselves to the request route)
+     *
+     * We will bump down hop_limit in this call.
+     */
+    void resendRouteRequest(const MeshPacket *p);
+
+    /**
+     * Record that forwarder can reach dest for us, but they will need numHops to get there.
+     * If our routing tables already have something that can reach that node in fewer hops we will keep the existing route
+     * instead.
+     */
+    void addRoute(NodeNum dest, NodeNum forwarder, uint8_t numHops);
+
+    /**
+     * Record that we no longer have a route to the dest
+     */
+    void removeRoute(NodeNum dest);
+
+    /**
+     * Forward the specified packet to the specified node
+     */
+    void sendNextHop(NodeNum n, const MeshPacket *p);
+
+    /**
+     * Send a route error packet towards whoever originally sent this message
+     */
+    void sendRouteError(const MeshPacket *p, Routing_Error err);
+
+    /** make a copy of p, start discovery, but only if we don't
+     *  already a discovery in progress for that node number.  Caller has already scheduled this message for retransmission
+     *  when the discovery is complete.
+     */
+    void startDiscovery(NodeNum dest);
+};

src/mesh/generated/admin.pb.h

@@ -125,7 +125,7 @@ extern const pb_msgdesc_t AdminMessage_msg;
 #define AdminMessage_fields &AdminMessage_msg
 
 /* Maximum encoded size of messages (where known) */
-#define AdminMessage_size                        608
+#define AdminMessage_size                        611
 
 #ifdef __cplusplus
 } /* extern "C" */

src/mesh/generated/radioconfig.pb.c

@@ -21,3 +21,4 @@ PB_BIND(RadioConfig_UserPreferences, RadioConfig_UserPreferences, 2)
 
 
 
+

src/mesh/generated/radioconfig.pb.h

@@ -26,6 +26,12 @@ typedef enum _RegionCode {
     RegionCode_TH = 12
 } RegionCode;
 
+typedef enum _Role {
+    Role_Default = 0,
+    Role_Router = 1,
+    Role_Repeater = 2
+} Role;
+
 typedef enum _ChargeCurrent {
     ChargeCurrent_MAUnset = 0,
     ChargeCurrent_MA100 = 1,
@@ -123,6 +129,7 @@ typedef struct _RadioConfig_UserPreferences {
     RegionCode region;
     ChargeCurrent charge_current;
     bool position_broadcast_smart;
+    Role role;
     LocationSharing location_share;
     GpsOperation gps_operation;
     uint32_t gps_update_interval;
@@ -204,6 +211,10 @@ typedef struct _RadioConfig {
 #define _RegionCode_MAX RegionCode_TH
 #define _RegionCode_ARRAYSIZE ((RegionCode)(RegionCode_TH+1))
 
+#define _Role_MIN Role_Default
+#define _Role_MAX Role_Repeater
+#define _Role_ARRAYSIZE ((Role)(Role_Repeater+1))
+
 #define _ChargeCurrent_MIN ChargeCurrent_MAUnset
 #define _ChargeCurrent_MAX ChargeCurrent_MA1320
 #define _ChargeCurrent_ARRAYSIZE ((ChargeCurrent)(ChargeCurrent_MA1320+1))
@@ -239,9 +250,9 @@ extern "C" {
 
 /* Initializer values for message structs */
 #define RadioConfig_init_default                 {false, RadioConfig_UserPreferences_init_default}
-#define RadioConfig_UserPreferences_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "", "", 0, _RegionCode_MIN, _ChargeCurrent_MIN, 0, _LocationSharing_MIN, _GpsOperation_MIN, 0, 0, 0, 0, 0, 0, 0, "", 0, _GpsCoordinateFormat_MIN, 0, 0, 0, 0, 0, {0, 0, 0}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, _RadioConfig_UserPreferences_TelemetrySensorType_MIN, 0, 0, 0, 0, 0, 0, 0, 0, "", "", 0, 0, 0, 0, 0, 0, _InputEventChar_MIN, _InputEventChar_MIN, _InputEventChar_MIN, 0, "", 0, 0, 0, 0}
+#define RadioConfig_UserPreferences_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "", "", 0, _RegionCode_MIN, _ChargeCurrent_MIN, 0, _Role_MIN, _LocationSharing_MIN, _GpsOperation_MIN, 0, 0, 0, 0, 0, 0, 0, "", 0, _GpsCoordinateFormat_MIN, 0, 0, 0, 0, 0, {0, 0, 0}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, _RadioConfig_UserPreferences_TelemetrySensorType_MIN, 0, 0, 0, 0, 0, 0, 0, 0, "", "", 0, 0, 0, 0, 0, 0, _InputEventChar_MIN, _InputEventChar_MIN, _InputEventChar_MIN, 0, "", 0, 0, 0, 0}
 #define RadioConfig_init_zero                    {false, RadioConfig_UserPreferences_init_zero}
-#define RadioConfig_UserPreferences_init_zero    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "", "", 0, _RegionCode_MIN, _ChargeCurrent_MIN, 0, _LocationSharing_MIN, _GpsOperation_MIN, 0, 0, 0, 0, 0, 0, 0, "", 0, _GpsCoordinateFormat_MIN, 0, 0, 0, 0, 0, {0, 0, 0}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, _RadioConfig_UserPreferences_TelemetrySensorType_MIN, 0, 0, 0, 0, 0, 0, 0, 0, "", "", 0, 0, 0, 0, 0, 0, _InputEventChar_MIN, _InputEventChar_MIN, _InputEventChar_MIN, 0, "", 0, 0, 0, 0}
+#define RadioConfig_UserPreferences_init_zero    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "", "", 0, _RegionCode_MIN, _ChargeCurrent_MIN, 0, _Role_MIN, _LocationSharing_MIN, _GpsOperation_MIN, 0, 0, 0, 0, 0, 0, 0, "", 0, _GpsCoordinateFormat_MIN, 0, 0, 0, 0, 0, {0, 0, 0}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, _RadioConfig_UserPreferences_TelemetrySensorType_MIN, 0, 0, 0, 0, 0, 0, 0, 0, "", "", 0, 0, 0, 0, 0, 0, _InputEventChar_MIN, _InputEventChar_MIN, _InputEventChar_MIN, 0, "", 0, 0, 0, 0}
 
 /* Field tags (for use in manual encoding/decoding) */
 #define RadioConfig_UserPreferences_position_broadcast_secs_tag 1
@@ -260,6 +271,7 @@ extern "C" {
 #define RadioConfig_UserPreferences_region_tag   15
 #define RadioConfig_UserPreferences_charge_current_tag 16
 #define RadioConfig_UserPreferences_position_broadcast_smart_tag 17
+#define RadioConfig_UserPreferences_role_tag     18
 #define RadioConfig_UserPreferences_location_share_tag 32
 #define RadioConfig_UserPreferences_gps_operation_tag 33
 #define RadioConfig_UserPreferences_gps_update_interval_tag 34
@@ -353,6 +365,7 @@ X(a, STATIC,   SINGULAR, BOOL,     wifi_ap_mode,     14) \
 X(a, STATIC,   SINGULAR, UENUM,    region,           15) \
 X(a, STATIC,   SINGULAR, UENUM,    charge_current,   16) \
 X(a, STATIC,   SINGULAR, BOOL,     position_broadcast_smart,  17) \
+X(a, STATIC,   SINGULAR, UENUM,    role,             18) \
 X(a, STATIC,   SINGULAR, UENUM,    location_share,   32) \
 X(a, STATIC,   SINGULAR, UENUM,    gps_operation,    33) \
 X(a, STATIC,   SINGULAR, UINT32,   gps_update_interval,  34) \
@@ -431,8 +444,8 @@ extern const pb_msgdesc_t RadioConfig_UserPreferences_msg;
 #define RadioConfig_UserPreferences_fields &RadioConfig_UserPreferences_msg
 
 /* Maximum encoded size of messages (where known) */
-#define RadioConfig_size                         605
-#define RadioConfig_UserPreferences_size         602
+#define RadioConfig_size                         608
+#define RadioConfig_UserPreferences_size         605
 
 #ifdef __cplusplus
 } /* extern "C" */