RNS/Destination.py

@@ -69,8 +69,6 @@ class Destination:
     OUT        = 0x12;
     directions = [IN, OUT]
 
-    PR_TAG_WINDOW = 30
-
     @staticmethod
     def expand_name(identity, app_name, *aspects):
         """
@@ -134,7 +132,6 @@ class Destination:
         self.proof_strategy = Destination.PROVE_NONE
         self.mtu = 0
 
-        self.path_responses = {}
         self.links = []
 
         if identity == None and direction == Destination.IN and self.type != Destination.PLAIN:
@@ -166,7 +163,7 @@ class Destination:
         return "<"+self.name+"/"+self.hexhash+">"
 
 
-    def announce(self, app_data=None, path_response=False, attached_interface=None, tag=None, send=True):
+    def announce(self, app_data=None, path_response=False, send=True):
         """
         Creates an announce packet for this destination and broadcasts it on all
         relevant interfaces. Application specific data can be added to the announce.
@@ -177,59 +174,34 @@ class Destination:
         if self.type != Destination.SINGLE:
             raise TypeError("Only SINGLE destination types can be announced")
             
-        now = time.time()
+        destination_hash = self.hash
-        stale_responses = []
+        random_hash = RNS.Identity.get_random_hash()[0:5]+int(time.time()).to_bytes(5, "big")
-        for entry_tag in self.path_responses:
-            entry = self.path_responses[entry_tag]
-            if now > entry[0]+Destination.PR_TAG_WINDOW:
-                stale_responses.append(entry_tag)
 
-        for entry_tag in stale_responses:
+        if app_data == None and self.default_app_data != None:
-            self.path_responses.pop(entry_tag)
+            if isinstance(self.default_app_data, bytes):
+                app_data = self.default_app_data
+            elif callable(self.default_app_data):
+                returned_app_data = self.default_app_data()
+                if isinstance(returned_app_data, bytes):
+                    app_data = returned_app_data
         
-        if (path_response == True and tag != None) and tag in self.path_responses:
+        signed_data = self.hash+self.identity.get_public_key()+self.name_hash+random_hash
-            # This code is currently not used, since Transport will block duplicate
+        if app_data != None:
-            # path requests based on tags. When multi-path support is implemented in
+            signed_data += app_data
-            # Transport, this will allow Transport to detect redundant paths to the
-            # same destination, and select the best one based on chosen criteria,
-            # since it will be able to detect that a single emitted announce was
-            # received via multiple paths. The difference in reception time will
-            # potentially also be useful in determining characteristics of the
-            # multiple available paths, and to choose the best one.
-            RNS.log("Using cached announce data for answering path request with tag "+RNS.prettyhexrep(tag), RNS.LOG_EXTREME)
-            announce_data = self.path_responses[tag][1]
 
-        else:
+        signature = self.identity.sign(signed_data)
-            destination_hash = self.hash
-            random_hash = RNS.Identity.get_random_hash()[0:5]+int(time.time()).to_bytes(5, "big")
 
-            if app_data == None and self.default_app_data != None:
+        announce_data = self.identity.get_public_key()+self.name_hash+random_hash+signature
-                if isinstance(self.default_app_data, bytes):
-                    app_data = self.default_app_data
-                elif callable(self.default_app_data):
-                    returned_app_data = self.default_app_data()
-                    if isinstance(returned_app_data, bytes):
-                        app_data = returned_app_data
 
-            signed_data = self.hash+self.identity.get_public_key()+self.name_hash+random_hash
+        if app_data != None:
-            if app_data != None:
+            announce_data += app_data
-                signed_data += app_data
-
-            signature = self.identity.sign(signed_data)
-
-            announce_data = self.identity.get_public_key()+self.name_hash+random_hash+signature
-
-            if app_data != None:
-                announce_data += app_data
-
-            self.path_responses[tag] = [time.time(), announce_data]
 
         if path_response:
             announce_context = RNS.Packet.PATH_RESPONSE
         else:
             announce_context = RNS.Packet.NONE
 
-        announce_packet = RNS.Packet(self, announce_data, RNS.Packet.ANNOUNCE, context = announce_context, attached_interface = attached_interface)
+        announce_packet = RNS.Packet(self, announce_data, RNS.Packet.ANNOUNCE, context = announce_context)
 
         if send:
             announce_packet.send()

RNS/Identity.py

@@ -255,22 +255,10 @@ class Identity:
                         RNS.Identity.remember(packet.get_hash(), destination_hash, public_key, app_data)
                         del announced_identity
 
-                        if packet.rssi != None or packet.snr != None:
-                            signal_str = " ["
-                            if packet.rssi != None:
-                                signal_str += "RSSI "+str(packet.rssi)+"dBm"
-                                if packet.snr != None:
-                                    signal_str += ", "
-                            if packet.snr != None:
-                                signal_str += "SNR "+str(packet.snr)+"dB"
-                            signal_str += "]"
-                        else:
-                            signal_str = ""
-
                         if hasattr(packet, "transport_id") and packet.transport_id != None:
-                            RNS.log("Valid announce for "+RNS.prettyhexrep(destination_hash)+" "+str(packet.hops)+" hops away, received via "+RNS.prettyhexrep(packet.transport_id)+" on "+str(packet.receiving_interface)+signal_str, RNS.LOG_EXTREME)
+                            RNS.log("Valid announce for "+RNS.prettyhexrep(destination_hash)+" "+str(packet.hops)+" hops away, received via "+RNS.prettyhexrep(packet.transport_id)+" on "+str(packet.receiving_interface), RNS.LOG_EXTREME)
                         else:
-                            RNS.log("Valid announce for "+RNS.prettyhexrep(destination_hash)+" "+str(packet.hops)+" hops away, received on "+str(packet.receiving_interface)+signal_str, RNS.LOG_EXTREME)
+                            RNS.log("Valid announce for "+RNS.prettyhexrep(destination_hash)+" "+str(packet.hops)+" hops away, received on "+str(packet.receiving_interface), RNS.LOG_EXTREME)
 
                         return True
 

RNS/Transport.py

@@ -1948,9 +1948,10 @@ class Transport:
         
         local_destination = next((d for d in Transport.destinations if d.hash == destination_hash), None)
         if local_destination != None:
-            local_destination.announce(path_response=True, tag=tag, attached_interface=attached_interface)
+            local_destination.announce(path_response=True)
             RNS.log("Answering path request for "+RNS.prettyhexrep(destination_hash)+interface_str+", destination is local to this system", RNS.LOG_DEBUG)
 
+
         elif (RNS.Reticulum.transport_enabled() or is_from_local_client) and (destination_hash in Transport.destination_table):
             packet = Transport.destination_table[destination_hash][6]
             next_hop = Transport.destination_table[destination_hash][1]
@@ -1995,10 +1996,9 @@ class Transport:
             # Forward path request on all interfaces
             # except the local client
             RNS.log("Forwarding path request from local client for "+RNS.prettyhexrep(destination_hash)+interface_str+" to all other interfaces", RNS.LOG_DEBUG)
-            request_tag = RNS.Identity.get_random_hash()
             for interface in Transport.interfaces:
                 if not interface == attached_interface:
-                    Transport.request_path(destination_hash, interface, tag = request_tag)
+                    Transport.request_path(destination_hash, interface)
 
         elif should_search_for_unknown:
             if destination_hash in Transport.discovery_path_requests: