Prevent answering path requests on roaming-mode interfaces for next-hop instances on same roaming-mode interface

RNS/Resource.py

@@ -476,7 +476,8 @@ class Resource:
                     
                     if sleep_time < 0:
                         if self.retries_left > 0:
-                            RNS.log("Timed out waiting for parts, requesting retry", RNS.LOG_DEBUG)
+                            ms = "" if self.outstanding_parts == 1 else "s"
+                            RNS.log("Timed out waiting for "+str(self.outstanding_parts)+" part"+ms+", requesting retry", RNS.LOG_DEBUG)
                             if self.window > self.window_min:
                                 self.window -= 1
                                 if self.window_max > self.window_min:

RNS/Transport.py

@@ -2047,40 +2047,44 @@ class Transport:
             next_hop = Transport.destination_table[destination_hash][1]
             received_from = Transport.destination_table[destination_hash][5]
 
-            if requestor_transport_id != None and next_hop == requestor_transport_id:
+            if attached_interface.mode == RNS.Interfaces.Interface.Interface.MODE_ROAMING and attached_interface == received_from:
-                # TODO: Find a bandwidth efficient way to invalidate our
+                RNS.log("Not answering path request on roaming-mode interface, since next hop is on same roaming-mode interface", RNS.LOG_DEBUG)
-                # known path on this signal. The obvious way of signing
+            
-                # path requests with transport instance keys is quite
-                # inefficient. There is probably a better way. Doing
-                # path invalidation here would decrease the network
-                # convergence time. Maybe just drop it?
-                RNS.log("Not answering path request for "+RNS.prettyhexrep(destination_hash)+interface_str+", since next hop is the requestor", RNS.LOG_DEBUG)
             else:
-                RNS.log("Answering path request for "+RNS.prettyhexrep(destination_hash)+interface_str+", path is known", RNS.LOG_DEBUG)
+                if requestor_transport_id != None and next_hop == requestor_transport_id:
-
+                    # TODO: Find a bandwidth efficient way to invalidate our
-                now = time.time()
+                    # known path on this signal. The obvious way of signing
-                retries = Transport.PATHFINDER_R
+                    # path requests with transport instance keys is quite
-                local_rebroadcasts = 0
+                    # inefficient. There is probably a better way. Doing
-                block_rebroadcasts = True
+                    # path invalidation here would decrease the network
-                announce_hops      = packet.hops
+                    # convergence time. Maybe just drop it?
-
+                    RNS.log("Not answering path request for "+RNS.prettyhexrep(destination_hash)+interface_str+", since next hop is the requestor", RNS.LOG_DEBUG)
-                if is_from_local_client:
-                    retransmit_timeout = now
                 else:
-                    # TODO: Look at this timing
+                    RNS.log("Answering path request for "+RNS.prettyhexrep(destination_hash)+interface_str+", path is known", RNS.LOG_DEBUG)
-                    retransmit_timeout = now + Transport.PATH_REQUEST_GRACE # + (RNS.rand() * Transport.PATHFINDER_RW)
 
-                # This handles an edge case where a peer sends a past
+                    now = time.time()
-                # request for a destination just after an announce for
+                    retries = Transport.PATHFINDER_R
-                # said destination has arrived, but before it has been
+                    local_rebroadcasts = 0
-                # rebroadcast locally. In such a case the actual announce
+                    block_rebroadcasts = True
-                # is temporarily held, and then reinserted when the path
+                    announce_hops      = packet.hops
-                # request has been served to the peer.
-                if packet.destination_hash in Transport.announce_table:
-                    held_entry = Transport.announce_table[packet.destination_hash]
-                    Transport.held_announces[packet.destination_hash] = held_entry
 
-                Transport.announce_table[packet.destination_hash] = [now, retransmit_timeout, retries, received_from, announce_hops, packet, local_rebroadcasts, block_rebroadcasts, attached_interface]
+                    if is_from_local_client:
+                        retransmit_timeout = now
+                    else:
+                        # TODO: Look at this timing
+                        retransmit_timeout = now + Transport.PATH_REQUEST_GRACE # + (RNS.rand() * Transport.PATHFINDER_RW)
+
+                    # This handles an edge case where a peer sends a past
+                    # request for a destination just after an announce for
+                    # said destination has arrived, but before it has been
+                    # rebroadcast locally. In such a case the actual announce
+                    # is temporarily held, and then reinserted when the path
+                    # request has been served to the peer.
+                    if packet.destination_hash in Transport.announce_table:
+                        held_entry = Transport.announce_table[packet.destination_hash]
+                        Transport.held_announces[packet.destination_hash] = held_entry
+                    
+                    Transport.announce_table[packet.destination_hash] = [now, retransmit_timeout, retries, received_from, announce_hops, packet, local_rebroadcasts, block_rebroadcasts, attached_interface]
 
         elif is_from_local_client:
             # Forward path request on all interfaces

RNS/Utilities/rnpath.py

@@ -187,15 +187,20 @@ def program_setup(configdir, table, rates, drop, destination_hexhash, verbosity,
 
         if RNS.Transport.has_path(destination_hash):
             hops = RNS.Transport.hops_to(destination_hash)
-            next_hop = RNS.prettyhexrep(reticulum.get_next_hop(destination_hash))
+            next_hop_bytes = reticulum.get_next_hop(destination_hash)
-            next_hop_interface = reticulum.get_next_hop_if_name(destination_hash)
+            if next_hop_bytes == None:
-
+                print("\r                                                       \rError: Invalid path data returned")
-            if hops != 1:
+                sys.exit(1)
-                ms = "s"
             else:
-                ms = ""
+                next_hop = RNS.prettyhexrep(next_hop_bytes)
+                next_hop_interface = reticulum.get_next_hop_if_name(destination_hash)
 
-            print("\rPath found, destination "+RNS.prettyhexrep(destination_hash)+" is "+str(hops)+" hop"+ms+" away via "+next_hop+" on "+next_hop_interface)
+                if hops != 1:
+                    ms = "s"
+                else:
+                    ms = ""
+
+                print("\rPath found, destination "+RNS.prettyhexrep(destination_hash)+" is "+str(hops)+" hop"+ms+" away via "+next_hop+" on "+next_hop_interface)
         else:
             print("\r                                                       \rPath not found")
             sys.exit(1)