add beginnings of full DSR routing

src/mesh/DSRRouter.cpp

@@ -0,0 +1,80 @@
+#include "DSRRouter.h"
+#include "configuration.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.
+*/
+
+void DSRRouter::sniffReceived(const MeshPacket *p)
+{
+
+    // FIXME, update nodedb
+
+    // Handle route discovery packets (will be a broadcast message)
+    if (p->decoded.which_payload == SubPacket_request_tag) {
+        // FIXME - always start request with the senders nodenum
+
+        if (weAreInRoute(p->decoded.request)) {
+            DEBUG_MSG("Ignoring a route request that contains us\n");
+        } else {
+            updateRoutes(p->decoded.request, false); // 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(p->decoded.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(p->decoded.request, nextHop);
+                } else {
+                    // Not in our route cache, rebroadcast on their behalf (after adding ourselves to the request route)
+                    resendRouteRequest(p);
+                }
+            }
+        }
+    }
+
+    // Handle regular packets
+    if (p->to == getNodeNum()) { // Destined for us (at least for this hop)
+
+        // We need to route this packet
+        if (p->decoded.dest != p->to) {
+            // FIXME
+        }
+    }
+
+    return ReliableRouter::sniffReceived(p);
+}

src/mesh/DSRRouter.h

@@ -0,0 +1,39 @@
+#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);
+
+  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
+     **/
+    void updateRoutes(const RouteDiscovery &route, bool reverse);
+
+    /**
+     * 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)
+     */
+    void resendRouteRequest(const MeshPacket *p);
+};

src/mesh/Router.cpp

@@ -90,6 +90,10 @@ ErrorCode Router::send(MeshPacket *p)
         packetPool.release(p);
         return ERRNO_OK;
     } else {
+        // Never set the want_ack flag on broadcast packets sent over the air.
+        if (p->to == NODENUM_BROADCAST)
+            p->want_ack = false;
+
         // 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 == MeshPacket_encrypted_tag ||
@@ -125,9 +129,10 @@ ErrorCode Router::send(MeshPacket *p)
  * 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)
  */
-void Router::sniffReceived(MeshPacket *p)
+void Router::sniffReceived(const MeshPacket *p)
 {
-    DEBUG_MSG("Sniffing packet not sent to us fr=0x%x,to=0x%x,id=%d\n", p->from, p->to, p->id);
+    DEBUG_MSG("FIXME-update-db Sniffing packet fr=0x%x,to=0x%x,id=%d\n", p->from, p->to, p->id);
+
 }
 
 bool Router::perhapsDecode(MeshPacket *p)

src/mesh/Router.h

@@ -75,7 +75,7 @@ class Router
      * 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(MeshPacket *p);
+    virtual void sniffReceived(const MeshPacket *p);
 
     /**
      * Remove any encryption and decode the protobufs inside this packet (if necessary).