Prepare release

Changelog.md

@@ -1,10 +1,20 @@
-### 2026-06-01: RNS 1.3.5
+### 2026-07-19: RNS 1.3.9
 
-This maintenance release contains an important fix for `AutoInterface` reliability when roaming between different physical networks.
+**Critical Security Update**: This release fixes a severe security flaw in `rnsh`. Due to the nature of the issue, I will not disclose any further details for the time being. Once operators have had time to update, I will provide a full report for transparency. If you use `rnsh`, update **right now**.
+
+**Important**: The new version of `rnsh` changes default identity file locations, and these will now be sourced from `~/.rnsh/identity` (initiator) and `~/.rnsh/identity.default` (listener). Make sure you copy your old files to this directory, or specify a custom identity path using the command line arguments. The `--config` argument has also been renamed to `--rnsconfig`, and the `--config` argument will now specify the `rnsh` configuration directory instead of the RNS configuration directory, bringing the behavior into alignment with other RNS utilities. 
+
+Additionally, this release includes automated blocking of fast-flapping clients on `BackboneInterface` listeners (see the Interfaces chapter of the manual for details), and a number of improvements to resource handling. The logging system has also been improved, and path and destination information moved to a new `LOG_PATHING` loglevel, to decrease log noise.
 
 **Changes**
-- Fixed UDP listener replacement deadlocking inbound AutoInterface traffic when fast-roaming between physical interfaces or WiFi APs
-- Fixed some paths never resolving when using other interfaces at the same time as a deadlocked AutoInterface
+- Fixed a critical security issue in `rnsh`
+- Added automated blocking of fast-flapping clients to `BackboneInterface`
+- Added new `LOG_PATHING` loglevel, improved logging
+- Added ability to make internal-mode interfaces discoverable
+- Added ability to get discoverable interface location from external script
+- Added `RESOURCE_RCL` signal on resource receiver cancel
+- Improved resource handling and reliability
+- Updated `rnsh` config args to work similarly to other RNS utilities
 
 **Verified Retrieval**
 You can retrieve and verify this release over Reticulum using the built-in `rngit release` utility. To retrieve only the installation `.whl` package, and the release manifest for future updates, you can use:
@@ -34,6 +44,39 @@ rnid -i bc7291552be7a58f361522990465165c -V rns_*.rsm *.rsg
 
 The `rnid` utility will then verify the signatures, and display whether they are valid. If the signature cannot be verified, the release has been tampered with and should be discarded.
 
+### 2026-07-10: RNS 1.3.8
+
+This release fixes various inconsistencies in link and hop-count related APIs.
+
+**Changes**
+- Fixed inconsistent link traffic stats calculation
+- Fixed link hop-count metric only being available on initiator side
+- Fixed potential hop-count serialization error on transport
+- Updated `WeaveInterface` to support latest Weave firmware
+
+### 2026-07-03: RNS 1.3.7
+
+This maintenance release improves announces propagation logic, and adds additional options for configuring announce propagation and interface behavior in transport mode.
+
+**Changes**
+- Added `internal` interface mode
+- Added `recursive_prs` interface option
+- Added `announces_from_internal` interface option
+- Added new options to the manual
+- Improved and cleaned up announce propagation logic
+
+### 2026-07-03: RNS 1.3.6
+
+This release contained a bug in the local instance transport handling, and was superseded by version `1.3.7`.
+
+### 2026-06-01: RNS 1.3.5
+
+This maintenance release contains an important fix for `AutoInterface` reliability when roaming between different physical networks.
+
+**Changes**
+- Fixed UDP listener replacement deadlocking inbound AutoInterface traffic when fast-roaming between physical interfaces or WiFi APs
+- Fixed some paths never resolving when using other interfaces at the same time as a deadlocked AutoInterface
+
 ### 2026-05-29: RNS 1.3.4
 
 This release fixes a regression that could cause sub-optimal path selection under conditions where the same announce was received within a very short timespan on different interfaces, as well as a few other bugs and inefficiencies.

RNS/Discovery.py

@@ -99,6 +99,33 @@ class InterfaceAnnouncer():
 
         if not interface_type in self.DISCOVERABLE_INTERFACE_TYPES: return None
         else:
+            if not RNS.vendor.platformutils.is_windows() and interface.discovery_location:
+                try:
+                    discovery_location = self.sanitize(interface.discovery_location)
+                    exec_path = os.path.expanduser(discovery_location)
+                    if os.path.isfile(exec_path) and os.access(exec_path, os.X_OK):
+                        RNS.log(f"Evaluating discovery location from executable at {exec_path}", RNS.LOG_DEBUG)
+                        exec_result = subprocess.run([exec_path], stdout=subprocess.PIPE)
+                        exec_stdout = exec_result.stdout.decode("utf-8")
+                        if exec_result.returncode != 0: raise ValueError("Non-zero exit code from subprocess")
+                        discovery_location = self.sanitize(exec_stdout)
+                        location_components = discovery_location.replace(" ", "").split(",")
+                        if len(location_components) != 3: raise ValueError(f"Invalid location component count: {len(location_components)}")
+                        dlat = float(location_components[0])
+                        dlon = float(location_components[1])
+                        dhgt = float(location_components[2])
+                        if dlat < -90   or dlat > 90:  raise ValueError(f"Invalid latitude: {dlat}")
+                        if dlon < -180  or dlat > 180: raise ValueError(f"Invalid longitude: {dlon}")
+                        if dhgt < -4000 or dhgt > 1e6: raise ValueError(f"Invalid height: {dhgt}")
+                        interface.discovery_latitude  = dlat
+                        interface.discovery_longitude = dlon
+                        interface.discovery_height    = dhgt
+
+                except Exception as e:
+                    RNS.log(f"Error while getting reachable_on from executable at {interface.reachable_on}: {e}", RNS.LOG_ERROR)
+                    RNS.log(f"Aborting discovery announce", RNS.LOG_ERROR)
+                    return None
+
             flags = 0x00
             info  = {INTERFACE_TYPE: interface_type,
                      TRANSPORT:      RNS.Reticulum.transport_enabled(),
@@ -237,7 +264,7 @@ class InterfaceAnnounceHandler:
                 valid     = self.stamper.stamp_valid(stamp, self.required_value, workblock)
 
                 if not valid:
-                    RNS.log(f"Ignored discovered interface with invalid stamp", RNS.LOG_DEBUG)
+                    RNS.log(f"Ignored discovered interface with insufficient stamp value {value}", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
                     return
 
                 if value < self.required_value: RNS.log(f"Ignored discovered interface with stamp value {value}", RNS.LOG_DEBUG)

RNS/Identity.py

@@ -213,7 +213,7 @@ class Identity:
                 except Exception as e:
                     RNS.log("Skipped recombining known destinations from disk, since an error occurred: "+str(e), RNS.LOG_WARNING)
 
-            RNS.log("Saving "+str(len(Identity.known_destinations))+" known destinations to storage...", RNS.LOG_VERBOSE)
+            RNS.log("Saving "+str(len(Identity.known_destinations))+" known destinations to storage...", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
             temp_file = RNS.Reticulum.storagepath+f"/known_destinations.tmp.{time.time()}"
 
             try:
@@ -230,7 +230,7 @@ class Identity:
             if save_time < 1: time_str = str(round(save_time*1000,2))+"ms"
             else:             time_str = str(round(save_time,2))+"s"
 
-            RNS.log("Saved known destinations to storage in "+time_str, RNS.LOG_VERBOSE)
+            RNS.log("Saved known destinations to storage in "+time_str, RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
 
         except Exception as e:
             RNS.log("Error while saving known destinations to disk, the contained exception was: "+str(e), RNS.LOG_ERROR)

RNS/Interfaces/BackboneInterface.py

@@ -54,6 +54,13 @@ class BackboneInterface(Interface):
     DEFAULT_IFAC_SIZE = 16
     AUTOCONFIGURE_MTU = True
 
+    BLOCK_FAST_FLAPPING = True
+    FAST_FLAP_THRESHOLD = 20
+    FAST_FLAP_GRACE     = 5
+    FAST_FLAP_EXPIRY    = 12*60*60
+    fast_flapping_lock  = threading.Lock()
+    fast_flapping       = {}
+
     epoll = None
     listener_filenos = {}
     spawned_interface_filenos = {}
@@ -109,13 +116,17 @@ class BackboneInterface(Interface):
 
         super().__init__()
 
-        c            = Interface.get_config_obj(configuration)
-        name         = c["name"]
-        device       = c["device"] if "device" in c else None
-        port         = int(c["port"]) if "port" in c else None
-        bindip       = c["listen_ip"] if "listen_ip" in c else None
-        bindport     = int(c["listen_port"]) if "listen_port" in c else None
-        prefer_ipv6  = c.as_bool("prefer_ipv6") if "prefer_ipv6" in c else False
+        c              = Interface.get_config_obj(configuration)
+        name           = c["name"]
+        device         = c["device"] if "device" in c else None
+        port           = int(c["port"]) if "port" in c else None
+        bindip         = c["listen_ip"] if "listen_ip" in c else None
+        bindport       = int(c["listen_port"]) if "listen_port" in c else None
+        prefer_ipv6    = c.as_bool("prefer_ipv6") if "prefer_ipv6" in c else False
+        flap_block     = c.as_bool("block_fast_flapping") if "block_fast_flapping" in c else BackboneInterface.BLOCK_FAST_FLAPPING
+        flap_threshold = c.as_float("fast_flapping_threshold") if "fast_flapping_threshold" in c else BackboneInterface.FAST_FLAP_THRESHOLD
+        flap_grace     = c.as_int("fast_flapping_grace") if "fast_flapping_grace" in c else BackboneInterface.FAST_FLAP_GRACE
+        flap_expiry    = c.as_float("fast_flapping_block_time")*60 if "fast_flapping_block_time" in c else BackboneInterface.FAST_FLAP_EXPIRY
 
         if port != None: bindport = port
 
@@ -128,11 +139,13 @@ class BackboneInterface(Interface):
         self.mode = RNS.Interfaces.Interface.Interface.MODE_FULL
         self.spawned_interfaces = []
         self.supports_discovery = True
+        self.block_fast_flapping = flap_block
+        self.fast_flap_threshold = flap_threshold
+        self.fast_flap_grace = flap_grace
+        self.fast_flap_expiry = flap_expiry
 
-        if bindport == None:
-            raise SystemError(f"No TCP port configured for interface \"{name}\"")
-        else:
-            self.bind_port = bindport
+        if bindport == None: raise SystemError(f"No TCP port configured for interface \"{name}\"")
+        else:                self.bind_port = bindport
 
         bind_address = None
         if device != None:
@@ -282,7 +295,9 @@ class BackboneInterface(Interface):
             if fileno in BackboneInterface.spawned_interface_filenos:
                 try: BackboneInterface.epoll.modify(fileno, select.EPOLLOUT)
                 except Exception as e:
-                    RNS.log(f"Error occurred on {interface} while modifying socket EPOLL state: {e}", RNS.LOG_WARNING)
+                    if   str(e).endswith("No such file or directory"): pass
+                    elif str(e).endswith("Bad file descriptor"): pass
+                    else: RNS.log(f"Error occurred on {interface} while modifying socket EPOLL state: {e}", RNS.LOG_WARNING)
                     raise e
 
     @staticmethod
@@ -302,7 +317,7 @@ class BackboneInterface(Interface):
                                 if client_socket and fileno == client_socket.fileno() and (event & select.EPOLLIN):
                                     try: received_bytes = client_socket.recv(spawned_interface.HW_MTU)
                                     except Exception as e:
-                                        RNS.log(f"Error while reading from {spawned_interface}: {e}", RNS.LOG_DEBUG)
+                                        RNS.log(f"Error while reading from {spawned_interface}: {e}", RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
                                         received_bytes = b""
 
                                     if len(received_bytes): spawned_interface.receive(received_bytes)
@@ -325,7 +340,11 @@ class BackboneInterface(Interface):
                                     try: written = client_socket.send(spawned_interface.transmit_buffer)
                                     except Exception as e:
                                         written = 0
-                                        if not spawned_interface.detached: RNS.log(f"Error while writing to {spawned_interface}: {e}", RNS.LOG_DEBUG)
+                                        if not spawned_interface.detached:
+                                            if RNS.sl(RNS.LOG_DEBUG):
+                                                if   str(e).endswith("Connection timed out"): pass
+                                                elif str(e).endswith("Connection reset by peer"): pass
+                                                else: RNS.log(f"Error while writing to {spawned_interface}: {e}", RNS.LOG_DEBUG)
                                         BackboneInterface.deregister_fileno(fileno)
 
                                         try:
@@ -399,8 +418,22 @@ class BackboneInterface(Interface):
                     BackboneInterface.deregister_listeners()
     
     def incoming_connection(self, socket):
-        RNS.log("Accepting incoming connection", RNS.LOG_VERBOSE)
         try:
+            remote_ip = socket.getpeername()[0]
+            remote_port = str(socket.getpeername()[1])
+            if self.blocked_ip_count > 0:
+                with BackboneInterface.fast_flapping_lock:
+                    if remote_ip in BackboneInterface.fast_flapping:
+                        now = time.time()
+                        ffe = BackboneInterface.fast_flapping[remote_ip]
+                        started_flapping = ffe[0]
+                        last_flap        = ffe[1]
+                        flaps            = ffe[2]
+                        if flaps > self.fast_flap_grace:
+                            RNS.log(f"Ignoring incoming connection from fast-flapping IP {remote_ip}", RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
+                            return False
+
+            RNS.log("Accepting incoming connection", RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
             spawned_configuration = {"name": "Client on "+self.name, "target_host": None, "target_port": None}
             spawned_interface = BackboneClientInterface(self.owner, spawned_configuration, connected_socket=socket)
             spawned_interface.OUT = self.OUT
@@ -421,8 +454,8 @@ class BackboneInterface(Interface):
             spawned_interface.ic_pr_burst_freq = self.ic_pr_burst_freq
             
             spawned_interface.socket = socket
-            spawned_interface.target_ip = socket.getpeername()[0]
-            spawned_interface.target_port = str(socket.getpeername()[1])
+            spawned_interface.target_ip = remote_ip
+            spawned_interface.target_port = remote_port
             spawned_interface.parent_interface = self
             spawned_interface.bitrate = self.bitrate
             spawned_interface.optimise_mtu()
@@ -432,18 +465,12 @@ class BackboneInterface(Interface):
             spawned_interface.ifac_netkey = self.ifac_netkey
             if spawned_interface.ifac_netname != None or spawned_interface.ifac_netkey != None:
                 ifac_origin = b""
-                if spawned_interface.ifac_netname != None:
-                    ifac_origin += RNS.Identity.full_hash(spawned_interface.ifac_netname.encode("utf-8"))
-                if spawned_interface.ifac_netkey != None:
-                    ifac_origin += RNS.Identity.full_hash(spawned_interface.ifac_netkey.encode("utf-8"))
+                if spawned_interface.ifac_netname != None: ifac_origin += RNS.Identity.full_hash(spawned_interface.ifac_netname.encode("utf-8"))
+                if spawned_interface.ifac_netkey != None:  ifac_origin += RNS.Identity.full_hash(spawned_interface.ifac_netkey.encode("utf-8"))
 
                 ifac_origin_hash = RNS.Identity.full_hash(ifac_origin)
-                spawned_interface.ifac_key = RNS.Cryptography.hkdf(
-                    length=64,
-                    derive_from=ifac_origin_hash,
-                    salt=RNS.Reticulum.IFAC_SALT,
-                    context=None
-                )
+                spawned_interface.ifac_key = RNS.Cryptography.hkdf(length=64, derive_from=ifac_origin_hash,
+                                                                   salt=RNS.Reticulum.IFAC_SALT, context=None)
                 spawned_interface.ifac_identity = RNS.Identity.from_bytes(spawned_interface.ifac_key)
                 spawned_interface.ifac_signature = spawned_interface.ifac_identity.sign(RNS.Identity.full_hash(spawned_interface.ifac_key))
 
@@ -452,12 +479,13 @@ class BackboneInterface(Interface):
             spawned_interface.announce_rate_penalty = self.announce_rate_penalty
             spawned_interface.mode = self.mode
             spawned_interface.HW_MTU = self.HW_MTU
-            spawned_interface.online = True
-            RNS.log("Spawned new BackboneClient Interface: "+str(spawned_interface), RNS.LOG_VERBOSE)
+            RNS.log("Spawned new BackboneClient Interface: "+str(spawned_interface), RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
             RNS.Transport.add_interface(spawned_interface)
             while spawned_interface in self.spawned_interfaces: self.spawned_interfaces.remove(spawned_interface)
             self.spawned_interfaces.append(spawned_interface)
             BackboneInterface.add_client_socket(socket, spawned_interface)
+            spawned_interface.spawned_at = time.time()
+            spawned_interface.online = True
 
         except Exception as e:
             RNS.log(f"An error occurred while accepting incoming connection on {self}: {e}", RNS.LOG_ERROR)
@@ -491,15 +519,38 @@ class BackboneInterface(Interface):
                     if callable(listener_socket.shutdown):
                         try: listener_socket.shutdown(socket.SHUT_RDWR)
                         except Exception as e:
-                            if str(e).endswith("Transport endpoint is not connected"): pass
+                            if   str(e).endswith("Transport endpoint is not connected"): pass
+                            elif str(e).endswith("Bad file descriptor"): pass
                             else: RNS.log("Error while shutting down socket for "+str(self)+": "+str(e), RNS.LOG_ERROR)
 
-    def __str__(self):
-        if ":" in self.bind_ip:
-            ip_str = f"[{self.bind_ip}]"
+    @property
+    def blocked_ip_count(self):
+        if not self.block_fast_flapping: return 0
         else:
-            ip_str = f"{self.bind_ip}"
+            count = 0
+            expired = []
+            now = time.time()
+            with BackboneInterface.fast_flapping_lock:
+                for remote_ip in BackboneInterface.fast_flapping:
+                    ffe              = BackboneInterface.fast_flapping[remote_ip]
+                    started_flapping = ffe[0]
+                    last_flap        = ffe[1]
+                    flaps            = ffe[2]
+                    if now - last_flap > self.fast_flap_expiry: expired.append(remote_ip)
+                    elif flaps > self.fast_flap_grace: count += 1
 
+                for remote_ip in expired:
+                    if remote_ip in BackboneInterface.fast_flapping:
+                        try:
+                            BackboneInterface.fast_flapping.pop(remote_ip)
+                            RNS.log(f"Fast-flapping block expired for {remote_ip}", RNS.LOG_DEBUG)
+                        except Exception as e: RNS.log(f"Error while expiring fast-flapping block for {remote_ip}: {e}", RNS.LOG_ERROR)
+
+            return count
+
+    def __str__(self):
+        if ":" in self.bind_ip: ip_str = f"[{self.bind_ip}]"
+        else:                   ip_str = f"{self.bind_ip}"
         return "BackboneInterface["+self.name+"/"+ip_str+":"+str(self.bind_port)+"]"
 
 
@@ -710,6 +761,14 @@ class BackboneClientInterface(Interface):
                 RNS.log("The contained exception was: "+str(e), RNS.LOG_ERROR)
                 self.teardown()
 
+    def check_frame_len(self, frame_len):
+        if   frame_len <= RNS.Reticulum.HEADER_MINSIZE:        return False
+        elif frame_len >  self.HW_MTU + (self.ifac_size or 0): return False
+        else:                                                  return True
+
+    def invalid_frame(self, frame_len):
+        RNS.log(f"Invalid HDLC frame of {RNS.prettysize(frame_len)} received on {self}, dropping frame", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
+
     def receive(self, data_in):
         try:
             if len(data_in) > 0:
@@ -723,12 +782,18 @@ class BackboneClientInterface(Interface):
                             frame = self.frame_buffer[frame_start+1:frame_end]
                             frame = frame.replace(bytes([HDLC.ESC, HDLC.FLAG ^ HDLC.ESC_MASK]), bytes([HDLC.FLAG]))
                             frame = frame.replace(bytes([HDLC.ESC, HDLC.ESC  ^ HDLC.ESC_MASK]), bytes([HDLC.ESC]))
-                            if len(frame) > RNS.Reticulum.HEADER_MINSIZE:
-                                self.process_incoming(frame)
+                            frame_len = len(frame)
+                            if frame_len != 0:
+                                if self.check_frame_len(frame_len): self.process_incoming(frame)
+                                else:                               self.invalid_frame(len(frame))
+
                             self.frame_buffer = self.frame_buffer[frame_end:]
+
                         else:
+                            if len(self.frame_buffer) > self.HW_MTU*2: self.frame_buffer = b""
                             flags_remaining = False
                     else:
+                        self.frame_buffer = b""
                         flags_remaining = False
 
             else:
@@ -738,7 +803,7 @@ class BackboneClientInterface(Interface):
                     def job(): self.reconnect()
                     threading.Thread(target=job, daemon=True).start()
                 else:
-                    RNS.log("The socket for remote client "+str(self)+" was closed.", RNS.LOG_DEBUG)
+                    RNS.log("The socket for remote client "+str(self)+" was closed.", RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
                     self.teardown()
                 
         except Exception as e:
@@ -755,11 +820,29 @@ class BackboneClientInterface(Interface):
     def teardown(self):
         if self.initiator and not self.detached:
             RNS.log("The interface "+str(self)+" experienced an unrecoverable error and is being torn down. Restart Reticulum to attempt to open this interface again.", RNS.LOG_ERROR)
-            if RNS.Reticulum.panic_on_interface_error:
-                RNS.panic()
+            if RNS.Reticulum.panic_on_interface_error: RNS.panic()
 
         else:
-            RNS.log("The interface "+str(self)+" is being torn down.", RNS.LOG_VERBOSE)
+            RNS.log("The interface "+str(self)+" is being torn down.", RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
+            if self.parent_interface.block_fast_flapping and hasattr(self, "spawned_at"):
+                connected_time = time.time() - self.spawned_at
+                if connected_time < self.parent_interface.fast_flap_threshold:
+                    try:
+                        now = time.time()
+                        remote_id = f"{self.target_ip}"
+                        with BackboneInterface.fast_flapping_lock:
+                            if remote_id in BackboneInterface.fast_flapping: ffe = BackboneInterface.fast_flapping[remote_id]
+                            else:                                            ffe = [now, now, 0]
+                        ffe[1]  = now
+                        ffe[2] += 1
+                        with BackboneInterface.fast_flapping_lock: BackboneInterface.fast_flapping[remote_id] = ffe
+
+                        dt  = now-ffe[0]; fff = ffe[2]/dt if dt > 0 else None
+                        freq_str = f" at {RNS.prettyfrequency(fff)}" if fff else ""
+                        RNS.log(f"{self} is fast flapping{freq_str}, connection time was {RNS.prettytime(connected_time)}, {ffe[2]} fast flaps", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
+                        if ffe[2] > self.parent_interface.fast_flap_grace: RNS.log(f"Ignoring further connections from {remote_id} due to fast-flapping", RNS.LOG_WARNING)
+
+                    except Exception as e: RNS.log(f"Error while updating fast-flapping interface statistics: {e}", RNS.LOG_ERROR)
 
         self.online = False
         self.OUT = False

RNS/Interfaces/Interface.py

@@ -212,13 +212,15 @@ class Interface:
             elif self.bitrate > 62_500:          self.HW_MTU = 1024
             else:                                self.HW_MTU = None
 
-        RNS.log(f"{self} hardware MTU set to {self.HW_MTU}", RNS.LOG_DEBUG)
+        RNS.log(f"{self} hardware MTU set to {self.HW_MTU}", RNS.LOG_PATHING)
 
     def age(self):
         return time.time()-self.created
 
     def hold_announce(self, announce_packet):
-        if announce_packet.destination_hash in self.held_announces:
+        if announce_packet.hops >= RNS.Transport.PATHFINDER_M-1:
+            return
+        elif announce_packet.destination_hash in self.held_announces:
             self.held_announces[announce_packet.destination_hash] = announce_packet
         elif not len(self.held_announces) >= self.ic_max_held_announces:
             self.held_announces[announce_packet.destination_hash] = announce_packet

RNS/Interfaces/TCPInterface.py

@@ -333,6 +333,13 @@ class TCPClientInterface(Interface):
                 RNS.log("The contained exception was: "+str(e), RNS.LOG_ERROR)
                 self.teardown()
 
+    def check_frame_len(self, frame_len):
+        if   frame_len <= RNS.Reticulum.HEADER_MINSIZE:        return False
+        elif frame_len >  self.HW_MTU + (self.ifac_size or 0): return False
+        else:                                                  return True
+
+    def invalid_frame(self, frame_len):
+        RNS.log(f"Invalid HDLC frame of {RNS.prettysize(frame_len)} received on {self}, dropping frame", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
 
     def read_loop(self):
         try:
@@ -389,12 +396,18 @@ class TCPClientInterface(Interface):
                                     frame = frame_buffer[frame_start+1:frame_end]
                                     frame = frame.replace(bytes([HDLC.ESC, HDLC.FLAG ^ HDLC.ESC_MASK]), bytes([HDLC.FLAG]))
                                     frame = frame.replace(bytes([HDLC.ESC, HDLC.ESC  ^ HDLC.ESC_MASK]), bytes([HDLC.ESC]))
-                                    if len(frame) > RNS.Reticulum.HEADER_MINSIZE:
-                                        self.process_incoming(frame)
+                                    frame_len = len(frame)
+                                    if frame_len != 0:
+                                        if self.check_frame_len(frame_len): self.process_incoming(frame)
+                                        else:                               self.invalid_frame(len(frame))
+
                                     frame_buffer = frame_buffer[frame_end:]
+
                                 else:
+                                    if len(frame_buffer) > self.HW_MTU*2: frame_buffer = b""
                                     flags_remaining = False
                             else:
+                                frame_buffer = b""
                                 flags_remaining = False
 
                 else:

RNS/Interfaces/WeaveInterface.py

@@ -109,30 +109,30 @@ class WDCL():
         self.switch_id = self.switch_identity.sig_pub_bytes[-4:]
         self.switch_pub_bytes = self.switch_identity.sig_pub_bytes
 
-        self.rxb = 0
-        self.txb = 0
-        self.owner = owner
-        self.as_interface = as_interface
-        self.device = device
+        self.rxb               = 0
+        self.txb               = 0
+        self.owner             = owner
+        self.as_interface      = as_interface
+        self.device            = device
         self.device.connection = self
-        self.pyserial = serial
-        self.serial   = None
-        self.port     = port
-        self.speed    = 3000000
-        self.databits = 8
-        self.parity   = parity
-        self.stopbits = 1
-        self.timeout  = 100
-        self.online   = False
-        self.frame_buffer = b""
-        self.next_tx = 0
-        self.should_run = True
-        self.receiver = None
-        self.wdcl_connected = False
-        self.reconnecting = False
-        self.frame_queue = deque()
-        if not self.as_interface:
-            self.id = RNS.Identity.full_hash(port.hwid.encode("utf-8"))
+        self.pyserial          = serial
+        self.serial            = None
+        self.port              = port
+        self.speed             = 3000000
+        self.databits          = 8
+        self.parity            = parity
+        self.stopbits          = 1
+        self.timeout           = 100
+        self.online            = False
+        self.frame_buffer      = b""
+        self.next_tx           = 0
+        self.should_run        = True
+        self.receiver          = None
+        self.wdcl_connected    = False
+        self.reconnecting      = False
+        self.frame_queue       = deque()
+
+        if not self.as_interface: self.id = RNS.Identity.full_hash(port.hwid.encode("utf-8"))
 
         if self.as_interface:
             try:
@@ -168,19 +168,10 @@ class WDCL():
                 self.owner.wlog(f"Opening serial port {self.port.device}...")
                 target_port = self.port.device
 
-            self.serial = self.pyserial.Serial(
-                port = target_port,
-                baudrate = self.speed,
-                bytesize = self.databits,
-                parity = self.parity,
-                stopbits = self.stopbits,
-                xonxoff = False,
-                rtscts = False,
-                timeout = 0.250,
-                inter_byte_timeout = None,
-                write_timeout = None,
-                dsrdtr = False)
-
+            self.serial = self.pyserial.Serial(port = target_port, baudrate = self.speed,
+                                               bytesize = self.databits, parity = self.parity, stopbits = self.stopbits,
+                                               xonxoff = False, rtscts = False, timeout = 0.250, inter_byte_timeout = None,
+                                               write_timeout = None, dsrdtr = False)
         else:
             if self.port != None:
                 # Get device parameters
@@ -198,19 +189,9 @@ class WDCL():
                         from usbserial4a.cdcacmserial4a import CdcAcmSerial
                         proxy = CdcAcmSerial
 
-                    self.serial = proxy(
-                        self.port,
-                        baudrate = self.speed,
-                        bytesize = self.databits,
-                        parity = self.parity,
-                        stopbits = self.stopbits,
-                        xonxoff = False,
-                        rtscts = False,
-                        timeout = None,
-                        inter_byte_timeout = None,
-                        # write_timeout = wtimeout,
-                        dsrdtr = False,
-                    )
+                    self.serial = proxy(self.port, baudrate = self.speed, bytesize = self.databits,
+                                        parity = self.parity, stopbits = self.stopbits, xonxoff = False,
+                                        rtscts = False, timeout = None, inter_byte_timeout = None, dsrdtr = False)
 
                     if vid == 0x0403:
                         # Hardware parameters for FTDI devices @ 115200 baud
@@ -299,10 +280,9 @@ class WDCL():
                                 frame = frame.replace(bytes([HDLC.ESC, HDLC.ESC  ^ HDLC.ESC_MASK]), bytes([HDLC.ESC]))
                                 if len(frame) > WDCL.HEADER_MINSIZE: self.process_incoming(frame)
                                 self.frame_buffer = self.frame_buffer[frame_end:]
-                            else:
-                                flags_remaining = False
-                        else:
-                            flags_remaining = False
+
+                            else: flags_remaining = False
+                        else: flags_remaining = False
                     
         except Exception as e:
             self.online = False
@@ -359,6 +339,7 @@ class Evt():
     ET_MSG                       = 0x0000
     ET_SYSTEM_BOOT               = 0x0001
     ET_CORE_INIT                 = 0x0002
+    ET_BOARD_INIT                = 0x0003
     ET_DRV_UART_INIT             = 0x1000
     ET_DRV_USB_CDC_INIT          = 0x1010
     ET_DRV_USB_CDC_HOST_AVAIL    = 0x1011
@@ -426,77 +407,78 @@ class Evt():
     IF_TYPE_DMA                  = 0x10
 
     event_descriptions = {
-        ET_SYSTEM_BOOT: "System boot",
-        ET_CORE_INIT: "Core initialization",
-        ET_DRV_UART_INIT: "UART driver initialization",
-        ET_DRV_USB_CDC_INIT: "USB CDC driver initialization",
-        ET_DRV_USB_CDC_HOST_AVAIL: "USB CDC host became available",
-        ET_DRV_USB_CDC_HOST_SUSPEND: "USB CDC host suspend",
-        ET_DRV_USB_CDC_HOST_RESUME: "USB CDC host resume",
-        ET_DRV_USB_CDC_CONNECTED: "USB CDC host connection",
-        ET_DRV_USB_CDC_READ_ERR: "USB CDC read error",
-        ET_DRV_USB_CDC_OVERFLOW: "USB CDC overflow occurred",
-        ET_DRV_USB_CDC_DROPPED: "USB CDC dropped bytes",
-        ET_DRV_USB_CDC_TX_TIMEOUT: "USB CDC TX flush timeout",
-        ET_DRV_I2C_INIT: "I2C driver initialization",
-        ET_DRV_NVS_INIT: "NVS driver initialization",
-        ET_DRV_CRYPTO_INIT: "Cryptography driver initialization",
-        ET_DRV_W80211_INIT: "W802.11 driver initialization",
-        ET_DRV_W80211_CHANNEL: "W802.11 channel configuration",
-        ET_DRV_W80211_POWER: "W802.11 TX power configuration",
-        ET_DRV_DISPLAY_INIT: "Display driver initialization",
+        ET_SYSTEM_BOOT:               "System boot",
+        ET_CORE_INIT:                 "Core initialization",
+        ET_BOARD_INIT:                "Board hardware initialization",
+        ET_DRV_UART_INIT:             "UART driver initialization",
+        ET_DRV_USB_CDC_INIT:          "USB CDC driver initialization",
+        ET_DRV_USB_CDC_HOST_AVAIL:    "USB CDC host became available",
+        ET_DRV_USB_CDC_HOST_SUSPEND:  "USB CDC host suspend",
+        ET_DRV_USB_CDC_HOST_RESUME:   "USB CDC host resume",
+        ET_DRV_USB_CDC_CONNECTED:     "USB CDC host connection",
+        ET_DRV_USB_CDC_READ_ERR:      "USB CDC read error",
+        ET_DRV_USB_CDC_OVERFLOW:      "USB CDC overflow occurred",
+        ET_DRV_USB_CDC_DROPPED:       "USB CDC dropped bytes",
+        ET_DRV_USB_CDC_TX_TIMEOUT:    "USB CDC TX flush timeout",
+        ET_DRV_I2C_INIT:              "I2C driver initialization",
+        ET_DRV_NVS_INIT:              "NVS driver initialization",
+        ET_DRV_CRYPTO_INIT:           "Cryptography driver initialization",
+        ET_DRV_W80211_INIT:           "W802.11 driver initialization",
+        ET_DRV_W80211_CHANNEL:        "W802.11 channel configuration",
+        ET_DRV_W80211_POWER:          "W802.11 TX power configuration",
+        ET_DRV_DISPLAY_INIT:          "Display driver initialization",
         ET_DRV_DISPLAY_BUS_AVAILABLE: "Display bus availability",
         ET_DRV_DISPLAY_IO_CONFIGURED: "Display I/O configuration",
         ET_DRV_DISPLAY_PANEL_CREATED: "Display panel allocation",
-        ET_DRV_DISPLAY_PANEL_RESET: "Display panel reset",
-        ET_DRV_DISPLAY_PANEL_INIT: "Display panel initialization",
-        ET_DRV_DISPLAY_PANEL_ENABLE: "Display panel activation",
+        ET_DRV_DISPLAY_PANEL_RESET:   "Display panel reset",
+        ET_DRV_DISPLAY_PANEL_INIT:    "Display panel initialization",
+        ET_DRV_DISPLAY_PANEL_ENABLE:  "Display panel activation",
         ET_DRV_DISPLAY_REMOTE_ENABLE: "Remote display output activation",
-        ET_KRN_LOGGER_INIT: "Logging service initialization",
-        ET_KRN_LOGGER_OUTPUT: "Logging service output activation",
-        ET_KRN_UI_INIT: "User interface service initialization",
-        ET_PROTO_WDCL_INIT: "WDCL protocol initialization",
-        ET_PROTO_WDCL_RUNNING: "WDCL protocol activation",
-        ET_PROTO_WDCL_CONNECTION: "WDCL host connection",
-        ET_PROTO_WDCL_HOST_ENDPOINT: "Weave host endpoint",
-        ET_PROTO_WEAVE_INIT: "Weave protocol initialization",
-        ET_PROTO_WEAVE_RUNNING: "Weave protocol activation",
-        ET_PROTO_WEAVE_EP_ALIVE: "Weave endpoint alive",
-        ET_PROTO_WEAVE_EP_TIMEOUT: "Weave endpoint disappeared",
-        ET_SRVCTL_REMOTE_DISPLAY: "Remote display service control event",
-        ET_INTERFACE_REGISTERED: "Interface registration",
-        ET_SYSERR_MEM_EXHAUSTED: "System memory exhausted",
+        ET_KRN_LOGGER_INIT:           "Logging service initialization",
+        ET_KRN_LOGGER_OUTPUT:         "Logging service output activation",
+        ET_KRN_UI_INIT:               "User interface service initialization",
+        ET_PROTO_WDCL_INIT:           "WDCL protocol initialization",
+        ET_PROTO_WDCL_RUNNING:        "WDCL protocol activation",
+        ET_PROTO_WDCL_CONNECTION:     "WDCL host connection",
+        ET_PROTO_WDCL_HOST_ENDPOINT:  "Weave host endpoint",
+        ET_PROTO_WEAVE_INIT:          "Weave protocol initialization",
+        ET_PROTO_WEAVE_RUNNING:       "Weave protocol activation",
+        ET_PROTO_WEAVE_EP_ALIVE:      "Weave endpoint alive",
+        ET_PROTO_WEAVE_EP_TIMEOUT:    "Weave endpoint disappeared",
+        ET_SRVCTL_REMOTE_DISPLAY:     "Remote display service control event",
+        ET_INTERFACE_REGISTERED:      "Interface registration",
+        ET_SYSERR_MEM_EXHAUSTED:      "System memory exhausted",
     }
 
     interface_types = {
-        IF_TYPE_USB: "usb",
-        IF_TYPE_UART: "uart",
-        IF_TYPE_W80211: "mw",
-        IF_TYPE_BLE: "ble",
-        IF_TYPE_LORA: "lora",
+        IF_TYPE_USB:      "usb",
+        IF_TYPE_UART:     "uart",
+        IF_TYPE_W80211:   "mw",
+        IF_TYPE_BLE:      "ble",
+        IF_TYPE_LORA:     "lora",
         IF_TYPE_ETHERNET: "eth",
-        IF_TYPE_WIFI: "wifi",
-        IF_TYPE_TCP: "tcp",
-        IF_TYPE_UDP: "udp",
-        IF_TYPE_IR: "ir",
-        IF_TYPE_AFSK: "afsk",
-        IF_TYPE_GPIO: "gpio",
-        IF_TYPE_SPI: "spi",
-        IF_TYPE_I2C: "i2c",
-        IF_TYPE_CAN: "can",
-        IF_TYPE_DMA: "dma",
+        IF_TYPE_WIFI:     "wifi",
+        IF_TYPE_TCP:      "tcp",
+        IF_TYPE_UDP:      "udp",
+        IF_TYPE_IR:       "ir",
+        IF_TYPE_AFSK:     "afsk",
+        IF_TYPE_GPIO:     "gpio",
+        IF_TYPE_SPI:      "spi",
+        IF_TYPE_I2C:      "i2c",
+        IF_TYPE_CAN:      "can",
+        IF_TYPE_DMA:      "dma",
     }
 
     channel_descriptions = {
-        1: "Channel 1 (2412 MHz)",
-        2: "Channel 2 (2417 MHz)",
-        3: "Channel 3 (2422 MHz)",
-        4: "Channel 4 (2427 MHz)",
-        5: "Channel 5 (2432 MHz)",
-        6: "Channel 6 (2437 MHz)",
-        7: "Channel 7 (2442 MHz)",
-        8: "Channel 8 (2447 MHz)",
-        9: "Channel 9 (2452 MHz)",
+        1:  "Channel 1 (2412 MHz)",
+        2:  "Channel 2 (2417 MHz)",
+        3:  "Channel 3 (2422 MHz)",
+        4:  "Channel 4 (2427 MHz)",
+        5:  "Channel 5 (2432 MHz)",
+        6:  "Channel 6 (2437 MHz)",
+        7:  "Channel 7 (2442 MHz)",
+        8:  "Channel 8 (2447 MHz)",
+        9:  "Channel 9 (2452 MHz)",
         10: "Channel 10 (2457 MHz)",
         11: "Channel 11 (2462 MHz)",
         12: "Channel 12 (2467 MHz)",
@@ -529,23 +511,23 @@ class Evt():
     }
 
     task_descriptions = {
-        "taskLVGL": "Driver: UI Renderer",
-        "ui_service": "Service: User Interface",
-        "TinyUSB":  "Driver: USB",
-        "drv_w80211": "Driver: W802.11",
-        "system_stats": "System: Stats",
-        "core": "System: Core",
-        "protocol_wdcl": "Protocol: WDCL",
+        "taskLVGL":       "Driver: UI Renderer",
+        "ui_service":     "Service: User Interface",
+        "TinyUSB":        "Driver: USB",
+        "drv_w80211":     "Driver: W802.11",
+        "system_stats":   "System: Stats",
+        "core":           "System: Core",
+        "protocol_wdcl":  "Protocol: WDCL",
         "protocol_weave": "Protocol: Weave",
-        "tiT": "Protocol: TCP/IP",
-        "ipc0": "System: CPU 0 IPC",
-        "ipc1": "System: CPU 1 IPC",
-        "esp_timer": "Driver: Timers",
-        "Tmr Svc": "Service: Timers",
-        "kernel_logger": "Service: Logging",
+        "tiT":            "Protocol: TCP/IP",
+        "ipc0":           "System: CPU 0 IPC",
+        "ipc1":           "System: CPU 1 IPC",
+        "esp_timer":      "Driver: Timers",
+        "Tmr Svc":        "Service: Timers",
+        "kernel_logger":  "Service: Logging",
         "remote_display": "Service: Remote Display",
-        "wifi": "System: WiFi Hardware",
-        "sys_evt": "System: Kernel Events",
+        "wifi":           "System: WiFi Hardware",
+        "sys_evt":        "System: Kernel Events",
     }
 
     @staticmethod

RNS/Link.py

@@ -522,6 +522,7 @@ class Link:
                 self.rtt = max(measured_rtt, rtt)
                 self.status = Link.ACTIVE
                 self.activated_at = time.time()
+                self.expected_hops = packet.hops
 
                 if self.rtt != None and self.establishment_cost != None and self.rtt > 0 and self.establishment_cost > 0:
                     self.establishment_rate = self.establishment_cost/self.rtt
@@ -663,6 +664,7 @@ class Link:
         Closes the link and purges encryption keys. New keys will
         be used if a new link to the same destination is established.
         """
+        if self.status == Link.CLOSED: return
         if self.status != Link.PENDING and self.status != Link.CLOSED: self.__teardown_packet()
         self.status = Link.CLOSED
         if self.initiator: self.teardown_reason = Link.INITIATOR_CLOSED
@@ -806,7 +808,7 @@ class Link:
             request_data = unpacked_request[2]
 
             if path_hash in self.destination.request_handlers:
-                request_handler = self.destination.request_handlers[path_hash]
+                request_handler    = self.destination.request_handlers[path_hash]
                 path               = request_handler[0]
                 response_generator = request_handler[1]
                 allow              = request_handler[2]
@@ -967,10 +969,11 @@ class Link:
                                         self.teardown()
 
                                     else:
-                                        self.__remote_identity = identity
-                                        if self.callbacks.remote_identified != None:
-                                            try: self.callbacks.remote_identified(self, self.__remote_identity)
-                                            except Exception as e: RNS.log(f"Error while executing remote identified callback from {self}. The contained exception was: "+str(e), RNS.LOG_ERROR)
+                                        if self.__remote_identity == None:
+                                            self.__remote_identity = identity
+                                            if self.callbacks.remote_identified != None:
+                                                try: self.callbacks.remote_identified(self, self.__remote_identity)
+                                                except Exception as e: RNS.log(f"Error while executing remote identified callback from {self}. The contained exception was: "+str(e), RNS.LOG_ERROR)
                                 
                                     self.__update_phy_stats(packet, query_shared=True)
 
@@ -1011,36 +1014,39 @@ class Link:
                         packet.plaintext = self.decrypt(packet.data)
                         if packet.plaintext != None:
                             self.__update_phy_stats(packet, query_shared=True)
-
-                            if RNS.ResourceAdvertisement.is_request(packet):
-                                RNS.Resource.accept(packet, callback=self.request_resource_concluded)
-                            elif RNS.ResourceAdvertisement.is_response(packet):
-                                request_id = RNS.ResourceAdvertisement.read_request_id(packet)
-                                for pending_request in self.pending_requests:
-                                    if pending_request.request_id == request_id:
-                                        response_resource = RNS.Resource.accept(packet, callback=self.response_resource_concluded, progress_callback=pending_request.response_resource_progress, request_id = request_id)
-                                        if response_resource != None:
-                                            if pending_request.response_size == None:
-                                                pending_request.response_size = RNS.ResourceAdvertisement.read_size(packet)
-                                            if pending_request.response_transfer_size == None:
-                                                pending_request.response_transfer_size = 0
-                                            pending_request.response_transfer_size += RNS.ResourceAdvertisement.read_transfer_size(packet)
-                                            if pending_request.started_at == None:
-                                                pending_request.started_at = time.time()
-                                            pending_request.response_resource_progress(response_resource)
-
-                            elif self.resource_strategy == Link.ACCEPT_NONE: pass
-                            elif self.resource_strategy == Link.ACCEPT_APP:
-                                if self.callbacks.resource != None:
-                                    try:
-                                        resource_advertisement = RNS.ResourceAdvertisement.unpack(packet.plaintext)
-                                        resource_advertisement.link = self
-                                        if self.callbacks.resource(resource_advertisement): RNS.Resource.accept(packet, self.callbacks.resource_concluded)
-                                        else:                                               RNS.Resource.reject(packet)
-                                    except Exception as e:
-                                        RNS.log("Error while executing resource accept callback from "+str(self)+". The contained exception was: "+str(e), RNS.LOG_ERROR)
-                            elif self.resource_strategy == Link.ACCEPT_ALL:
-                                RNS.Resource.accept(packet, self.callbacks.resource_concluded)
+                            try:
+                                if RNS.ResourceAdvertisement.is_request(packet):
+                                    if self.destination.request_handlers:
+                                        RNS.Resource.accept(packet, callback=self.request_resource_concluded)
+                                elif RNS.ResourceAdvertisement.is_response(packet):
+                                    request_id = RNS.ResourceAdvertisement.read_request_id(packet)
+                                    for pending_request in self.pending_requests:
+                                        if pending_request.request_id == request_id:
+                                            response_resource = RNS.Resource.accept(packet, callback=self.response_resource_concluded, progress_callback=pending_request.response_resource_progress, request_id = request_id)
+                                            if response_resource != None:
+                                                if pending_request.response_size == None:
+                                                    pending_request.response_size = RNS.ResourceAdvertisement.read_size(packet)
+                                                if pending_request.response_transfer_size == None:
+                                                    pending_request.response_transfer_size = 0
+                                                pending_request.response_transfer_size += RNS.ResourceAdvertisement.read_transfer_size(packet)
+                                                if pending_request.started_at == None:
+                                                    pending_request.started_at = time.time()
+                                                pending_request.response_resource_progress(response_resource)
+                                elif self.resource_strategy == Link.ACCEPT_NONE: pass
+                                elif self.resource_strategy == Link.ACCEPT_APP:
+                                    if self.callbacks.resource != None:
+                                        try:
+                                            resource_advertisement = RNS.ResourceAdvertisement.unpack(packet.plaintext)
+                                            resource_advertisement.link = self
+                                            if self.callbacks.resource(resource_advertisement): RNS.Resource.accept(packet, self.callbacks.resource_concluded)
+                                            else:                                               RNS.Resource.reject(packet)
+                                        except Exception as e:
+                                            RNS.log("Error while executing resource accept callback from "+str(self)+". The contained exception was: "+str(e), RNS.LOG_ERROR)
+                                elif self.resource_strategy == Link.ACCEPT_ALL:
+                                    RNS.Resource.accept(packet, self.callbacks.resource_concluded)
+                            except Exception as e:
+                                RNS.log(f"Invalid resource advertisement on {self}: {e}", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
+                                self.teardown()
 
                     elif packet.context == RNS.Packet.RESOURCE_REQ:
                         plaintext = self.decrypt(packet.data)

RNS/Packet.py

@@ -244,6 +244,9 @@ class Packet:
             self.flags = self.raw[0]
             self.hops  = self.raw[1]
 
+            if self.hops >= RNS.Transport.PATHFINDER_M:
+                raise ValueError(f"Invalid hop count {self.hops}")
+
             self.header_type      = (self.flags & 0b01000000) >> 6
             self.context_flag     = (self.flags & 0b00100000) >> 5
             self.transport_type   = (self.flags & 0b00010000) >> 4
@@ -268,7 +271,7 @@ class Packet:
             return True
 
         except Exception as e:
-            RNS.log("Received malformed packet, dropping it. The contained exception was: "+str(e), RNS.LOG_EXTREME) if RNS.sl(RNS.LOG_EXTREME) else None
+            RNS.log(f"Received malformed packet, dropping it. The contained exception was: {e}", RNS.LOG_EXTREME) if RNS.sl(RNS.LOG_EXTREME) else None
             return False
 
     def send(self):
@@ -278,6 +281,7 @@ class Packet:
         :returns: A :ref:`RNS.PacketReceipt<api-packetreceipt>` instance if *create_receipt* was set to *True* when the packet was instantiated, if not returns *None*. If the packet could not be sent *False* is returned.
         """
         if not self.sent:
+            if not self.packed: self.pack()
             if self.destination.type == RNS.Destination.LINK:
                 if self.destination.status == RNS.Link.CLOSED:
                     RNS.log("Attempt to transmit over a closed link, dropping packet", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
@@ -288,9 +292,7 @@ class Packet:
                 else:
                     self.destination.last_outbound = time.time()
                     self.destination.tx += 1
-                    self.destination.txbytes += len(self.data)
-
-            if not self.packed: self.pack()
+                    self.destination.txbytes += len(self.ciphertext)
 
             if RNS.Transport.outbound(self): return self.receipt
             else:

RNS/Resource.py

@@ -149,7 +149,7 @@ class Resource:
     COMPLETE        = 0x06
     FAILED          = 0x07
     CORRUPT         = 0x08
-    REJECTED        = 0x00
+    REJECTED        = 0x09
 
     @staticmethod
     def reject(advertisement_packet):
@@ -239,7 +239,7 @@ class Resource:
                 return None
 
         except Exception as e:
-            RNS.log("Could not decode resource advertisement, dropping resource", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
+            RNS.log(f"Could not decode resource advertisement, dropping resource: {e}", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
             return None
 
     # Create a resource for transmission to a remote destination
@@ -314,30 +314,26 @@ class Resource:
                 self.input_file = data
 
         elif isinstance(data, bytes):
-            data_size = len(data)
+            data_size       = len(data)
             self.total_size = data_size + self.metadata_size
             
-            resource_data = data
+            resource_data       = data
             self.total_segments = 1
             self.segment_index  = 1
             self.split          = False
 
-        elif data == None:
-            pass
+        elif data == None: pass
 
-        else:
-            raise TypeError("Invalid data instance type passed to resource initialisation")
+        else: raise TypeError("Invalid data instance type passed to resource initialisation")
 
         if resource_data:
             if self.has_metadata: data = self.metadata + resource_data
             else:                 data = resource_data
 
         self.status = Resource.NONE
-        self.link = link
-        if self.link.mtu:
-            self.sdu = self.link.mtu - RNS.Reticulum.HEADER_MAXSIZE - RNS.Reticulum.IFAC_MIN_SIZE
-        else:
-            self.sdu = link.mdu or Resource.SDU
+        self.link   = link
+        if self.link.mtu: self.sdu = self.link.mtu - RNS.Reticulum.HEADER_MAXSIZE - RNS.Reticulum.IFAC_MIN_SIZE
+        else:             self.sdu = link.mdu or Resource.SDU
         self.max_retries = Resource.MAX_RETRIES
         self.max_adv_retries = Resource.MAX_ADV_RETRIES
         self.retries_left = self.max_retries
@@ -482,12 +478,12 @@ class Resource:
 
     def hashmap_update_packet(self, plaintext):
         if not self.status == Resource.FAILED:
-            self.last_activity = time.time()
-            self.retries_left = self.max_retries
-
-            update = umsgpack.unpackb(plaintext[RNS.Identity.HASHLENGTH//8:])
-            self.hashmap_update(update[0], update[1])
+            if self.waiting_for_hmu:
+                self.last_activity = time.time()
+                self.retries_left = self.max_retries
 
+                update = umsgpack.unpackb(plaintext[RNS.Identity.HASHLENGTH//8:])
+                self.hashmap_update(update[0], update[1])
 
     def hashmap_update(self, segment, hashmap):
         if not self.status == Resource.FAILED:
@@ -495,12 +491,16 @@ class Resource:
             seg_len = ResourceAdvertisement.HASHMAP_MAX_LEN
             hashes = len(hashmap)//Resource.MAPHASH_LEN
             for i in range(0,hashes):
-                if self.hashmap[i+segment*seg_len] == None:
-                    self.hashmap_height += 1
+                if self.hashmap[i+segment*seg_len] == None: self.hashmap_height += 1
                 self.hashmap[i+segment*seg_len] = hashmap[i*Resource.MAPHASH_LEN:(i+1)*Resource.MAPHASH_LEN]
 
-            self.waiting_for_hmu = False
-            self.request_next()
+            if hashes < 1:
+                RNS.log("Invalid HMU received, cancelling transfer", RNS.LOG_ERROR)
+                self.cancel()
+
+            else:
+                self.waiting_for_hmu = False
+                self.request_next()
 
     def get_map_hash(self, data):
         return RNS.Identity.full_hash(data+self.random_hash)[:Resource.MAPHASH_LEN]
@@ -517,6 +517,14 @@ class Resource:
             prepare_thread = threading.Thread(target=self.__prepare_next_segment, daemon=True)
             prepare_thread.start()
 
+    def ensure_link(self):
+        if not self.link or self.link.status != RNS.Link.ACTIVE:
+            RNS.log(f"Invalid link state for {self}, aborting transfer", RNS.LOG_VERBOSE)
+            try: self.cancel()
+            except Exception as e: RNS.log(f"Error while cancelling resource on link-state abort: {e}", RNS.LOG_ERROR)
+            return False
+        else: return True
+
     def __advertise_job(self):
         self.advertisement_packet = RNS.Packet(self.link, ResourceAdvertisement(self).pack(), context=RNS.Packet.RESOURCE_ADV)
         while not self.link.ready_for_new_resource():
@@ -524,6 +532,7 @@ class Resource:
             sleep(0.25)
 
         try:
+            if not self.ensure_link(): return
             self.advertisement_packet.send()
             self.last_activity = time.time()
             self.started_transferring = self.last_activity
@@ -541,18 +550,13 @@ class Resource:
         self.watchdog_job()
 
     def update_eifr(self):
-        if self.rtt == None:
-            rtt = self.link.rtt
-        else:
-            rtt = self.rtt
+        if self.rtt == None: rtt = self.link.rtt
+        else:                rtt = self.rtt
 
-        if self.req_data_rtt_rate != 0:
-            expected_inflight_rate = self.req_data_rtt_rate*8
+        if self.req_data_rtt_rate != 0:    expected_inflight_rate = self.req_data_rtt_rate*8
         else:
-            if self.previous_eifr != None:
-                expected_inflight_rate = self.previous_eifr
-            else:
-                expected_inflight_rate = self.link.establishment_cost*8 / rtt
+            if self.previous_eifr != None: expected_inflight_rate = self.previous_eifr
+            else:                          expected_inflight_rate = self.link.establishment_cost*8 / rtt
 
         self.eifr = expected_inflight_rate
         if self.link: self.link.expected_rate = self.eifr
@@ -566,8 +570,7 @@ class Resource:
         this_job_id = self.__watchdog_job_id
 
         while self.status < Resource.ASSEMBLING and this_job_id == self.__watchdog_job_id:
-            while self.watchdog_lock:
-                sleep(0.025)
+            while self.watchdog_lock: sleep(0.025)
 
             sleep_time = None
             if self.status == Resource.ADVERTISED:
@@ -581,6 +584,7 @@ class Resource:
                         try:
                             RNS.log("No part requests received, retrying resource advertisement...", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
                             self.retries_left -= 1
+                            if not self.ensure_link(): return
                             self.advertisement_packet = RNS.Packet(self.link, ResourceAdvertisement(self).pack(), context=RNS.Packet.RESOURCE_ADV)
                             self.advertisement_packet.send()
                             self.last_activity = time.time()
@@ -657,13 +661,13 @@ class Resource:
                         self.last_part_sent = time.time()
                         sleep_time = 0.001
 
-            elif self.status == Resource.REJECTED:
+            elif self.status >= Resource.ASSEMBLING:
                 sleep_time = 0.001
 
             if sleep_time == 0:
                 RNS.log("Warning! Link watchdog sleep time of 0!", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
             if sleep_time == None or sleep_time < 0:
-                RNS.log("Timing error, cancelling resource transfer.", RNS.LOG_ERROR)
+                RNS.log(f"Timing error ({sleep_time}/{self.status}), cancelling resource transfer.", RNS.LOG_ERROR)
                 self.cancel()
             
             if sleep_time != None:
@@ -754,6 +758,7 @@ class Resource:
             try:
                 proof = RNS.Identity.full_hash(self.data+self.hash)
                 proof_data = self.hash+proof
+                if not self.ensure_link(): return
                 proof_packet = RNS.Packet(self.link, proof_data, packet_type=RNS.Packet.PROOF, context=RNS.Packet.RESOURCE_PRF)
                 proof_packet.send()
                 RNS.Transport.cache(proof_packet, force_cache=True)
@@ -776,8 +781,8 @@ class Resource:
                                      advertise = False,
                                      auto_compress = self.auto_compress_option,
                                      sent_metadata_size = self.metadata_size)
-        if self.__progress_callback:
-            self.next_segment.progress_callback(self.__progress_callback)
+        
+        if self.__progress_callback: self.next_segment.progress_callback(self.__progress_callback)
 
     def validate_proof(self, proof_data):
         if not self.status == Resource.FAILED:
@@ -966,6 +971,7 @@ class Resource:
                 request_packet = RNS.Packet(self.link, request_data, context = RNS.Packet.RESOURCE_REQ)
 
                 try:
+                    if not self.ensure_link(): return
                     request_packet.send()
                     self.last_activity = time.time()
                     self.req_sent = self.last_activity
@@ -1010,11 +1016,11 @@ class Resource:
 
             for part in requested_parts:
                 try:
+                    if not self.ensure_link(): return
                     if not part.sent:
                         part.send()
                         self.sent_parts += 1
-                    else:
-                        part.resend()
+                    else: part.resend()
 
                     self.last_activity = time.time()
                     self.last_part_sent = self.last_activity
@@ -1032,8 +1038,7 @@ class Resource:
                 search_end   = self.receiver_min_consecutive_height+ResourceAdvertisement.COLLISION_GUARD_SIZE
                 for part in self.parts[search_start:search_end]:
                     part_index += 1
-                    if part.map_hash == last_map_hash:
-                        break
+                    if part.map_hash == last_map_hash: break
 
                 self.receiver_min_consecutive_height = max(part_index-1-Resource.WINDOW_MAX, 0)
 
@@ -1041,10 +1046,8 @@ class Resource:
                     RNS.log("Resource sequencing error, cancelling transfer!", RNS.LOG_ERROR)
                     self.cancel()
                     return
-                else:
-                    segment = part_index // ResourceAdvertisement.HASHMAP_MAX_LEN
+                else: segment = part_index // ResourceAdvertisement.HASHMAP_MAX_LEN
 
-                
                 hashmap_start = segment*ResourceAdvertisement.HASHMAP_MAX_LEN
                 hashmap_end   = min((segment+1)*ResourceAdvertisement.HASHMAP_MAX_LEN, len(self.parts))
 
@@ -1052,10 +1055,16 @@ class Resource:
                 for i in range(hashmap_start,hashmap_end):
                     hashmap += self.hashmap[i*Resource.MAPHASH_LEN:(i+1)*Resource.MAPHASH_LEN]
 
+                if not hashmap:
+                    RNS.log("Resource HMU error, cancelling transfer!", RNS.LOG_ERROR)
+                    self.cancel()
+                    return
+
                 hmu = self.hash+umsgpack.packb([segment, hashmap])
                 hmu_packet = RNS.Packet(self.link, hmu, context = RNS.Packet.RESOURCE_HMU)
 
                 try:
+                    if not self.ensure_link(): return
                     hmu_packet.send()
                     self.last_activity = time.time()
                 except Exception as e:
@@ -1090,10 +1099,14 @@ class Resource:
                     try:
                         cancel_packet = RNS.Packet(self.link, self.hash, context=RNS.Packet.RESOURCE_ICL)
                         cancel_packet.send()
-                    except Exception as e:
-                        RNS.log("Could not send resource cancel packet, the contained exception was: "+str(e), RNS.LOG_ERROR)
+                    except Exception as e: RNS.log("Could not send resource cancel packet, the contained exception was: "+str(e), RNS.LOG_ERROR)
                 self.link.cancel_outgoing_resource(self)
             else:
+                if self.link.status == RNS.Link.ACTIVE:
+                    try:
+                        cancel_packet = RNS.Packet(self.link, self.hash, context=RNS.Packet.RESOURCE_RCL)
+                        cancel_packet.send()
+                    except Exception as e: RNS.log("Could not send resource cancel packet, the contained exception was: "+str(e), RNS.LOG_ERROR)
                 self.link.cancel_incoming_resource(self)
             
             if self.callback != None:
@@ -1241,40 +1254,30 @@ class ResourceAdvertisement:
     @staticmethod
     def is_request(advertisement_packet):
         adv = ResourceAdvertisement.unpack(advertisement_packet.plaintext)
-        if adv.q != None and adv.u:
-            return True
-        else:
-            return False
-
+        if adv.q != None and adv.u: return True
+        else:                       return False
 
     @staticmethod
     def is_response(advertisement_packet):
         adv = ResourceAdvertisement.unpack(advertisement_packet.plaintext)
-
-        if adv.q != None and adv.p:
-            return True
-        else:
-            return False
-
+        if adv.q != None and adv.p: return True
+        else:                       return False
 
     @staticmethod
     def read_request_id(advertisement_packet):
         adv = ResourceAdvertisement.unpack(advertisement_packet.plaintext)
         return adv.q
 
-
     @staticmethod
     def read_transfer_size(advertisement_packet):
         adv = ResourceAdvertisement.unpack(advertisement_packet.plaintext)
         return adv.t
 
-
     @staticmethod
     def read_size(advertisement_packet):
         adv = ResourceAdvertisement.unpack(advertisement_packet.plaintext)
         return adv.d
 
-
     def __init__(self, resource=None, request_id=None, is_response=False):
         self.link = None
         if resource != None:
@@ -1306,29 +1309,14 @@ class ResourceAdvertisement:
             # Flags
             self.f = 0x00 | self.x << 5 | self.p << 4 | self.u << 3 | self.s << 2 | self.c << 1 | self.e
 
-    def get_transfer_size(self):
-        return self.t
-
-    def get_data_size(self):
-        return self.d
-
-    def get_parts(self):
-        return self.n
-
-    def get_segments(self):
-        return self.l
-
-    def get_hash(self):
-        return self.h
-
-    def is_compressed(self):
-        return self.c
-
-    def has_metadata(self):
-        return self.x
-
-    def get_link(self):
-        return self.link
+    def get_transfer_size(self): return self.t
+    def get_data_size(self):     return self.d
+    def get_parts(self):         return self.n
+    def get_segments(self):      return self.l
+    def get_hash(self):          return self.h
+    def is_compressed(self):     return self.c
+    def has_metadata(self):      return self.x
+    def get_link(self):          return self.link
 
     def pack(self, segment=0):
         hashmap_start = segment*ResourceAdvertisement.HASHMAP_MAX_LEN
@@ -1338,23 +1326,20 @@ class ResourceAdvertisement:
         for i in range(hashmap_start,hashmap_end):
             hashmap += self.m[i*Resource.MAPHASH_LEN:(i+1)*Resource.MAPHASH_LEN]
 
-        dictionary = {
-            "t": self.t,    # Transfer size
-            "d": self.d,    # Data size
-            "n": self.n,    # Number of parts
-            "h": self.h,    # Resource hash
-            "r": self.r,    # Resource random hash
-            "o": self.o,    # Original hash
-            "i": self.i,    # Segment index
-            "l": self.l,    # Total segments
-            "q": self.q,    # Request ID
-            "f": self.f,    # Resource flags
-            "m": hashmap
-        }
+        dictionary = { "t": self.t,    # Transfer size
+                       "d": self.d,    # Data size
+                       "n": self.n,    # Number of parts
+                       "h": self.h,    # Resource hash
+                       "r": self.r,    # Resource random hash
+                       "o": self.o,    # Original hash
+                       "i": self.i,    # Segment index
+                       "l": self.l,    # Total segments
+                       "q": self.q,    # Request ID
+                       "f": self.f,    # Resource flags
+                       "m": hashmap }
 
         return umsgpack.packb(dictionary)
 
-
     @staticmethod
     def unpack(data):
         dictionary = umsgpack.unpackb(data)
@@ -1378,4 +1363,6 @@ class ResourceAdvertisement:
         adv.p = True if ((adv.f >> 4) & 0x01) == 0x01 else False
         adv.x = True if ((adv.f >> 5) & 0x01) == 0x01 else False
 
+        if adv.t > Resource.MAX_EFFICIENT_SIZE*3: raise ValueError("Invalid transfer size")
+
         return adv

RNS/Reticulum.py

@@ -829,6 +829,7 @@ class Reticulum:
         latitude = None
         longitude = None
         height = None
+        discovery_location = None
         discovery_frequency = None
         discovery_bandwidth = None
         discovery_modulation = None
@@ -846,6 +847,7 @@ class Reticulum:
                 if "discovery_encrypt" in c: discovery_encrypt = c.as_bool("discovery_encrypt")
                 if "reachable_on" in c: reachable_on = c["reachable_on"]
                 if "publish_ifac" in c: publish_ifac = c.as_bool("publish_ifac")
+                if "location_cmd" in c: discovery_location = c["location_cmd"]
                 if "latitude" in c: latitude = c.as_float("latitude")
                 if "longitude" in c: longitude = c.as_float("longitude")
                 if "height" in c: height = c.as_float("height")
@@ -853,14 +855,14 @@ class Reticulum:
                 if "discovery_bandwidth" in c: discovery_bandwidth = c.as_int("discovery_bandwidth")
                 if "discovery_modulation" in c: discovery_modulation = c.as_int("discovery_modulation")
 
-                if not interface_mode in [Interface.Interface.MODE_GATEWAY, Interface.Interface.MODE_ACCESS_POINT]:
+                if not interface_mode in [Interface.Interface.MODE_GATEWAY, Interface.Interface.MODE_ACCESS_POINT, Interface.Interface.MODE_INTERNAL]:
                     if not ignore_config_warnings:
                         if c["type"] in ["RNodeInterface", "RNodeMultiInterface"]:
                             interface_mode = Interface.Interface.MODE_ACCESS_POINT
-                            RNS.log(f"Discovery enabled on interface {name} without gateway or AP mode. Auto-configured to AP mode.", RNS.LOG_NOTICE)
+                            RNS.log(f"Discovery enabled on interface {name} without gateway, internal or AP mode. Auto-configured to AP mode.", RNS.LOG_NOTICE)
                         else:
                             interface_mode = Interface.Interface.MODE_GATEWAY
-                            RNS.log(f"Discovery enabled on interface {name} without gateway or AP mode. Auto-configured to gateway mode.", RNS.LOG_NOTICE)
+                            RNS.log(f"Discovery enabled on interface {name} without gateway, internal or AP mode. Auto-configured to gateway mode.", RNS.LOG_NOTICE)
                 
         try:
             def interface_post_init(interface):
@@ -884,6 +886,7 @@ class Reticulum:
                     interface.discovery_name                  = discovery_name
                     interface.discovery_encrypt               = discovery_encrypt
                     interface.discovery_stamp_value           = discovery_stamp_value
+                    interface.discovery_location              = discovery_location
                     interface.discovery_latitude              = latitude
                     interface.discovery_longitude             = longitude
                     interface.discovery_height                = height
@@ -1412,6 +1415,9 @@ class Reticulum:
                     if interface.announce_queue != None: ifstats["announce_queue"] = len(interface.announce_queue)
                     else:                                ifstats["announce_queue"] = None
 
+                if hasattr(interface, "blocked_ip_count"):
+                    ifstats["blocked_ips"] = interface.blocked_ip_count
+
                 ifstats["name"]                        = str(interface)
                 ifstats["short_name"]                  = str(interface.name)
                 ifstats["hash"]                        = interface.get_hash()
@@ -1892,7 +1898,7 @@ instance_name = default
 
 
 [logging]
-# Valid log levels are 0 through 7:
+# Valid log levels are 0 through 8:
 #   0: Log only critical information
 #   1: Log errors and lower log levels
 #   2: Log warnings and lower log levels
@@ -1900,7 +1906,8 @@ instance_name = default
 #   4: Log info and lower (this is the default)
 #   5: Verbose logging
 #   6: Debug logging
-#   7: Extreme logging
+#   7: Path logging
+#   8: Extreme logging
 
 loglevel = 4
 

RNS/Transport.py

@@ -217,7 +217,6 @@ class Transport:
     @staticmethod
     def start(reticulum_instance):
         Transport.owner = reticulum_instance
-        Transport.PR_LOGLEVEL = RNS.LOG_EXTREME
 
         if Transport.identity == None:
             transport_identity_path = RNS.Reticulum.storagepath+"/transport_identity"
@@ -303,7 +302,6 @@ class Transport:
         if RNS.Reticulum.transport_enabled():
             path_table_path = RNS.Reticulum.storagepath+"/destination_table"
             tunnel_table_path = RNS.Reticulum.storagepath+"/tunnels"
-            Transport.PR_LOGLEVEL = RNS.LOG_DEBUG
 
             if os.path.isfile(path_table_path) and not Transport.owner.is_connected_to_shared_instance:
                 serialised_destinations = []
@@ -331,7 +329,7 @@ class Transport:
                                 del path_identity
 
                             if announce_packet != None and receiving_interface != None and blackholed == False:
-                                announce_packet.unpack()
+                                if not announce_packet.unpack(): continue
                                 # We increase the hops, since reading a packet
                                 # from cache is equivalent to receiving it again
                                 # over an interface. It is cached with it's non-
@@ -339,15 +337,15 @@ class Transport:
                                 announce_packet.hops += 1
                                 with Transport.path_table_lock:
                                     Transport.path_table[destination_hash] = [timestamp, received_from, hops, expires, random_blobs, receiving_interface, announce_packet.packet_hash]
-                                RNS.log("Loaded path table entry for "+RNS.prettyhexrep(destination_hash)+" from storage", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
+                                RNS.log("Loaded path table entry for "+RNS.prettyhexrep(destination_hash)+" from storage", RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
                             else:
-                                RNS.log("Could not reconstruct path table entry from storage for "+RNS.prettyhexrep(destination_hash), RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
+                                RNS.log("Could not reconstruct path table entry from storage for "+RNS.prettyhexrep(destination_hash), RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
                                 if announce_packet == None:
-                                    RNS.log("The announce packet could not be loaded from cache", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
+                                    RNS.log("The announce packet could not be loaded from cache", RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
                                 if receiving_interface == None:
-                                    RNS.log("The interface is no longer available", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
+                                    RNS.log("The interface is no longer available", RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
                                 if blackholed:
-                                    RNS.log("The associated identity is blackholed", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
+                                    RNS.log("The associated identity is blackholed", RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
 
                     if len(Transport.path_table) == 1: specifier = "entry"
                     else:                              specifier = "entries"
@@ -384,7 +382,7 @@ class Transport:
                             announce_packet = Transport.get_cached_packet(serialised_entry[7], packet_type="announce")
 
                             if announce_packet != None:
-                                announce_packet.unpack()
+                                if not announce_packet.unpack(): continue
                                 # We increase the hops, since reading a packet
                                 # from cache is equivalent to receiving it again
                                 # over an interface. It is cached with it's non-
@@ -508,8 +506,7 @@ class Transport:
                 Transport.speed_rx     = rxs
                 Transport.speed_tx     = txs
             
-            except Exception as e:
-                RNS.log(f"An error occurred while counting interface traffic: {e}", RNS.LOG_ERROR)
+            except Exception as e: RNS.log(f"An error occurred while counting interface traffic: {e}", RNS.LOG_ERROR)
 
     @staticmethod
     def jobloop():
@@ -549,7 +546,7 @@ class Transport:
                                                 last_path_request = Transport.path_requests[link.destination.hash]
 
                                         if time.time() - last_path_request > Transport.PATH_REQUEST_MI:
-                                            RNS.log("Trying to rediscover path for "+RNS.prettyhexrep(link.destination.hash)+" since an attempted link was never established", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
+                                            RNS.log("Trying to rediscover path for "+RNS.prettyhexrep(link.destination.hash)+" since an attempted link was never established", RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
                                             if not link.destination.hash in path_requests:
                                                 blocked_if = None
                                                 path_requests[link.destination.hash] = blocked_if
@@ -610,7 +607,7 @@ class Transport:
                                     announce_data = packet.data
                                     announce_identity = RNS.Identity.recall(packet.destination_hash, _no_use=True)
                                     if not announce_identity:
-                                        RNS.log("Completed announce processing for "+RNS.prettyhexrep(destination_hash)+", the path was cleaned while waiting for announce rebroadcast", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
+                                        RNS.log("Completed announce processing for "+RNS.prettyhexrep(destination_hash)+", the path was cleaned while waiting for announce rebroadcast", RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
                                         completed_announces.append(destination_hash)
 
                                     else:
@@ -629,12 +626,12 @@ class Transport:
                                                                 context_flag = packet.context_flag)
 
                                         new_packet.hops = announce_entry[4]
-                                        if block_rebroadcasts: RNS.log("Rebroadcasting announce as path response for "+RNS.prettyhexrep(announce_destination.hash)+" with hop count "+str(new_packet.hops), RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
-                                        else: RNS.log("Rebroadcasting announce for "+RNS.prettyhexrep(announce_destination.hash)+" with hop count "+str(new_packet.hops), RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
+                                        if block_rebroadcasts: RNS.log("Rebroadcasting announce as path response for "+RNS.prettyhexrep(announce_destination.hash)+" with hop count "+str(new_packet.hops), RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
+                                        else: RNS.log("Rebroadcasting announce for "+RNS.prettyhexrep(announce_destination.hash)+" with hop count "+str(new_packet.hops), RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
                                         
                                         outgoing.append(new_packet)
 
-                                        # This handles an edge case where a peer sends a past
+                                        # This handles an edge case where a peer sends a path
                                         # 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
@@ -643,7 +640,7 @@ class Transport:
                                         if destination_hash in Transport.held_announces:
                                             held_entry = Transport.held_announces.pop(destination_hash)
                                             Transport.announce_table[destination_hash] = held_entry
-                                            RNS.log("Reinserting held announce into table", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
+                                            RNS.log("Reinserting held announce into table", RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
 
                         for destination_hash in completed_announces:
                             if destination_hash in Transport.announce_table: Transport.announce_table.pop(destination_hash)
@@ -719,14 +716,14 @@ class Transport:
                                     # If the path has been invalidated between the time of
                                     # making the link request and now, try to rediscover it
                                     if not Transport.has_path(link_entry[IDX_LT_DSTHASH]):
-                                        RNS.log("Trying to rediscover path for "+RNS.prettyhexrep(link_entry[IDX_LT_DSTHASH])+" since an attempted link was never established, and path is now missing", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
+                                        RNS.log("Trying to rediscover path for "+RNS.prettyhexrep(link_entry[IDX_LT_DSTHASH])+" since an attempted link was never established, and path is now missing", RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
                                         path_request_conditions = True
 
                                     # If this link request was originated from a local client
                                     # attempt to rediscover a path to the destination, if this
                                     # has not already happened recently.
                                     elif not path_request_throttle and lr_taken_hops == 0:
-                                        RNS.log("Trying to rediscover path for "+RNS.prettyhexrep(link_entry[IDX_LT_DSTHASH])+" since an attempted local client link was never established", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
+                                        RNS.log("Trying to rediscover path for "+RNS.prettyhexrep(link_entry[IDX_LT_DSTHASH])+" since an attempted local client link was never established", RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
                                         path_request_conditions = True
 
                                     # If the link destination was previously only 1 hop
@@ -735,7 +732,7 @@ class Transport:
                                     # In that case, try to discover a new path, and mark
                                     # the old one as unresponsive.
                                     elif not path_request_throttle and Transport.hops_to(link_entry[IDX_LT_DSTHASH]) == 1:
-                                        RNS.log("Trying to rediscover path for "+RNS.prettyhexrep(link_entry[IDX_LT_DSTHASH])+" since an attempted link was never established, and destination was previously local to an interface on this instance", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
+                                        RNS.log("Trying to rediscover path for "+RNS.prettyhexrep(link_entry[IDX_LT_DSTHASH])+" since an attempted link was never established, and destination was previously local to an interface on this instance", RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
                                         path_request_conditions = True
                                         blocked_if = link_entry[IDX_LT_RCVD_IF]
 
@@ -757,7 +754,7 @@ class Transport:
                                     # changed. In that case, we try to discover a new path,
                                     # and mark the old one as potentially unresponsive.
                                     elif not path_request_throttle and lr_taken_hops == 1:
-                                        RNS.log("Trying to rediscover path for "+RNS.prettyhexrep(link_entry[IDX_LT_DSTHASH])+" since an attempted link was never established, and link initiator is local to an interface on this instance", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
+                                        RNS.log("Trying to rediscover path for "+RNS.prettyhexrep(link_entry[IDX_LT_DSTHASH])+" since an attempted link was never established, and link initiator is local to an interface on this instance", RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
                                         path_request_conditions = True
                                         blocked_if = link_entry[IDX_LT_RCVD_IF]
 
@@ -793,11 +790,11 @@ class Transport:
                             if time.time() > destination_expiry:
                                 stale_paths.append(destination_hash)
                                 should_collect = True
-                                RNS.log("Path to "+RNS.prettyhexrep(destination_hash)+" timed out and was removed", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
+                                RNS.log("Path to "+RNS.prettyhexrep(destination_hash)+" timed out and was removed", RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
                             elif not attached_interface in Transport.interfaces:
                                 stale_paths.append(destination_hash)
                                 should_collect = True
-                                RNS.log("Path to "+RNS.prettyhexrep(destination_hash)+" was removed since the attached interface no longer exists", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
+                                RNS.log("Path to "+RNS.prettyhexrep(destination_hash)+" was removed since the attached interface no longer exists", RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
 
                     # Cull the pending path requests table
                     stale_path_requests = []
@@ -1206,7 +1203,7 @@ class Transport:
 
                     if packet.packet_type == RNS.Packet.ANNOUNCE:
                         if packet.attached_interface == None:
-                            ac_loglevel = RNS.LOG_EXTREME
+                            ac_loglevel = RNS.LOG_PATHING
                             from_interface = Transport.next_hop_interface(packet.destination_hash)
                             local_destination = None
                             with Transport.destinations_map_lock:
@@ -1442,10 +1439,8 @@ class Transport:
                         ifac = raw[2:2+interface.ifac_size]
 
                         # Generate mask
-                        mask = RNS.Cryptography.hkdf(length=len(raw),
-                                                     derive_from=ifac,
-                                                     salt=interface.ifac_key,
-                                                     context=None)
+                        mask = RNS.Cryptography.hkdf(length=len(raw), derive_from=ifac,
+                                                     salt=interface.ifac_key, context=None)
                         # Unmask payload
                         i = 0; unmasked_raw = b""
                         for byte in raw:
@@ -1547,10 +1542,12 @@ class Transport:
             # through a shared Reticulum instance
             from_local_client         = (packet.receiving_interface in Transport.local_client_interfaces)
             for_local_client          = (packet.packet_type != RNS.Packet.ANNOUNCE) and (packet.destination_hash in Transport.path_table and Transport.path_table[packet.destination_hash][IDX_PT_HOPS] == 0)
-            for_local_client_link     = (packet.packet_type != RNS.Packet.ANNOUNCE) and (packet.destination_hash in Transport.link_table and Transport.link_table[packet.destination_hash][IDX_LT_RCVD_IF] in Transport.local_client_interfaces)
-            for_local_client_link    |= (packet.packet_type != RNS.Packet.ANNOUNCE) and (packet.destination_hash in Transport.link_table and Transport.link_table[packet.destination_hash][IDX_LT_NH_IF] in Transport.local_client_interfaces)
+            local_client_nh           = (packet.packet_type != RNS.Packet.ANNOUNCE) and (packet.destination_hash in Transport.link_table and Transport.link_table[packet.destination_hash][IDX_LT_NH_IF] in Transport.local_client_interfaces)
+            local_client_rh           = (packet.packet_type != RNS.Packet.ANNOUNCE) and (packet.destination_hash in Transport.link_table and Transport.link_table[packet.destination_hash][IDX_LT_RCVD_IF] in Transport.local_client_interfaces)
             proof_for_local_client    = (packet.destination_hash in Transport.reverse_table) and (Transport.reverse_table[packet.destination_hash][IDX_RT_RCVD_IF] in Transport.local_client_interfaces)
-            to_local_client           = for_local_client or for_local_client_link or proof_for_local_client
+            to_local_client           = for_local_client or proof_for_local_client
+            instance_local_link       = local_client_nh and local_client_rh
+            for_local_client_link     = local_client_nh or local_client_rh
             link_request_handled      = False
 
             # Plain broadcast packets from local clients are sent
@@ -1644,11 +1641,11 @@ class Transport:
                                 nh_mtu         = outbound_interface.HW_MTU
                                 if path_mtu:
                                     if outbound_interface.HW_MTU == None:
-                                        RNS.log(f"No next-hop HW MTU, disabling link MTU upgrade", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
+                                        RNS.log(f"No next-hop HW MTU, disabling link MTU upgrade", RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
                                         path_mtu = None
                                         new_raw  = new_raw[:-RNS.Link.LINK_MTU_SIZE]
                                     elif not outbound_interface.AUTOCONFIGURE_MTU and not outbound_interface.FIXED_MTU:
-                                        RNS.log(f"Outbound interface doesn't support MTU autoconfiguration, disabling link MTU upgrade", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
+                                        RNS.log(f"Outbound interface doesn't support MTU autoconfiguration, disabling link MTU upgrade", RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
                                         path_mtu = None
                                         new_raw  = new_raw[:-RNS.Link.LINK_MTU_SIZE]
                                     else:
@@ -1656,7 +1653,7 @@ class Transport:
                                             try:
                                                 path_mtu = min(nh_mtu, ph_mtu)
                                                 clamped_mtu = RNS.Link.signalling_bytes(path_mtu, mode)
-                                                RNS.log(f"Clamping link MTU to {RNS.prettysize(path_mtu)}", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
+                                                RNS.log(f"Clamping link MTU to {RNS.prettysize(path_mtu)}", RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
                                                 new_raw  = new_raw[:-RNS.Link.LINK_MTU_SIZE]+clamped_mtu
                                             except Exception as e:
                                                 RNS.log(f"Dropping link request packet. The contained exception was: {e}", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
@@ -1728,7 +1725,7 @@ class Transport:
                             Transport.add_packet_hash(packet.packet_hash)
 
                             new_raw = packet.raw[0:1]
-                            new_raw += struct.pack("!B", packet.hops if not from_local_client or Transport.local_hops_delta == 0 else Transport.local_hops_delta)
+                            new_raw += struct.pack("!B", packet.hops if not from_local_client or instance_local_link or Transport.local_hops_delta == 0 else Transport.local_hops_delta)
                             new_raw += packet.raw[2:]
                             Transport.transmit(outbound_interface, new_raw)
                             Transport.link_table[packet.destination_hash][IDX_LT_TIMESTAMP] = time.time()
@@ -1790,8 +1787,7 @@ class Transport:
                                     with Transport.announce_table_lock:
                                         if packet.destination_hash in Transport.announce_table: Transport.announce_table.pop(packet.destination_hash)
 
-                    else:
-                        received_from = packet.destination_hash
+                    else: received_from = packet.destination_hash
 
                     # Check if this announce should be inserted into
                     # announce and destination tables
@@ -1850,7 +1846,7 @@ class Transport:
                                         if not random_blob in random_blobs:
                                             # TODO: Check that this ^ approach actually
                                             # works under all circumstances
-                                            RNS.log("Replacing destination table entry for "+str(RNS.prettyhexrep(packet.destination_hash))+" with new announce due to expired path", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
+                                            RNS.log("Replacing path table entry for "+str(RNS.prettyhexrep(packet.destination_hash))+" with new announce due to expired path", RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
                                             Transport.mark_path_unknown_state(packet.destination_hash)
                                             should_add = True
                                         else:
@@ -1861,7 +1857,7 @@ class Transport:
                                         # this announce before, update the path table.
                                         if (announce_emitted > path_announce_emitted):
                                             if not random_blob in random_blobs:
-                                                RNS.log("Replacing destination table entry for "+str(RNS.prettyhexrep(packet.destination_hash))+" with new announce, since it was more recently emitted", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
+                                                RNS.log("Replacing path table entry for "+str(RNS.prettyhexrep(packet.destination_hash))+" with new announce, since it was more recently emitted", RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
                                                 Transport.mark_path_unknown_state(packet.destination_hash)
                                                 should_add = True
                                             else:
@@ -1873,7 +1869,7 @@ class Transport:
                                         # allow updating the path table to this one.
                                         elif announce_emitted == path_announce_emitted:
                                             if Transport.path_is_unresponsive(packet.destination_hash):
-                                                RNS.log("Replacing destination table entry for "+str(RNS.prettyhexrep(packet.destination_hash))+" with new announce, since previously tried path was unresponsive", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
+                                                RNS.log("Replacing path table entry for "+str(RNS.prettyhexrep(packet.destination_hash))+" with new announce, since previously tried path was unresponsive", RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
                                                 should_add = True
                                             else:
                                                 should_add = False
@@ -1939,7 +1935,7 @@ class Transport:
                                 if (RNS.Reticulum.transport_enabled() or is_from_local_client) and packet.context != RNS.Packet.PATH_RESPONSE:
                                     # Insert announce into announce table for retransmission
 
-                                    if rate_blocked: RNS.log("Blocking rebroadcast of announce from "+RNS.prettyhexrep(packet.destination_hash)+" due to excessive announce rate", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
+                                    if rate_blocked: RNS.log("Blocking rebroadcast of announce from "+RNS.prettyhexrep(packet.destination_hash)+" due to excessive announce rate", RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
                                     else:
                                         if is_from_local_client:
                                             # If the announce is from a local client,
@@ -1997,17 +1993,10 @@ class Transport:
                                     if is_from_local_client and packet.context == RNS.Packet.PATH_RESPONSE:
                                         for local_interface in Transport.local_client_interfaces:
                                             if packet.receiving_interface != local_interface:
-                                                new_announce = RNS.Packet(
-                                                    announce_destination,
-                                                    announce_data,
-                                                    RNS.Packet.ANNOUNCE, # <-- This one?
-                                                    context = announce_context,
-                                                    header_type = RNS.Packet.HEADER_2,
-                                                    transport_type = Transport.TRANSPORT,
-                                                    transport_id = Transport.identity.hash,
-                                                    attached_interface = local_interface,
-                                                    context_flag = packet.context_flag,
-                                                )
+                                                new_announce = RNS.Packet(announce_destination, announce_data, RNS.Packet.ANNOUNCE, # <-- This one?
+                                                                          context = announce_context, header_type = RNS.Packet.HEADER_2,
+                                                                          transport_type = Transport.TRANSPORT, transport_id = Transport.identity.hash,
+                                                                          attached_interface = local_interface, context_flag = packet.context_flag)
                                                 
                                                 new_announce.hops = packet.hops
                                                 new_announce.send()
@@ -2015,17 +2004,10 @@ class Transport:
                                     else:
                                         for local_interface in Transport.local_client_interfaces:
                                             if packet.receiving_interface != local_interface:
-                                                new_announce = RNS.Packet(
-                                                    announce_destination,
-                                                    announce_data,
-                                                    RNS.Packet.ANNOUNCE,
-                                                    context = announce_context,
-                                                    header_type = RNS.Packet.HEADER_2,
-                                                    transport_type = Transport.TRANSPORT,
-                                                    transport_id = Transport.identity.hash,
-                                                    attached_interface = local_interface,
-                                                    context_flag = packet.context_flag,
-                                                )
+                                                new_announce = RNS.Packet(announce_destination, announce_data, RNS.Packet.ANNOUNCE,
+                                                                          context = announce_context, header_type = RNS.Packet.HEADER_2,
+                                                                          transport_type = Transport.TRANSPORT, transport_id = Transport.identity.hash,
+                                                                          attached_interface = local_interface, context_flag = packet.context_flag)
 
                                                 new_announce.hops = packet.hops
                                                 new_announce.send()
@@ -2039,7 +2021,7 @@ class Transport:
 
                                     interface_str = " on "+str(attached_interface)
 
-                                    RNS.log("Got matching announce, answering waiting discovery path request for "+RNS.prettyhexrep(packet.destination_hash)+interface_str, Transport.PR_LOGLEVEL) if RNS.sl(Transport.PR_LOGLEVEL) else None
+                                    RNS.log("Got matching announce, answering waiting discovery path request for "+RNS.prettyhexrep(packet.destination_hash)+interface_str, RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
                                     announce_identity = RNS.Identity.recall(packet.destination_hash, _no_use=False)
                                     announce_destination = RNS.Destination(announce_identity, RNS.Destination.OUT, RNS.Destination.SINGLE, "unknown", "unknown");
                                     announce_destination.hash = packet.destination_hash
@@ -2047,17 +2029,10 @@ class Transport:
                                     announce_context = RNS.Packet.NONE
                                     announce_data = packet.data
 
-                                    new_announce = RNS.Packet(
-                                        announce_destination,
-                                        announce_data,
-                                        RNS.Packet.ANNOUNCE,
-                                        context = RNS.Packet.PATH_RESPONSE,
-                                        header_type = RNS.Packet.HEADER_2,
-                                        transport_type = Transport.TRANSPORT,
-                                        transport_id = Transport.identity.hash,
-                                        attached_interface = attached_interface,
-                                        context_flag = packet.context_flag,
-                                    )
+                                    new_announce = RNS.Packet(announce_destination, announce_data, RNS.Packet.ANNOUNCE,
+                                                              context = RNS.Packet.PATH_RESPONSE, header_type = RNS.Packet.HEADER_2,
+                                                              transport_type = Transport.TRANSPORT, transport_id = Transport.identity.hash,
+                                                              attached_interface = attached_interface, context_flag = packet.context_flag)
 
                                     new_announce.hops = packet.hops
                                     new_announce.send()
@@ -2066,7 +2041,7 @@ class Transport:
                                 path_table_entry = [now, received_from, announce_hops, expires, random_blobs, packet.receiving_interface, packet.packet_hash]
                                 with Transport.path_table_lock: Transport.path_table[packet.destination_hash] = path_table_entry
                                 Transport.mark_path_unknown_state(packet.destination_hash)
-                                RNS.log("Destination "+RNS.prettyhexrep(packet.destination_hash)+" is now "+str(announce_hops)+" hops away via "+RNS.prettyhexrep(received_from)+" on "+str(packet.receiving_interface), RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
+                                RNS.log("Destination "+RNS.prettyhexrep(packet.destination_hash)+" is now "+str(announce_hops)+" hops away via "+RNS.prettyhexrep(received_from)+" on "+str(packet.receiving_interface), RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
                                 if packet.destination_hash in Transport.path_requests:
                                     RNS.Reticulum.get_instance()._used_destination_data(packet.destination_hash)
 
@@ -2074,15 +2049,14 @@ class Transport:
                                 # announce to the tunnels table
                                 if hasattr(packet.receiving_interface, "tunnel_id") and packet.receiving_interface.tunnel_id != None:
                                     with Transport.tunnels_lock:
-                                        if not packet.receiving_interface.tunnel_id in Transport.tunnels:
-                                            RNS.log(f"Tunnel ID for {packet.receiving_interface} was not found in tunnel table", RNS.LOG_WARNING)
+                                        if not packet.receiving_interface.tunnel_id in Transport.tunnels: RNS.log(f"Tunnel ID for {packet.receiving_interface} was not found in tunnel table", RNS.LOG_WARNING)
                                         else:
                                             tunnel_entry = Transport.tunnels[packet.receiving_interface.tunnel_id]
                                             paths = tunnel_entry[IDX_TT_PATHS]
                                             paths[packet.destination_hash] = [now, received_from, announce_hops, expires, random_blobs, None, packet.packet_hash]
                                             expires = time.time() + Transport.TUNNEL_TIMEOUT
                                             tunnel_entry[IDX_TT_EXPIRES] = expires
-                                            RNS.log("Path to "+RNS.prettyhexrep(packet.destination_hash)+" associated with tunnel "+RNS.prettyhexrep(packet.receiving_interface.tunnel_id), RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
+                                            RNS.log("Path to "+RNS.prettyhexrep(packet.destination_hash)+" associated with tunnel "+RNS.prettyhexrep(packet.receiving_interface.tunnel_id), RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
 
                                 # Call externally registered callbacks from apps
                                 # wanting to know when an announce arrives
@@ -2093,10 +2067,10 @@ class Transport:
                                             # the handlers aspect filter
                                             execute_callback = False
                                             announce_identity = RNS.Identity.recall(packet.destination_hash, _no_use=True)
-                                            if handler.aspect_filter == None:
-                                                # If the handlers aspect filter is set to
-                                                # None, we execute the callback in all cases
-                                                execute_callback = True
+
+                                            # If the handlers aspect filter is set to
+                                            # None, we execute the callback in all cases
+                                            if handler.aspect_filter == None: execute_callback = True
                                             else:
                                                 handler_expected_hash = RNS.Destination.hash_from_name_and_identity(handler.aspect_filter, announce_identity)
                                                 if packet.destination_hash == handler_expected_hash: execute_callback = True
@@ -2184,7 +2158,7 @@ class Transport:
                                     if packet.context == RNS.Packet.CACHE_REQUEST:
                                         cached_packet = Transport.get_cached_packet(packet.data)
                                         if cached_packet != None:
-                                            cached_packet.unpack()
+                                            if not cached_packet.unpack(): return
                                             RNS.Packet(destination=link, data=cached_packet.data,
                                                        packet_type=cached_packet.packet_type, context=cached_packet.context).send()
                                     
@@ -2211,13 +2185,11 @@ class Transport:
                         packet.destination = destination
                         if destination.receive(packet):
                             if destination.proof_strategy == RNS.Destination.PROVE_ALL: packet.prove()
-
                             elif destination.proof_strategy == RNS.Destination.PROVE_APP:
                                 if destination.callbacks.proof_requested:
                                     try:
                                         if destination.callbacks.proof_requested(packet): packet.prove()
-                                    except Exception as e:
-                                        RNS.log("Error while executing proof request callback. The contained exception was: "+str(e), RNS.LOG_ERROR)
+                                    except Exception as e: RNS.log("Error while executing proof request callback. The contained exception was: "+str(e), RNS.LOG_ERROR)
 
             # Handling for proofs and link-request proofs
             elif packet.packet_type == RNS.Packet.PROOF:
@@ -2244,19 +2216,17 @@ class Transport:
                                         if peer_identity.validate(signature, signed_data):
                                             RNS.log("Link request proof validated for transport via "+str(link_entry[IDX_LT_RCVD_IF]), RNS.LOG_EXTREME) if RNS.sl(RNS.LOG_EXTREME) else None
                                             new_raw = packet.raw[0:1]
-                                            new_raw += struct.pack("!B", packet.hops if not from_local_client or Transport.local_hops_delta == 0 else Transport.local_hops_delta)
+                                            new_raw += struct.pack("!B", packet.hops if not from_local_client or instance_local_link or Transport.local_hops_delta == 0 else Transport.local_hops_delta)
                                             new_raw += packet.raw[2:]
                                             Transport.link_table[packet.destination_hash][IDX_LT_VALIDATED] = True
                                             Transport.transmit(link_entry[IDX_LT_RCVD_IF], new_raw)
                                             if not Transport.owner.is_connected_to_shared_instance:
                                                 RNS.Identity._used_destination_data(link_entry[IDX_LT_DSTHASH])
 
-                                        else:
-                                            RNS.log("Invalid link request proof in transport for link "+RNS.prettyhexrep(packet.destination_hash)+", dropping proof.", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
-
+                                        else: RNS.log("Invalid link request proof in transport for link "+RNS.prettyhexrep(packet.destination_hash)+", dropping proof.", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
                                 except Exception as e: RNS.log("Could not transport link request proof. The contained exception was: "+str(e), RNS.LOG_DEBUG) if RNS.sl(LOG_DEBUG) else None
                             else: RNS.log("Link request proof received on wrong interface, not transporting it.", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
-                        else: RNS.log("Received link request proof with hop mismatch, not transporting it", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
+                        else: RNS.log(f"Received link request proof with hop mismatch ({packet.hops}/{link_entry[IDX_LT_NH_IF]}), not transporting it", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
                     
                     else:
                         # Check if we can deliver it to a local
@@ -2311,7 +2281,7 @@ class Transport:
                         if packet.receiving_interface == reverse_entry[IDX_RT_OUTB_IF]:
                             RNS.log("Proof received on correct interface, transporting it via "+str(reverse_entry[IDX_RT_RCVD_IF]), RNS.LOG_EXTREME) if RNS.sl(RNS.LOG_EXTREME) else None
                             new_raw = packet.raw[0:1]
-                            new_raw += struct.pack("!B", packet.hops if not from_local_client or Transport.local_hops_delta == 0 else Transport.local_hops_delta)
+                            new_raw += struct.pack("!B", packet.hops if not from_local_client or proof_for_local_client or Transport.local_hops_delta == 0 else Transport.local_hops_delta)
                             new_raw += packet.raw[2:]
                             Transport.transmit(reverse_entry[IDX_RT_RCVD_IF], new_raw)
                         else:
@@ -2392,14 +2362,14 @@ class Transport:
     def handle_tunnel(tunnel_id, interface):
         expires = time.time() + Transport.TUNNEL_TIMEOUT
         if not tunnel_id in Transport.tunnels:
-            RNS.log("Tunnel endpoint "+RNS.prettyhexrep(tunnel_id)+" established.", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
+            RNS.log("Tunnel endpoint "+RNS.prettyhexrep(tunnel_id)+" established.", RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
             paths = {}
             with Transport.tunnels_lock:
                 tunnel_entry = [tunnel_id, interface, paths, expires]
                 interface.tunnel_id = tunnel_id
                 Transport.tunnels[tunnel_id] = tunnel_entry
         else:
-            RNS.log("Tunnel endpoint "+RNS.prettyhexrep(tunnel_id)+" reappeared. Restoring paths...", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
+            RNS.log("Tunnel endpoint "+RNS.prettyhexrep(tunnel_id)+" reappeared. Restoring paths...", RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
             tunnel_entry = Transport.tunnels[tunnel_id]
             tunnel_entry[IDX_TT_IF] = interface
             tunnel_entry[IDX_TT_EXPIRES] = expires
@@ -2428,21 +2398,21 @@ class Transport:
                                 current_path_timebase    = Transport.timebase_from_random_blobs(current_random_blobs)
                                 tunnel_announce_timebase = Transport.timebase_from_random_blobs(random_blobs)
                                 if tunnel_announce_timebase >= current_path_timebase: should_add = True
-                                else: RNS.log("Did not restore path to "+RNS.prettyhexrep(destination_hash)+" because existing path is more recent", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
-                            else: RNS.log("Did not restore path to "+RNS.prettyhexrep(destination_hash)+" because a newer path with fewer hops exist", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
+                                else: RNS.log("Did not restore path to "+RNS.prettyhexrep(destination_hash)+" because existing path is more recent", RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
+                            else: RNS.log("Did not restore path to "+RNS.prettyhexrep(destination_hash)+" because a newer path with fewer hops exist", RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
                         
                         else:
                             if time.time() < expires: should_add = True
-                            else: RNS.log("Did not restore path to "+RNS.prettyhexrep(destination_hash)+" because it has expired", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
+                            else: RNS.log("Did not restore path to "+RNS.prettyhexrep(destination_hash)+" because it has expired", RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
 
                     if should_add:
                         with Transport.path_table_lock: Transport.path_table[destination_hash] = new_entry
-                        RNS.log("Restored path to "+RNS.prettyhexrep(destination_hash)+" is now "+str(announce_hops)+" hops away via "+RNS.prettyhexrep(received_from)+" on "+str(receiving_interface), RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
+                        RNS.log("Restored path to "+RNS.prettyhexrep(destination_hash)+" is now "+str(announce_hops)+" hops away via "+RNS.prettyhexrep(received_from)+" on "+str(receiving_interface), RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
                     
                     else: deprecated_paths.append(destination_hash)
 
             for deprecated_path in deprecated_paths:
-                RNS.log("Removing path to "+RNS.prettyhexrep(deprecated_path)+" from tunnel "+RNS.prettyhexrep(tunnel_id), RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
+                RNS.log("Removing path to "+RNS.prettyhexrep(deprecated_path)+" from tunnel "+RNS.prettyhexrep(tunnel_id), RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
                 with Transport.tunnels_lock: paths.pop(deprecated_path)
 
     @staticmethod
@@ -2959,7 +2929,7 @@ class Transport:
                                                    tag=tag_bytes)
 
                         else: RNS.log("Ignoring duplicate path request for "+RNS.prettyhexrep(destination_hash)+" with tag "+RNS.prettyhexrep(unique_tag), RNS.LOG_EXTREME) if RNS.sl(RNS.LOG_EXTREME) else None
-                else: RNS.log("Ignoring tagless path request for "+RNS.prettyhexrep(destination_hash), Transport.PR_LOGLEVEL) if RNS.sl(Transport.PR_LOGLEVEL) else None
+                else: RNS.log("Ignoring tagless path request for "+RNS.prettyhexrep(destination_hash), RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
         except Exception as e: RNS.log(f"Error while handling path request. The contained exception was: {e}", RNS.LOG_ERROR)
 
     @staticmethod
@@ -2973,9 +2943,9 @@ class Transport:
                 if attached_interface.recursive_prs: should_search_for_unknown = True
                 elif attached_interface.mode in RNS.Interfaces.Interface.Interface.DISCOVER_PATHS_FOR: should_search_for_unknown = True
 
-        if RNS.sl(RNS.LOG_DEBUG):
+        if RNS.sl(RNS.LOG_PATHING):
             interface_str = f" on {attached_interface}"
-            RNS.log(f"Path request for {RNS.prettyhexrep(destination_hash)}{interface_str}", Transport.PR_LOGLEVEL)
+            RNS.log(f"Path request for {RNS.prettyhexrep(destination_hash)}{interface_str}", RNS.LOG_PATHING)
 
         destination_exists_on_local_client = False
         if len(Transport.local_client_interfaces) > 0:
@@ -2994,7 +2964,7 @@ class Transport:
 
         if local_destination != None:
             local_destination.announce(path_response=True, tag=tag, attached_interface=attached_interface)
-            RNS.log("Answering path request for "+RNS.prettyhexrep(destination_hash)+interface_str+", destination is local to this system", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
+            RNS.log("Answering path request for "+RNS.prettyhexrep(destination_hash)+interface_str+", destination is local to this system", RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
 
         elif (RNS.Reticulum.transport_enabled() or is_from_local_client) and (destination_hash in Transport.path_table):
             packet = Transport.get_cached_packet(Transport.path_table[destination_hash][IDX_PT_PACKET], packet_type="announce")
@@ -3005,10 +2975,10 @@ class Transport:
                 RNS.log(f"Could not retrieve announce packet from cache while answering path request for {RNS.prettyhexrep(destination_hash)}, ignoring path request", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
 
             elif attached_interface.mode == RNS.Interfaces.Interface.Interface.MODE_ROAMING and attached_interface == received_from:
-                RNS.log("Not answering path request on roaming-mode interface, since next hop is on same roaming-mode interface", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
+                RNS.log("Not answering path request on roaming-mode interface, since next hop is on same roaming-mode interface", RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
 
             else:
-                packet.unpack()
+                if not packet.unpack(): return
                 packet.hops = Transport.path_table[destination_hash][IDX_PT_HOPS]
 
                 if requestor_transport_id != None and next_hop == requestor_transport_id:
@@ -3018,9 +2988,9 @@ class Transport:
                     # 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) if RNS.sl(RNS.LOG_DEBUG) else None
+                    RNS.log("Not answering path request for "+RNS.prettyhexrep(destination_hash)+interface_str+", since next hop is the requestor", RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
                 else:
-                    RNS.log("Answering path request for "+RNS.prettyhexrep(destination_hash)+interface_str+", path is known", Transport.PR_LOGLEVEL) if RNS.sl(Transport.PR_LOGLEVEL) else None
+                    RNS.log("Answering path request for "+RNS.prettyhexrep(destination_hash)+interface_str+", path is known", RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
 
                     now = time.time()
                     retries = Transport.PATHFINDER_R
@@ -3062,7 +3032,7 @@ class Transport:
         elif is_from_local_client:
             # 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", Transport.PR_LOGLEVEL) if RNS.sl(Transport.PR_LOGLEVEL) else None
+            RNS.log("Forwarding path request from local client for "+RNS.prettyhexrep(destination_hash)+interface_str+" to all other interfaces", RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
             request_tag = RNS.Identity.get_random_hash()
             for interface in Transport.interfaces:
                 if not interface == attached_interface:
@@ -3070,20 +3040,20 @@ class Transport:
 
         elif should_search_for_unknown:
             if destination_hash in Transport.discovery_path_requests:
-                RNS.log("There is already a waiting path request for "+RNS.prettyhexrep(destination_hash)+" on behalf of path request"+interface_str, RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
+                RNS.log("There is already a waiting path request for "+RNS.prettyhexrep(destination_hash)+" on behalf of path request"+interface_str, RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
             else:
                 # Abort recursive path request if receiving
                 # interface has PR burst active, or should
                 # otherwise ingress limit path requests.
                 if should_ingress_limit:
-                    if RNS.sl(RNS.LOG_DEBUG):
+                    if RNS.sl(RNS.LOG_PATHING):
                         interface_str = f" for {attached_interface}" if attached_interface else ""
-                        RNS.log(f"Not sending recursive path request{interface_str} due to active ingress limiting", RNS.LOG_DEBUG)
+                        RNS.log(f"Not sending recursive path request{interface_str} due to active ingress limiting", RNS.LOG_PATHING)
                     return
 
                 # Forward path request on all interfaces
                 # except the requestor interface
-                RNS.log("Attempting to discover unknown path to "+RNS.prettyhexrep(destination_hash)+" on behalf of path request"+interface_str, RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
+                RNS.log("Attempting to discover unknown path to "+RNS.prettyhexrep(destination_hash)+" on behalf of path request"+interface_str, RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
                 pr_entry = { "destination_hash": destination_hash, "timeout": time.time()+Transport.PATH_REQUEST_TIMEOUT, "requesting_interface": attached_interface }
                 with Transport.discovery_pr_lock: Transport.discovery_path_requests[destination_hash] = pr_entry
 
@@ -3099,12 +3069,12 @@ class Transport:
         elif not is_from_local_client and len(Transport.local_client_interfaces) > 0:
             # Forward the path request on all local
             # client interfaces
-            RNS.log("Forwarding path request for "+RNS.prettyhexrep(destination_hash)+interface_str+" to local clients", Transport.PR_LOGLEVEL) if RNS.sl(Transport.PR_LOGLEVEL) else None
+            RNS.log("Forwarding path request for "+RNS.prettyhexrep(destination_hash)+interface_str+" to local clients", RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
             for interface in Transport.local_client_interfaces:
                 Transport.request_path(destination_hash, on_interface=interface)
 
         else:
-            RNS.log("Ignoring path request for "+RNS.prettyhexrep(destination_hash)+interface_str+", no path known", Transport.PR_LOGLEVEL) if RNS.sl(Transport.PR_LOGLEVEL) else None
+            RNS.log("Ignoring path request for "+RNS.prettyhexrep(destination_hash)+interface_str+", no path known", RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
 
     @staticmethod
     def from_local_client(packet):
@@ -3318,7 +3288,7 @@ class Transport:
                         if interface != None:
                             # Get the destination entry from the destination table
                             if not destination_hash in path_table:
-                                RNS.log(f"Skipping persist for path table entry {RNS.prettyhexrep(destination_hash)}, no longer in table", RNS.LOG_DEBUG) if RNS.sl(RNS.LOG_DEBUG) else None
+                                RNS.log(f"Skipping persist for path table entry {RNS.prettyhexrep(destination_hash)}, no longer in table", RNS.LOG_PATHING) if RNS.sl(RNS.LOG_PATHING) else None
 
                             de = path_table[destination_hash]
                             timestamp = de[IDX_PT_TIMESTAMP]

RNS/Utilities/rnsd.py

@@ -265,7 +265,7 @@ instance_name = default
 
 
 [logging]
-# Valid log levels are 0 through 7:
+# Valid log levels are 0 through 8:
 #   0: Log only critical information
 #   1: Log errors and lower log levels
 #   2: Log warnings and lower log levels
@@ -273,7 +273,8 @@ instance_name = default
 #   4: Log info and lower (this is the default)
 #   5: Verbose logging
 #   6: Debug logging
-#   7: Extreme logging
+#   7: Path logging
+#   8: Extreme logging
 
 loglevel = 4
 

RNS/Utilities/rnsh/_version.py

@@ -1 +1 @@
-__version__ = "0.2.0"
+__version__ = "0.3.0"

RNS/Utilities/rnsh/args.py

@@ -44,7 +44,8 @@ def setup_argument_parser():
     parser = argparse.ArgumentParser(description="Reticulum Remote Shell Utility", epilog="When specifying a command to execute, separate rnsh\noptions from the command and its arguments with --\n\nFor example:\n  rnsh -l -- /bin/bash --login\n  rnsh <destination> -- ls -la /tmp", formatter_class=argparse.RawDescriptionHelpFormatter)
 
     # Common options
-    parser.add_argument("--config", "-c", action="store", default=None, help="path to alternative Reticulum config directory", type=str)
+    parser.add_argument("--config", "-c", action="store", default=None, help="path to config directory", type=str)
+    parser.add_argument("--rnsconfig", action="store", default=None, help="path to alternative Reticulum config directory", type=str)
     parser.add_argument("--identity", "-i", action="store", default=None, help="path to identity file to use", type=str)
     parser.add_argument("-v", "--verbose", action="count", default=0, help="increase verbosity")
     parser.add_argument("-q", "--quiet", action="count", default=0, help="decrease verbosity")

RNS/Utilities/rnsh/exception.py

@@ -53,8 +53,6 @@ class permit(AbstractContextManager):
     """
 
     def __init__(self, *exceptions): self._exceptions = exceptions
-
     def __enter__(self): pass
-
     def __exit__(self, exctype, excinst, exctb):
         return exctype is not None and not issubclass(exctype, self._exceptions)

RNS/Utilities/rnsh/helpers.py

@@ -55,5 +55,4 @@ class SleepRate:
         return sleep_for if sleep_for > 0 else 0
 
     async def sleep_async(self): await asyncio.sleep(self.next_sleep_time())
-
     def sleep_block(self): time.sleep(self.next_sleep_time())

RNS/Utilities/rnsh/initiator.py

@@ -144,7 +144,7 @@ class RemoteExecutionError(Exception):
     def __init__(self, msg): self.msg = msg
 
 
-async def _initiate_link(configdir, rnsconfigdir, identitypath=None, verbosity=0, quietness=0, noid=False, destination=None,
+async def _initiate_link(configdir, rnsconfigdir, identitypath=None, logfile=None, verbosity=0, quietness=0, noid=False, destination=None,
                          timeout=RNS.Transport.PATH_REQUEST_TIMEOUT):
     global _identity, _reticulum, _link, _destination, _remote_exec_grace
 
@@ -160,11 +160,11 @@ async def _initiate_link(configdir, rnsconfigdir, identitypath=None, verbosity=0
 
     if _reticulum is None:
         targetloglevel = compute_target_rns_loglevel(verbosity, quietness, RNS.LOG_ERROR)
-        RNS.logfile = os.path.join(configdir, "logfile")
+        RNS.logfile = logfile
         _reticulum = RNS.Reticulum(configdir=rnsconfigdir, loglevel=targetloglevel, logdest=RNS.LOG_FILE)
 
     if _identity is None:
-        _identity = rnsh.prepare_identity(identitypath)
+        _identity = rnsh.prepare_identity(identity_path=identitypath, service_name=None, configdir=configdir)
 
     if not RNS.Transport.has_path(destination_hash):
         RNS.Transport.request_path(destination_hash)
@@ -211,8 +211,9 @@ async def _handle_error(errmsg: RNS.MessageBase):
         raise RemoteExecutionError(f"Remote error: {errmsg.msg}")
 
 
-async def initiate(configdir: str, rnsconfigdir:str, identitypath: str, verbosity: int, quietness: int, noid: bool, destination: str,
+async def initiate(configdir: str, rnsconfigdir:str, identitypath: str, logfile:str, verbosity: int, quietness: int, noid: bool, destination: str,
                    timeout: float, command: [str] | None = None):
+
     global _finished, _link
     if timeout is None:
         timeout = RNS.Transport.PATH_REQUEST_TIMEOUT
@@ -239,12 +240,6 @@ async def initiate(configdir: str, rnsconfigdir:str, identitypath: str, verbosit
         channel = _link.get_channel()
         protocol.register_message_types(channel)
         channel.add_message_handler(_client_message_handler)
-
-        # Next step after linking and identifying: send version
-        # if not await _spin(lambda: messenger.is_outlet_ready(outlet), timeout=5, quiet=quietness > 0):
-        #     print("Error bringing up link")
-        #     return 253
-
         channel.send(protocol.VersionInfoMessage())
         try:
             vm = _pq.get(timeout=max(outlet.rtt * 20, 5))
@@ -283,10 +278,8 @@ async def initiate(configdir: str, rnsconfigdir:str, identitypath: str, verbosit
                 return None
             elif b == "L":
                 line_mode = not line_mode
-                if line_mode:
-                    os.write(1, "\n\rLine-interactive mode enabled\n\r".encode("utf-8"))
-                else:
-                    os.write(1, "\n\rLine-interactive mode disabled\n\r".encode("utf-8"))
+                if line_mode: os.write(1, "\n\rLine-interactive mode enabled\n\r".encode("utf-8"))
+                else:         os.write(1, "\n\rLine-interactive mode disabled\n\r".encode("utf-8"))
                 return None
 
             return b

RNS/Utilities/rnsh/listener.py

@@ -118,25 +118,32 @@ def compute_target_rns_loglevel(verbosity: int, quietness: int, base_level: int
     
     except Exception: return base_level
 
-async def listen(configdir, rnsconfigdir, command, identitypath=None, service_name=None, verbosity=0, quietness=0, allowed=None,
-                 allowed_file=None, disable_auth=None, announce_period=900, no_remote_command=True, remote_cmd_as_args=False,
+async def listen(configdir, rnsconfigdir, command, identitypath=None, logfile=None, service_name=None, verbosity=0, quietness=0,
+                 allowed=None, allowed_file=None, disable_auth=None, announce_period=900, no_remote_command=True, remote_cmd_as_args=False,
                  loop: asyncio.AbstractEventLoop = None):
     global _identity, _allow_all, _allowed_identity_hashes, _allowed_file, _allowed_file_identity_hashes
     global _reticulum, _cmd, _destination, _no_remote_command, _remote_cmd_as_args, _finished
 
     if not loop: loop = asyncio.get_running_loop()
-    if service_name is None or len(service_name) == 0:
-        service_name = "default"
+    if service_name is None or len(service_name) == 0: service_name = "default"
 
     RNS.log(f"Using service name {service_name}", RNS.LOG_INFO)
+    if logfile:
+        RNS.log(f"Logging to {logfile}", RNS.LOG_NOTICE)
+        logdest = RNS.LOG_FILE
+        RNS.logfile = logfile
+    else:
+        RNS.log(f"Logging to console", RNS.LOG_NOTICE)
+        logdest = RNS.LOG_STDOUT
 
     # More -v should increase verbosity (higher RNS.loglevel); -q should decrease it
     targetloglevel = compute_target_rns_loglevel(verbosity, quietness, RNS.LOG_INFO)
     _reticulum = RNS.Reticulum(configdir=rnsconfigdir, loglevel=targetloglevel)
-    _identity = rnsh.prepare_identity(identitypath, service_name)
+    _identity = rnsh.prepare_identity(identity_path=identitypath, service_name=service_name, configdir=configdir)
     _destination = RNS.Destination(_identity, RNS.Destination.IN, RNS.Destination.SINGLE, rnsh.APP_NAME)
     
     RNS.log(f"rnsh listening for commands on {RNS.prettyhexrep(_destination.hash)}", RNS.LOG_NOTICE)
+    RNS.logdest = logdest
     
     _cmd = command
     if _cmd is None or len(_cmd) == 0:

RNS/Utilities/rnsh/retry.py

@@ -88,8 +88,7 @@ class RetryThread(AbstractContextManager):
         self._thread = threading.Thread(name=name, target=self._thread_run, daemon=True)
         self._thread.start()
 
-    def is_alive(self):
-        return self._thread.is_alive()
+    def is_alive(self): return self._thread.is_alive()
 
     def close(self, loop: asyncio.AbstractEventLoop = None) -> asyncio.Future:
         RNS.log("Stopping timer thread", RNS.LOG_DEBUG)
@@ -102,17 +101,12 @@ class RetryThread(AbstractContextManager):
             return self._finished
 
     def wait(self, timeout: float = None):
-        if timeout:
-            timeout = timeout + time.time()
-
+        if timeout: timeout = timeout + time.time()
         while timeout is None or time.time() < timeout:
-            with self._lock:
-                task_count = len(self._statuses)
-            if task_count == 0:
-                return
+            with self._lock: task_count = len(self._statuses)
+            if task_count == 0: return
             time.sleep(0.1)
 
-
     def _thread_run(self):
         while self._run and self._finished is None:
             time.sleep(self._loop_period)

RNS/Utilities/rnsh/rnsh.py

@@ -57,43 +57,54 @@ loop: asyncio.AbstractEventLoop | None = None
 
 def _sanitize_service_name(service_name:str) -> str: return re.sub(r'\W+', '', service_name)
 
-def prepare_identity(identity_path, service_name: str = None) -> tuple[RNS.Identity]:
+def prepare_identity(identity_path=None, service_name=None, configdir=None):
     service_name = _sanitize_service_name(service_name or "")
-    if identity_path is None:
-        identity_path = RNS.Reticulum.identitypath + "/" + APP_NAME + \
-                        (f".{service_name}" if service_name and len(service_name) > 0 else "")
+    if not identity_path:
+        identity_path = f"{configdir}/identity" + (f".{service_name}" if service_name and len(service_name) > 0 else "")
 
     identity = None
     if os.path.isfile(identity_path):
+        RNS.log(f"Loading identity from {identity_path}", RNS.LOG_VERBOSE)
         identity = RNS.Identity.from_file(identity_path)
 
     if identity is None:
-        RNS.log("No valid saved identity found, creating new...", RNS.LOG_INFO)
+        RNS.log(f"Creating identity {identity_path}", RNS.LOG_NOTICE)
         identity = RNS.Identity()
         identity.to_file(identity_path)
     
     return identity
 
 
-def print_identity(configdir, identitypath, service_name, include_destination: bool):
-    reticulum = RNS.Reticulum(configdir=configdir, loglevel=RNS.LOG_INFO)
-    if service_name and len(service_name) > 0:
-        print(f"Using service name \"{service_name}\"")
-    identity = prepare_identity(identitypath, service_name)
+def print_identity(configdir, rnsconfigdir, identitypath, service_name, include_destination: bool):
+    reticulum = RNS.Reticulum(configdir=rnsconfigdir, loglevel=RNS.LOG_INFO)
+    if service_name and len(service_name) > 0: print(f"Using service name \"{service_name}\"")
+    identity = prepare_identity(identity_path=identitypath, service_name=service_name, configdir=configdir)
     destination = RNS.Destination(identity, RNS.Destination.IN, RNS.Destination.SINGLE, APP_NAME)
     print("Identity     : " + str(identity))
-    if include_destination:
-        print("Listening on : " + RNS.prettyhexrep(destination.hash))
+    if include_destination: print("Listening on : " + RNS.prettyhexrep(destination.hash))
 
     exit(0)
 
 verbose_set = False
 
-def ensure_config_directory():
-    if os.path.isdir(os.path.expanduser("~/.config/rnsh")): return os.path.expanduser("~/.config/rnsh")
-    elif os.path.isdir(os.path.expanduser("~/.rnsh")): return os.path.expanduser("~/.rnsh")
+def ensure_config_directory(configdir=None):
+    if configdir:
+        if os.path.isdir(os.path.expanduser(configdir)): return os.path.expanduser(configdir)
+        else:
+            try:
+                RNS.log(f"Creating configuration directory: {os.path.expanduser(configdir)}")
+                os.makedirs(os.path.expanduser(configdir))
+                return os.path.expanduser(configdir)
+
+            except Exception as e:
+                RNS.log(f"Could not get or create rnsh configuration directory, aborting", RNS.LOG_CRITICAL)
+                os._exit(1)
+
+    elif os.path.isdir(os.path.expanduser("~/.config/rnsh")): return os.path.expanduser("~/.config/rnsh")
+    elif os.path.isdir(os.path.expanduser("~/.rnsh")):        return os.path.expanduser("~/.rnsh")
     else:
         try:
+            RNS.log(f"Creating configuration directory: {os.path.expanduser('~/.rnsh')}")
             os.makedirs(os.path.expanduser("~/.rnsh"))
             return os.path.expanduser("~/.rnsh")
 
@@ -105,26 +116,30 @@ def ensure_config_directory():
 async def _rnsh_cli_main():
     global verbose_set
     args, parser = parse_arguments()
-    verbose_set = args.verbose > 0
+    verbose_set  = args.verbose > 0
+    configdir    = ensure_config_directory(args.config)
 
-    configdir = ensure_config_directory()
+    if not configdir:
+        RNS.log(f"Could not resolve rnsh configuration directory", RNS.LOG_CRITICAL)
+        os._exit(1)
 
     if args.print_identity:
-        print_identity(args.config, args.identity, args.service, args.listen)
+        print_identity(configdir, args.rnsconfig, args.identity, args.service, args.listen)
         return 0
 
+    logfile = f"{configdir}/logfile"
+
     if args.listen:
         allowed_file = None
         dest_len = (RNS.Reticulum.TRUNCATED_HASHLENGTH//8)*2
-        if os.path.isfile(os.path.expanduser("~/.config/rnsh/allowed_identities")):
-            allowed_file = os.path.expanduser("~/.config/rnsh/allowed_identities")
-        elif os.path.isfile(os.path.expanduser("~/.rnsh/allowed_identities")):
-            allowed_file = os.path.expanduser("~/.rnsh/allowed_identities")
+        if os.path.isfile(os.path.expanduser(f"{configdir}/allowed_identities")):
+            allowed_file = os.path.expanduser(f"{configdir}/allowed_identities")
 
         await listener.listen(configdir=configdir,
-                              rnsconfigdir=args.config,
+                              rnsconfigdir=args.rnsconfig,
                               command=args.command,
                               identitypath=args.identity,
+                              logfile=logfile,
                               service_name=args.service,
                               verbosity=args.verbose,
                               quietness=args.quiet,
@@ -138,8 +153,9 @@ async def _rnsh_cli_main():
 
     if args.destination is not None:
         return_code = await initiator.initiate(configdir=configdir,
-                                               rnsconfigdir=args.config,
+                                               rnsconfigdir=args.rnsconfig,
                                                identitypath=args.identity,
+                                               logfile=logfile,
                                                verbosity=args.verbose,
                                                quietness=args.quiet,
                                                noid=args.no_id,
@@ -170,5 +186,4 @@ def main():
     if verbose_set and exc: raise exc
     sys.exit(return_code if return_code is not None else 255)
 
-
 if __name__ == "__main__": main()

RNS/Utilities/rnsh/session.py

@@ -103,6 +103,8 @@ class ListenerSession:
         self.outlet.set_link_closed_callback(self._link_closed)
         self.loop = loop
         self.state: LSState = None
+        self.terminated = False
+        self.authenticated = False
         self.remote_identity = None
         self.term: str | None = None
         self.stdin_is_pipe: bool = False
@@ -122,8 +124,10 @@ class ListenerSession:
         self.return_code_sent = False
         self.process: process.CallbackSubprocess | None = None
 
-        if self.allow_all: self._set_state(LSState.LSSTATE_WAIT_VERS)
-        else: self._set_state(LSState.LSSTATE_WAIT_IDENT)
+        if not self.allow_all: self._set_state(LSState.LSSTATE_WAIT_IDENT)
+        else:
+            self._set_state(LSState.LSSTATE_WAIT_VERS)
+            self.authenticated = True
 
         self.sessions.append(self)
         protocol.register_message_types(self.channel)
@@ -143,37 +147,31 @@ class ListenerSession:
     def _call(self, func: callable, delay: float = 0):
         def call_inner():
             if delay == 0: func()
-            else: self.loop.call_later(delay, func)
+            else:          self.loop.call_later(delay, func)
         
         self.loop.call_soon_threadsafe(call_inner)
 
-    def send(self, message: RNS.MessageBase):
-        self.channel.send(message)
-
-    def _protocol_error(self, name: str):
-        self.terminate(f"Protocol error ({name})")
-
-    def _protocol_timeout_error(self, name: str):
-        self.terminate(f"Protocol timeout error: {name}")
+    def send(self, message: RNS.MessageBase): self.channel.send(message)
+    def _protocol_error(self, name: str): self.terminate(f"Protocol error ({name})")
+    def _protocol_timeout_error(self, name: str): self.terminate(f"Protocol timeout error: {name}")
 
     def terminate(self, error: str = None):
+        self.terminated = True
+        self.state = LSState.LSSTATE_ERROR
         with contextlib.suppress(Exception):
             RNS.log("Terminating session" + (f": {error}" if error else ""), RNS.LOG_DEBUG)
             if error and self.state != LSState.LSSTATE_TEARDOWN:
                 with contextlib.suppress(Exception):
                     self.send(protocol.ErrorMessage(error, True))
 
-            self.state = LSState.LSSTATE_ERROR
             self._terminate_process()
             self._call(self._prune, max(self.outlet.rtt * 3, process.CallbackSubprocess.PROCESS_PIPE_TIME+5))
 
     def _prune(self):
         self.state = LSState.LSSTATE_TEARDOWN
         RNS.log("Pruning session", RNS.LOG_DEBUG)
-        with contextlib.suppress(ValueError):
-            self.sessions.remove(self)
-        with contextlib.suppress(Exception):
-            self.outlet.teardown()
+        with contextlib.suppress(ValueError): self.sessions.remove(self)
+        with contextlib.suppress(Exception):  self.outlet.teardown()
 
     def _check_protocol_timeout(self, fail_condition: Callable[[], bool], name: str):
         timeout = True
@@ -183,7 +181,6 @@ class ListenerSession:
 
     def _link_closed(self, outlet: LSOutletBase):
         outlet.unset_link_closed_callback()
-
         if outlet != self.outlet:
             RNS.log("Link closed received from incorrect outlet", RNS.LOG_DEBUG)
             return
@@ -200,11 +197,14 @@ class ListenerSession:
         if self.state not in [LSState.LSSTATE_WAIT_IDENT, LSState.LSSTATE_WAIT_VERS]:
             self._protocol_error(LSState.LSSTATE_WAIT_IDENT.name)
 
-        if not self.allow_all and identity.hash not in self.allowed_identity_hashes and identity.hash not in self.allowed_file_identity_hashes:
-            self.terminate("Identity is not allowed.")
+        if self.allow_all or identity.hash in self.allowed_identity_hashes or identity.hash in self.allowed_file_identity_hashes:
+            self.authenticated = True
+            self.remote_identity = identity
+            self._set_state(LSState.LSSTATE_WAIT_VERS)
 
-        self.remote_identity = identity
-        self._set_state(LSState.LSSTATE_WAIT_VERS)
+        else:
+            self.authenticated = False
+            self.terminate("Identity not allowed")
 
     @classmethod
     async def pump_all(cls) -> True:
@@ -241,8 +241,7 @@ class ListenerSession:
                 if compressed_length < max_data_len and compressed_length < chunk_segment_length:
                     comp_success = True
                     break
-                else:
-                    comp_try += 1
+                else: comp_try += 1
 
             if comp_success:
                 diff = max_data_len - len(compressed_chunk)
@@ -255,10 +254,8 @@ class ListenerSession:
             return comp_success, processed_length, chunk
 
         try:
-            if self.state != LSState.LSSTATE_RUNNING:
-                return False
-            elif not self.channel.is_ready_to_send():
-                return False
+            if self.state != LSState.LSSTATE_RUNNING: return False
+            elif not self.channel.is_ready_to_send(): return False
             elif len(self.stderr_buf) > 0:
                 comp_success, processed_length, data = compress_adaptive(self.stderr_buf)
                 self.stderr_buf = self.stderr_buf[processed_length:]
@@ -267,8 +264,7 @@ class ListenerSession:
                 msg = protocol.StreamDataMessage(protocol.StreamDataMessage.STREAM_ID_STDERR,
                                                  data, send_eof, comp_success)
                 self.send(msg)
-                if send_eof:
-                    self.stderr_eof_sent = True
+                if send_eof: self.stderr_eof_sent = True
                 return True
             elif len(self.stdout_buf) > 0:
                 comp_success, processed_length, data = compress_adaptive(self.stdout_buf)
@@ -278,8 +274,7 @@ class ListenerSession:
                 msg = protocol.StreamDataMessage(protocol.StreamDataMessage.STREAM_ID_STDOUT,
                                                  data, send_eof, comp_success)
                 self.send(msg)
-                if send_eof:
-                    self.stdout_eof_sent = True
+                if send_eof: self.stdout_eof_sent = True
                 return True
             elif self.return_code is not None and not self.return_code_sent:
                 msg = protocol.CommandExitedMessage(self.return_code)
@@ -295,22 +290,32 @@ class ListenerSession:
 
     def _terminate_process(self):
         with contextlib.suppress(Exception):
-            if self.process and self.process.running:
-                self.process.terminate()
+            if self.process and self.process.running: self.process.terminate()
 
     def _start_cmd(self, cmdline: [str], pipe_stdin: bool, pipe_stdout: bool, pipe_stderr: bool, tcflags: [any],
                    term: str | None, rows: int, cols: int, hpix: int, vpix: int):
 
+        if self.terminated:
+            RNS.log(f"Attempt to start command on terminated session: {cmdline}", RNS.LOG_WARNING)
+            return
+
+        if not self.authenticated:
+            RNS.log(f"Attempt to start command on unauthenticated session: {cmdline}", RNS.LOG_WARNING)
+            self.terminate("Invalid state")
+            return
+
+        if self.state != LSState.LSSTATE_RUNNING:
+            RNS.log(f"Attempt to start command on session not in running state: {cmdline}", RNS.LOG_WARNING)
+            self.terminate("Invalid state")
+            return
+
         self.cmdline = self.default_command
         if not self.allow_remote_command and cmdline and len(cmdline) > 0:
             self.terminate("Remote command line not allowed by listener")
             return
 
-        if self.remote_cmd_as_args and cmdline and len(cmdline) > 0:
-            self.cmdline.extend(cmdline)
-        elif cmdline and len(cmdline) > 0:
-            self.cmdline = cmdline
-
+        if self.remote_cmd_as_args and cmdline and len(cmdline) > 0: self.cmdline.extend(cmdline)
+        elif cmdline and len(cmdline) > 0:                           self.cmdline = cmdline
 
         self.stdin_is_pipe = pipe_stdin
         self.stdout_is_pipe = pipe_stdout
@@ -318,11 +323,8 @@ class ListenerSession:
         self.tcflags = tcflags
         self.term = term
 
-        def stdout(data: bytes):
-            self.stdout_buf.extend(data)
-
-        def stderr(data: bytes):
-            self.stderr_buf.extend(data)
+        def stdout(data: bytes): self.stdout_buf.extend(data)
+        def stderr(data: bytes): self.stderr_buf.extend(data)
 
         try:
             self.process = process.CallbackSubprocess(argv=self.cmdline,
@@ -347,22 +349,28 @@ class ListenerSession:
         self.cols = cols
         self.hpix = hpix
         self.vpix = vpix
-        with contextlib.suppress(Exception):
-            self.process.set_winsize(rows, cols, hpix, vpix)
+        with contextlib.suppress(Exception): self.process.set_winsize(rows, cols, hpix, vpix)
 
     def _received_stdin(self, data: bytes, eof: bool):
-        if data and len(data) > 0:
-            self.process.write(data)
-        if eof:
-            self.process.close_stdin()
+        if data and len(data) > 0: self.process.write(data)
+        if eof:                    self.process.close_stdin()
 
     def _handle_message(self, message: RNS.MessageBase):
+        if self.terminated:
+            RNS.log(f"Received packet, but session was terminated", RNS.LOG_ERROR)
+            return
+        if self.state > LSState.LSSTATE_RUNNING:
+            RNS.log(f"Received packet, but in state {self.state.name}", RNS.LOG_ERROR)
+            return
         if self.state == LSState.LSSTATE_WAIT_IDENT:
             # Ignore any messages until the initiator has identified to avoid race conditions
             # between identity announcement and early protocol messages.
             RNS.log("Ignoring message while waiting for identification", RNS.LOG_DEBUG)
             return
-        if self.state == LSState.LSSTATE_WAIT_VERS:
+        elif self.state == LSState.LSSTATE_WAIT_VERS:
+            if not self.authenticated:
+                self.terminate("Invalid state")
+                return
             if not isinstance(message, protocol.VersionInfoMessage):
                 self._protocol_error(self.state.name)
                 return
@@ -374,6 +382,9 @@ class ListenerSession:
             self._set_state(LSState.LSSTATE_WAIT_CMD)
             return
         elif self.state == LSState.LSSTATE_WAIT_CMD:
+            if not self.authenticated:
+                self.terminate("Invalid state")
+                return
             if not isinstance(message, protocol.ExecuteCommandMesssage):
                 return self._protocol_error(self.state.name)
             RNS.log(f"Execute command message on link {self.outlet}: {message.cmdline}", RNS.LOG_VERBOSE)
@@ -382,6 +393,9 @@ class ListenerSession:
                             message.tcflags, message.term, message.rows, message.cols, message.hpix, message.vpix)
             return
         elif self.state == LSState.LSSTATE_RUNNING:
+            if not self.authenticated:
+                self.terminate("Invalid state")
+                return
             if isinstance(message, protocol.WindowSizeMessage):
                 self._set_window_size(message.rows, message.cols, message.hpix, message.vpix)
             elif isinstance(message, protocol.StreamDataMessage):
@@ -394,9 +408,6 @@ class ListenerSession:
                 # echo noop only on listener--used for keepalive/connectivity check
                 self.send(message)
                 return
-        elif self.state in [LSState.LSSTATE_ERROR, LSState.LSSTATE_TEARDOWN]:
-            RNS.log(f"Received packet, but in state {self.state.name}", RNS.LOG_ERROR)
-            return
         else:
             self._protocol_error("unexpected message")
             return
@@ -405,29 +416,20 @@ class ListenerSession:
 class RNSOutlet(LSOutletBase):
 
     def set_initiator_identified_callback(self, cb: Callable[[LSOutletBase, _TIdentity], None]):
-        def inner_cb(link, identity: _TIdentity):
-            cb(self, identity)
-
+        def inner_cb(link, identity: _TIdentity): cb(self, identity)
         self.link.set_remote_identified_callback(inner_cb)
 
     def set_link_closed_callback(self, cb: Callable[[LSOutletBase], None]):
-        def inner_cb(link):
-            cb(self)
-
+        def inner_cb(link): cb(self)
         self.link.set_link_closed_callback(inner_cb)
 
-    def unset_link_closed_callback(self):
-        self.link.set_link_closed_callback(None)
-
-    def teardown(self):
-        self.link.teardown()
+    def unset_link_closed_callback(self): self.link.set_link_closed_callback(None)
+    def teardown(self): self.link.teardown()
 
     @property
-    def rtt(self) -> float:
-        return self.link.rtt
+    def rtt(self) -> float: return self.link.rtt
 
-    def __str__(self):
-        return f"Outlet RNS Link {self.link}"
+    def __str__(self): return f"Outlet on {self.link}"
 
     def __init__(self, link: RNS.Link):
         self.link = link
@@ -435,7 +437,5 @@ class RNSOutlet(LSOutletBase):
 
     @staticmethod
     def get_outlet(link: RNS.Link):
-        if hasattr(link, "lsoutlet"):
-            return link.lsoutlet
-
+        if hasattr(link, "lsoutlet"): return link.lsoutlet
         return RNSOutlet(link)

RNS/Utilities/rnstatus.py

@@ -450,6 +450,9 @@ def program_setup(configdir, dispall=False, verbosity=0, name_filter=None, json=
                                     clients_string = ""
                             else:
                                 clients_string = "Clients   : "+str(clients)
+                                if "blocked_ips" in ifstat:
+                                    p = ifstat["blocked_ips"] > 0
+                                    if p: clients_string += "\n    Blocked   : "+str(ifstat["blocked_ips"])+" IP"+"s" if p else ""
 
                         else:
                             clients = None

RNS/__init__.py

@@ -70,7 +70,8 @@ LOG_NOTICE   = 3
 LOG_INFO     = 4
 LOG_VERBOSE  = 5
 LOG_DEBUG    = 6
-LOG_EXTREME  = 7
+LOG_PATHING  = 7
+LOG_EXTREME  = 8
 
 LOG_STDOUT   = 0x91
 LOG_FILE     = 0x92
@@ -102,6 +103,7 @@ def loglevelname(level):
     if (level == LOG_INFO):     return "[Info]    "
     if (level == LOG_VERBOSE):  return "[Verbose] "
     if (level == LOG_DEBUG):    return "[Debug]   "
+    if (level == LOG_PATHING):  return "[Pathing] "
     if (level == LOG_EXTREME):  return "[Extra]   "
     
     return "Unknown"

RNS/_version.py

@@ -1 +1 @@
-__version__ = "1.3.6"
+__version__ = "1.3.9"

docs/manual/.buildinfo

@@ -1,4 +1,4 @@
 # Sphinx build info version 1
 # This file records the configuration used when building these files. When it is not found, a full rebuild will be done.
-config: c608aeb54a4bb500d26d78accb0ff325
+config: b7a9e97674355dfa0f0218a058ae09df
 tags: 645f666f9bcd5a90fca523b33c5a78b7

docs/manual/_sources/interfaces.rst.txt

@@ -230,6 +230,51 @@ specify the target Yggdrasil IPv6 address and port, like so:
       target_host = 201:5d78:af73:5caf:a4de:a79f:3278:71e5
       target_port = 4343
 
+Automated Blocking
+------------------
+Listener instances of ``BackboneInterface`` will automatically block fast-flapping clients,
+that repeatedly connect for a short amount of time, and then disconnect. Such behavior usually
+occurs from clients trying to spam the network with announces or path requests, by connecting, dumping
+a massive amount of requests, and then disconnecting in an attempt to bypass rate limits.
+
+While such bypass attempts only have very limited effect on the amount of spam actually dumped (ingress limits
+trigger immediately once a client exceeds rate limits), the behavior is often seen anyways, and
+causes log noise and needless interface rotation. The fast-flapping block ensures such clients
+are never allocated an interface on the transport instance.
+
+Another common cause can simply be clients using implementations that are broken, or automated
+scanning tools attempting to connect to the instance.
+
+.. code:: ini
+
+  [[Backbone Listener]]
+    type = BackboneInterface
+    enabled = yes    
+    listen_on = 0.0.0.0
+    port = 4242
+
+    # Whether to enable blocking
+    block_fast_flapping = yes
+
+    # How long an IP address stays
+    # blocked, in minutes. Set to
+    # 12 hours by default.
+    fast_flapping_block_time = 720
+
+    # The minimum time, in seconds,
+    # an interface must stay connected
+    # to be considered not fast-flapping.
+    fast_flapping_threshold = 20
+
+    # Amount of fast flaps a remote
+    # IP can perform before having
+    # blocking triggered.
+    fast_flapping_grace = 5
+
+The configuration options listed in the example above are the *default values*, and you do
+not need to add them for automated blocking to work, but you can use them to change the
+behavior from the defaults, if necessary.
+
 .. _interfaces-tcps:
 
 TCP Server Interface
@@ -998,7 +1043,13 @@ On a real system, you should make the script robust enough to deal with intermit
 **Physical Location**
 
 ``latitude``, ``longitude``, ``height``
-  Optional physical coordinates for the interface. These are useful for mapping discovered interfaces geographically or for clients to automatically select the nearest access point. Coordinates should be in decimal degrees, height in meters.
+  Optional physical coordinates for the interface. These are useful for mapping discovered interfaces geographically or for clients to automatically select the nearest access point. Coordinates should be in decimal degrees, height in meters above mean sea level.
+
+``location_cmd``
+  Optional path to executable or script that returns the physical coordinates for the interface. This can be used instead of manually setting ``latitude``, ``longitude`` and ``height``. Reticulum expects the script to output the location data to ``stdout`` on a single line, separated by commas, with values as floating point numbers in the format ``LAT, LON, HEIGHT``. Coordinates should be in decimal degrees, height in meters above mean sea level.
+
+.. note::
+   The height value for interface discovery is specified in *height above mean sea level*! This is the geoid-corrected height value, and is distinct from GPS altitude. If you manually specify height, it will typically be set to what you find on a topographical map. If you are using a script to output the location data, make sure that you are using the geoid-corrected altitude, not height above the GPS ellipsoid. Most GPS systems will make both figures available.
 
 **Radio Parameters**
 

docs/manual/_sources/using.rst.txt

@@ -1002,39 +1002,35 @@ available. These are only recognised immediately after a newline character:
     destination           hexadecimal hash of the destination to connect to
 
   options:
-    -h, --help            show this help message and exit
-    --config, -c CONFIG   path to alternative Reticulum config directory
-    --identity, -i IDENTITY
-                          path to identity file to use
-    -v, --verbose         increase verbosity
-    -q, --quiet           decrease verbosity
-    -p, --print-identity  print identity and destination info and exit
-    --version             show program's version number and exit
-    -l, --listen          listen (server) mode; any command specified after --
-                          will be used as the default command when the initiator
-                          does not provide one or when remote command execution
-                          is disabled; if no command is specified, the default
-                          shell of the user running rnsh will be used
-    -s, --service SERVICE
-                          service name for identity file if not the default
-    -b, --announce PERIOD
-                          announce on startup and every PERIOD seconds; specify
-                          0 to announce on startup only
-    -a, --allowed HASH    allow this identity to connect (may be specified
-                          multiple times); allowed identities can also be
-                          specified in ~/.rnsh/allowed_identities or
-                          ~/.config/rnsh/allowed_identities, one hash per line
-    -n, --no-auth         disable authentication (allow any identity to connect)
+    -h, --help              show this help message and exit
+    --config, -c PATH       path to config directory
+    --rnsconfig, -c PATH    path to alternative Reticulum config directory
+    --identity, -i IDENTITY path to identity file to use
+    -v, --verbose           increase verbosity
+    -q, --quiet             decrease verbosity
+    -p, --print-identity    print identity and destination info and exit
+    --version               show program's version number and exit
+    -l, --listen            listen (server) mode; any command specified after --
+                            will be used as the default command when the initiator
+                            does not provide one or when remote command execution
+                            is disabled; if no command is specified, the default
+                            shell of the user running rnsh will be used
+    -s, --service SERVICE   service name for identity file if not the default
+    -b, --announce PERIOD   announce on startup and every PERIOD seconds; specify
+                            0 to announce on startup only
+    -a, --allowed HASH      allow this identity to connect (may be specified
+                            multiple times); allowed identities can also be
+                            specified in ~/.rnsh/allowed_identities or
+                            ~/.config/rnsh/allowed_identities, one hash per line
+    -n, --no-auth           disable authentication (allow any identity to connect)
     -A, --remote-command-as-args
-                          concatenate remote command to the argument list of the
-                          default program or shell
-    -C, --no-remote-command
-                          disable executing command lines received from the
-                          remote initiator
-    -N, --no-id           disable identity announcement on connect
-    -m, --mirror          return with the exit code of the remote process
-    -w, --timeout SECONDS
-                          connect and request timeout in seconds
+                            concatenate remote command to the argument list of the
+                            default program or shell
+    -C, --no-remote-command disable executing command lines received from the
+                            remote initiator
+    -N, --no-id             disable identity announcement on connect
+    -m, --mirror            return with the exit code of the remote process
+    -w, --timeout SECONDS   connect and request timeout in seconds
 
   When specifying a command to execute, separate rnsh options from the command
   and its arguments with --. For example:

docs/manual/_static/documentation_options.js

@@ -1,5 +1,5 @@
 const DOCUMENTATION_OPTIONS = {
-    VERSION: '1.3.6',
+    VERSION: '1.3.9',
     LANGUAGE: 'en',
     COLLAPSE_INDEX: false,
     BUILDER: 'html',

docs/manual/distributed.html

@@ -7,7 +7,7 @@
         <link rel="prefetch" href="_static/rns_logo_512.png" as="image">
 
     <!-- Generated with Sphinx 8.2.3 and Furo 2025.09.25.dev1 -->
-        <title>Distributed Development - Reticulum Network Stack 1.3.6 documentation</title>
+        <title>Distributed Development - Reticulum Network Stack 1.3.9 documentation</title>
       <link rel="stylesheet" type="text/css" href="_static/pygments.css?v=d111a655" />
     <link rel="stylesheet" type="text/css" href="_static/styles/furo.css?v=580074bf" />
     <link rel="stylesheet" type="text/css" href="_static/copybutton.css?v=76b2166b" />
@@ -180,7 +180,7 @@
       </label>
     </div>
     <div class="header-center">
-      <a href="index.html"><div class="brand">Reticulum Network Stack 1.3.6 documentation</div></a>
+      <a href="index.html"><div class="brand">Reticulum Network Stack 1.3.9 documentation</div></a>
     </div>
     <div class="header-right">
       <div class="theme-toggle-container theme-toggle-header">
@@ -204,7 +204,7 @@
     <img class="sidebar-logo" src="_static/rns_logo_512.png" alt="Logo"/>
   </div>
   
-  <span class="sidebar-brand-text">Reticulum Network Stack 1.3.6 documentation</span>
+  <span class="sidebar-brand-text">Reticulum Network Stack 1.3.9 documentation</span>
   
 </a><form class="sidebar-search-container" method="get" action="search.html" role="search">
   <input class="sidebar-search" placeholder="Search" name="q" aria-label="Search">
@@ -431,7 +431,7 @@
       
     </aside>
   </div>
-</div><script src="_static/documentation_options.js?v=70d8fd07"></script>
+</div><script src="_static/documentation_options.js?v=98c25ec5"></script>
     <script src="_static/doctools.js?v=9bcbadda"></script>
     <script src="_static/sphinx_highlight.js?v=dc90522c"></script>
     <script src="_static/scripts/furo.js?v=46bd48cc"></script>

docs/manual/examples.html

@@ -7,7 +7,7 @@
         <link rel="prefetch" href="_static/rns_logo_512.png" as="image">
 
     <!-- Generated with Sphinx 8.2.3 and Furo 2025.09.25.dev1 -->
-        <title>Code Examples - Reticulum Network Stack 1.3.6 documentation</title>
+        <title>Code Examples - Reticulum Network Stack 1.3.9 documentation</title>
       <link rel="stylesheet" type="text/css" href="_static/pygments.css?v=d111a655" />
     <link rel="stylesheet" type="text/css" href="_static/styles/furo.css?v=580074bf" />
     <link rel="stylesheet" type="text/css" href="_static/copybutton.css?v=76b2166b" />
@@ -180,7 +180,7 @@
       </label>
     </div>
     <div class="header-center">
-      <a href="index.html"><div class="brand">Reticulum Network Stack 1.3.6 documentation</div></a>
+      <a href="index.html"><div class="brand">Reticulum Network Stack 1.3.9 documentation</div></a>
     </div>
     <div class="header-right">
       <div class="theme-toggle-container theme-toggle-header">
@@ -204,7 +204,7 @@
     <img class="sidebar-logo" src="_static/rns_logo_512.png" alt="Logo"/>
   </div>
   
-  <span class="sidebar-brand-text">Reticulum Network Stack 1.3.6 documentation</span>
+  <span class="sidebar-brand-text">Reticulum Network Stack 1.3.9 documentation</span>
   
 </a><form class="sidebar-search-container" method="get" action="search.html" role="search">
   <input class="sidebar-search" placeholder="Search" name="q" aria-label="Search">
@@ -3648,7 +3648,7 @@
       
     </aside>
   </div>
-</div><script src="_static/documentation_options.js?v=70d8fd07"></script>
+</div><script src="_static/documentation_options.js?v=98c25ec5"></script>
     <script src="_static/doctools.js?v=9bcbadda"></script>
     <script src="_static/sphinx_highlight.js?v=dc90522c"></script>
     <script src="_static/scripts/furo.js?v=46bd48cc"></script>

docs/manual/forhumans.html

@@ -7,7 +7,7 @@
         <link rel="prefetch" href="_static/rns_logo_512.png" as="image">
 
     <!-- Generated with Sphinx 8.2.3 and Furo 2025.09.25.dev1 -->
-        <title>An Explanation of Reticulum for Human Beings - Reticulum Network Stack 1.3.6 documentation</title>
+        <title>An Explanation of Reticulum for Human Beings - Reticulum Network Stack 1.3.9 documentation</title>
       <link rel="stylesheet" type="text/css" href="_static/pygments.css?v=d111a655" />
     <link rel="stylesheet" type="text/css" href="_static/styles/furo.css?v=580074bf" />
     <link rel="stylesheet" type="text/css" href="_static/copybutton.css?v=76b2166b" />
@@ -180,7 +180,7 @@
       </label>
     </div>
     <div class="header-center">
-      <a href="index.html"><div class="brand">Reticulum Network Stack 1.3.6 documentation</div></a>
+      <a href="index.html"><div class="brand">Reticulum Network Stack 1.3.9 documentation</div></a>
     </div>
     <div class="header-right">
       <div class="theme-toggle-container theme-toggle-header">
@@ -204,7 +204,7 @@
     <img class="sidebar-logo" src="_static/rns_logo_512.png" alt="Logo"/>
   </div>
   
-  <span class="sidebar-brand-text">Reticulum Network Stack 1.3.6 documentation</span>
+  <span class="sidebar-brand-text">Reticulum Network Stack 1.3.9 documentation</span>
   
 </a><form class="sidebar-search-container" method="get" action="search.html" role="search">
   <input class="sidebar-search" placeholder="Search" name="q" aria-label="Search">
@@ -296,7 +296,7 @@
       
     </aside>
   </div>
-</div><script src="_static/documentation_options.js?v=70d8fd07"></script>
+</div><script src="_static/documentation_options.js?v=98c25ec5"></script>
     <script src="_static/doctools.js?v=9bcbadda"></script>
     <script src="_static/sphinx_highlight.js?v=dc90522c"></script>
     <script src="_static/scripts/furo.js?v=46bd48cc"></script>

docs/manual/genindex.html

@@ -5,7 +5,7 @@
     <meta name="color-scheme" content="light dark"><link rel="index" title="Index" href="#"><link rel="search" title="Search" href="search.html">
         <link rel="prefetch" href="_static/rns_logo_512.png" as="image">
 
-    <!-- Generated with Sphinx 8.2.3 and Furo 2025.09.25.dev1 --><title>Index - Reticulum Network Stack 1.3.6 documentation</title>
+    <!-- Generated with Sphinx 8.2.3 and Furo 2025.09.25.dev1 --><title>Index - Reticulum Network Stack 1.3.9 documentation</title>
 <link rel="stylesheet" type="text/css" href="_static/pygments.css?v=d111a655" />
     <link rel="stylesheet" type="text/css" href="_static/styles/furo.css?v=580074bf" />
     <link rel="stylesheet" type="text/css" href="_static/copybutton.css?v=76b2166b" />
@@ -178,7 +178,7 @@
       </label>
     </div>
     <div class="header-center">
-      <a href="index.html"><div class="brand">Reticulum Network Stack 1.3.6 documentation</div></a>
+      <a href="index.html"><div class="brand">Reticulum Network Stack 1.3.9 documentation</div></a>
     </div>
     <div class="header-right">
       <div class="theme-toggle-container theme-toggle-header">
@@ -202,7 +202,7 @@
     <img class="sidebar-logo" src="_static/rns_logo_512.png" alt="Logo"/>
   </div>
   
-  <span class="sidebar-brand-text">Reticulum Network Stack 1.3.6 documentation</span>
+  <span class="sidebar-brand-text">Reticulum Network Stack 1.3.9 documentation</span>
   
 </a><form class="sidebar-search-container" method="get" action="search.html" role="search">
   <input class="sidebar-search" placeholder="Search" name="q" aria-label="Search">
@@ -846,7 +846,7 @@
       
     </aside>
   </div>
-</div><script src="_static/documentation_options.js?v=70d8fd07"></script>
+</div><script src="_static/documentation_options.js?v=98c25ec5"></script>
     <script src="_static/doctools.js?v=9bcbadda"></script>
     <script src="_static/sphinx_highlight.js?v=dc90522c"></script>
     <script src="_static/scripts/furo.js?v=46bd48cc"></script>

docs/manual/gettingstartedfast.html

@@ -7,7 +7,7 @@
         <link rel="prefetch" href="_static/rns_logo_512.png" as="image">
 
     <!-- Generated with Sphinx 8.2.3 and Furo 2025.09.25.dev1 -->
-        <title>Getting Started Fast - Reticulum Network Stack 1.3.6 documentation</title>
+        <title>Getting Started Fast - Reticulum Network Stack 1.3.9 documentation</title>
       <link rel="stylesheet" type="text/css" href="_static/pygments.css?v=d111a655" />
     <link rel="stylesheet" type="text/css" href="_static/styles/furo.css?v=580074bf" />
     <link rel="stylesheet" type="text/css" href="_static/copybutton.css?v=76b2166b" />
@@ -180,7 +180,7 @@
       </label>
     </div>
     <div class="header-center">
-      <a href="index.html"><div class="brand">Reticulum Network Stack 1.3.6 documentation</div></a>
+      <a href="index.html"><div class="brand">Reticulum Network Stack 1.3.9 documentation</div></a>
     </div>
     <div class="header-right">
       <div class="theme-toggle-container theme-toggle-header">
@@ -204,7 +204,7 @@
     <img class="sidebar-logo" src="_static/rns_logo_512.png" alt="Logo"/>
   </div>
   
-  <span class="sidebar-brand-text">Reticulum Network Stack 1.3.6 documentation</span>
+  <span class="sidebar-brand-text">Reticulum Network Stack 1.3.9 documentation</span>
   
 </a><form class="sidebar-search-container" method="get" action="search.html" role="search">
   <input class="sidebar-search" placeholder="Search" name="q" aria-label="Search">
@@ -776,7 +776,7 @@ section of this manual.</p>
       
     </aside>
   </div>
-</div><script src="_static/documentation_options.js?v=70d8fd07"></script>
+</div><script src="_static/documentation_options.js?v=98c25ec5"></script>
     <script src="_static/doctools.js?v=9bcbadda"></script>
     <script src="_static/sphinx_highlight.js?v=dc90522c"></script>
     <script src="_static/scripts/furo.js?v=46bd48cc"></script>

docs/manual/git.html

@@ -7,7 +7,7 @@
         <link rel="prefetch" href="_static/rns_logo_512.png" as="image">
 
     <!-- Generated with Sphinx 8.2.3 and Furo 2025.09.25.dev1 -->
-        <title>Git Over Reticulum - Reticulum Network Stack 1.3.6 documentation</title>
+        <title>Git Over Reticulum - Reticulum Network Stack 1.3.9 documentation</title>
       <link rel="stylesheet" type="text/css" href="_static/pygments.css?v=d111a655" />
     <link rel="stylesheet" type="text/css" href="_static/styles/furo.css?v=580074bf" />
     <link rel="stylesheet" type="text/css" href="_static/copybutton.css?v=76b2166b" />
@@ -180,7 +180,7 @@
       </label>
     </div>
     <div class="header-center">
-      <a href="index.html"><div class="brand">Reticulum Network Stack 1.3.6 documentation</div></a>
+      <a href="index.html"><div class="brand">Reticulum Network Stack 1.3.9 documentation</div></a>
     </div>
     <div class="header-right">
       <div class="theme-toggle-container theme-toggle-header">
@@ -204,7 +204,7 @@
     <img class="sidebar-logo" src="_static/rns_logo_512.png" alt="Logo"/>
   </div>
   
-  <span class="sidebar-brand-text">Reticulum Network Stack 1.3.6 documentation</span>
+  <span class="sidebar-brand-text">Reticulum Network Stack 1.3.9 documentation</span>
   
 </a><form class="sidebar-search-container" method="get" action="search.html" role="search">
   <input class="sidebar-search" placeholder="Search" name="q" aria-label="Search">
@@ -1594,7 +1594,7 @@ done
       
     </aside>
   </div>
-</div><script src="_static/documentation_options.js?v=70d8fd07"></script>
+</div><script src="_static/documentation_options.js?v=98c25ec5"></script>
     <script src="_static/doctools.js?v=9bcbadda"></script>
     <script src="_static/sphinx_highlight.js?v=dc90522c"></script>
     <script src="_static/scripts/furo.js?v=46bd48cc"></script>

docs/manual/hardware.html

@@ -7,7 +7,7 @@
         <link rel="prefetch" href="_static/rns_logo_512.png" as="image">
 
     <!-- Generated with Sphinx 8.2.3 and Furo 2025.09.25.dev1 -->
-        <title>Communications Hardware - Reticulum Network Stack 1.3.6 documentation</title>
+        <title>Communications Hardware - Reticulum Network Stack 1.3.9 documentation</title>
       <link rel="stylesheet" type="text/css" href="_static/pygments.css?v=d111a655" />
     <link rel="stylesheet" type="text/css" href="_static/styles/furo.css?v=580074bf" />
     <link rel="stylesheet" type="text/css" href="_static/copybutton.css?v=76b2166b" />
@@ -180,7 +180,7 @@
       </label>
     </div>
     <div class="header-center">
-      <a href="index.html"><div class="brand">Reticulum Network Stack 1.3.6 documentation</div></a>
+      <a href="index.html"><div class="brand">Reticulum Network Stack 1.3.9 documentation</div></a>
     </div>
     <div class="header-right">
       <div class="theme-toggle-container theme-toggle-header">
@@ -204,7 +204,7 @@
     <img class="sidebar-logo" src="_static/rns_logo_512.png" alt="Logo"/>
   </div>
   
-  <span class="sidebar-brand-text">Reticulum Network Stack 1.3.6 documentation</span>
+  <span class="sidebar-brand-text">Reticulum Network Stack 1.3.9 documentation</span>
   
 </a><form class="sidebar-search-container" method="get" action="search.html" role="search">
   <input class="sidebar-search" placeholder="Search" name="q" aria-label="Search">
@@ -676,7 +676,7 @@ can be used with Reticulum. This includes virtual software modems such as
       
     </aside>
   </div>
-</div><script src="_static/documentation_options.js?v=70d8fd07"></script>
+</div><script src="_static/documentation_options.js?v=98c25ec5"></script>
     <script src="_static/doctools.js?v=9bcbadda"></script>
     <script src="_static/sphinx_highlight.js?v=dc90522c"></script>
     <script src="_static/scripts/furo.js?v=46bd48cc"></script>

docs/manual/index.html

@@ -7,7 +7,7 @@
         <link rel="prefetch" href="_static/rns_logo_512.png" as="image">
 
     <!-- Generated with Sphinx 8.2.3 and Furo 2025.09.25.dev1 -->
-        <title>Reticulum Network Stack 1.3.6 documentation</title>
+        <title>Reticulum Network Stack 1.3.9 documentation</title>
       <link rel="stylesheet" type="text/css" href="_static/pygments.css?v=d111a655" />
     <link rel="stylesheet" type="text/css" href="_static/styles/furo.css?v=580074bf" />
     <link rel="stylesheet" type="text/css" href="_static/copybutton.css?v=76b2166b" />
@@ -180,7 +180,7 @@
       </label>
     </div>
     <div class="header-center">
-      <a href="#"><div class="brand">Reticulum Network Stack 1.3.6 documentation</div></a>
+      <a href="#"><div class="brand">Reticulum Network Stack 1.3.9 documentation</div></a>
     </div>
     <div class="header-right">
       <div class="theme-toggle-container theme-toggle-header">
@@ -204,7 +204,7 @@
     <img class="sidebar-logo" src="_static/rns_logo_512.png" alt="Logo"/>
   </div>
   
-  <span class="sidebar-brand-text">Reticulum Network Stack 1.3.6 documentation</span>
+  <span class="sidebar-brand-text">Reticulum Network Stack 1.3.9 documentation</span>
   
 </a><form class="sidebar-search-container" method="get" action="search.html" role="search">
   <input class="sidebar-search" placeholder="Search" name="q" aria-label="Search">
@@ -486,6 +486,7 @@ to participate in the development of Reticulum itself.</p>
 <li class="toctree-l2"><a class="reference internal" href="interfaces.html#backbone-interface">Backbone Interface</a><ul>
 <li class="toctree-l3"><a class="reference internal" href="interfaces.html#listeners">Listeners</a></li>
 <li class="toctree-l3"><a class="reference internal" href="interfaces.html#connecting-remotes">Connecting Remotes</a></li>
+<li class="toctree-l3"><a class="reference internal" href="interfaces.html#automated-blocking">Automated Blocking</a></li>
 </ul>
 </li>
 <li class="toctree-l2"><a class="reference internal" href="interfaces.html#tcp-server-interface">TCP Server Interface</a></li>
@@ -719,7 +720,7 @@ to participate in the development of Reticulum itself.</p>
       
     </aside>
   </div>
-</div><script src="_static/documentation_options.js?v=70d8fd07"></script>
+</div><script src="_static/documentation_options.js?v=98c25ec5"></script>
     <script src="_static/doctools.js?v=9bcbadda"></script>
     <script src="_static/sphinx_highlight.js?v=dc90522c"></script>
     <script src="_static/scripts/furo.js?v=46bd48cc"></script>

docs/manual/interfaces.html

@@ -7,7 +7,7 @@
         <link rel="prefetch" href="_static/rns_logo_512.png" as="image">
 
     <!-- Generated with Sphinx 8.2.3 and Furo 2025.09.25.dev1 -->
-        <title>Configuring Interfaces - Reticulum Network Stack 1.3.6 documentation</title>
+        <title>Configuring Interfaces - Reticulum Network Stack 1.3.9 documentation</title>
       <link rel="stylesheet" type="text/css" href="_static/pygments.css?v=d111a655" />
     <link rel="stylesheet" type="text/css" href="_static/styles/furo.css?v=580074bf" />
     <link rel="stylesheet" type="text/css" href="_static/copybutton.css?v=76b2166b" />
@@ -180,7 +180,7 @@
       </label>
     </div>
     <div class="header-center">
-      <a href="index.html"><div class="brand">Reticulum Network Stack 1.3.6 documentation</div></a>
+      <a href="index.html"><div class="brand">Reticulum Network Stack 1.3.9 documentation</div></a>
     </div>
     <div class="header-right">
       <div class="theme-toggle-container theme-toggle-header">
@@ -204,7 +204,7 @@
     <img class="sidebar-logo" src="_static/rns_logo_512.png" alt="Logo"/>
   </div>
   
-  <span class="sidebar-brand-text">Reticulum Network Stack 1.3.6 documentation</span>
+  <span class="sidebar-brand-text">Reticulum Network Stack 1.3.9 documentation</span>
   
 </a><form class="sidebar-search-container" method="get" action="search.html" role="search">
   <input class="sidebar-search" placeholder="Search" name="q" aria-label="Search">
@@ -460,6 +460,47 @@ specify the target Yggdrasil IPv6 address and port, like so:</p>
 </pre></div>
 </div>
 </section>
+<section id="automated-blocking">
+<h3>Automated Blocking<a class="headerlink" href="#automated-blocking" title="Link to this heading">¶</a></h3>
+<p>Listener instances of <code class="docutils literal notranslate"><span class="pre">BackboneInterface</span></code> will automatically block fast-flapping clients,
+that repeatedly connect for a short amount of time, and then disconnect. Such behavior usually
+occurs from clients trying to spam the network with announces or path requests, by connecting, dumping
+a massive amount of requests, and then disconnecting in an attempt to bypass rate limits.</p>
+<p>While such bypass attempts only have very limited effect on the amount of spam actually dumped (ingress limits
+trigger immediately once a client exceeds rate limits), the behavior is often seen anyways, and
+causes log noise and needless interface rotation. The fast-flapping block ensures such clients
+are never allocated an interface on the transport instance.</p>
+<p>Another common cause can simply be clients using implementations that are broken, or automated
+scanning tools attempting to connect to the instance.</p>
+<div class="highlight-ini notranslate"><div class="highlight"><pre><span></span><span class="k">[[Backbone Listener]]</span>
+<span class="w">  </span><span class="na">type</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">BackboneInterface</span>
+<span class="w">  </span><span class="na">enabled</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">yes</span>
+<span class="w">  </span><span class="na">listen_on</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">0.0.0.0</span>
+<span class="w">  </span><span class="na">port</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">4242</span>
+
+<span class="w">  </span><span class="c1"># Whether to enable blocking</span>
+<span class="w">  </span><span class="na">block_fast_flapping</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">yes</span>
+
+<span class="w">  </span><span class="c1"># How long an IP address stays</span>
+<span class="w">  </span><span class="c1"># blocked, in minutes. Set to</span>
+<span class="w">  </span><span class="c1"># 12 hours by default.</span>
+<span class="w">  </span><span class="na">fast_flapping_block_time</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">720</span>
+
+<span class="w">  </span><span class="c1"># The minimum time, in seconds,</span>
+<span class="w">  </span><span class="c1"># an interface must stay connected</span>
+<span class="w">  </span><span class="c1"># to be considered not fast-flapping.</span>
+<span class="w">  </span><span class="na">fast_flapping_threshold</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">20</span>
+
+<span class="w">  </span><span class="c1"># Amount of fast flaps a remote</span>
+<span class="w">  </span><span class="c1"># IP can perform before having</span>
+<span class="w">  </span><span class="c1"># blocking triggered.</span>
+<span class="w">  </span><span class="na">fast_flapping_grace</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">5</span>
+</pre></div>
+</div>
+<p>The configuration options listed in the example above are the <em>default values</em>, and you do
+not need to add them for automated blocking to work, but you can use them to change the
+behavior from the defaults, if necessary.</p>
+</section>
 </section>
 <section id="tcp-server-interface">
 <span id="interfaces-tcps"></span><h2>TCP Server Interface<a class="headerlink" href="#tcp-server-interface" title="Link to this heading">¶</a></h2>
@@ -1154,9 +1195,15 @@ curl<span class="w"> </span>-s<span class="w"> </span>ip.me
 </dl>
 <p><strong>Physical Location</strong></p>
 <dl class="simple">
-<dt><code class="docutils literal notranslate"><span class="pre">latitude</span></code>, <code class="docutils literal notranslate"><span class="pre">longitude</span></code>, <code class="docutils literal notranslate"><span class="pre">height</span></code></dt><dd><p>Optional physical coordinates for the interface. These are useful for mapping discovered interfaces geographically or for clients to automatically select the nearest access point. Coordinates should be in decimal degrees, height in meters.</p>
+<dt><code class="docutils literal notranslate"><span class="pre">latitude</span></code>, <code class="docutils literal notranslate"><span class="pre">longitude</span></code>, <code class="docutils literal notranslate"><span class="pre">height</span></code></dt><dd><p>Optional physical coordinates for the interface. These are useful for mapping discovered interfaces geographically or for clients to automatically select the nearest access point. Coordinates should be in decimal degrees, height in meters above mean sea level.</p>
+</dd>
+<dt><code class="docutils literal notranslate"><span class="pre">location_cmd</span></code></dt><dd><p>Optional path to executable or script that returns the physical coordinates for the interface. This can be used instead of manually setting <code class="docutils literal notranslate"><span class="pre">latitude</span></code>, <code class="docutils literal notranslate"><span class="pre">longitude</span></code> and <code class="docutils literal notranslate"><span class="pre">height</span></code>. Reticulum expects the script to output the location data to <code class="docutils literal notranslate"><span class="pre">stdout</span></code> on a single line, separated by commas, with values as floating point numbers in the format <code class="docutils literal notranslate"><span class="pre">LAT,</span> <span class="pre">LON,</span> <span class="pre">HEIGHT</span></code>. Coordinates should be in decimal degrees, height in meters above mean sea level.</p>
 </dd>
 </dl>
+<div class="admonition note">
+<p class="admonition-title">Note</p>
+<p>The height value for interface discovery is specified in <em>height above mean sea level</em>! This is the geoid-corrected height value, and is distinct from GPS altitude. If you manually specify height, it will typically be set to what you find on a topographical map. If you are using a script to output the location data, make sure that you are using the geoid-corrected altitude, not height above the GPS ellipsoid. Most GPS systems will make both figures available.</p>
+</div>
 <p><strong>Radio Parameters</strong></p>
 <p>For physical radio interfaces like <code class="docutils literal notranslate"><span class="pre">RNodeInterface</span></code> or <code class="docutils literal notranslate"><span class="pre">KISSInterface</span></code>, the following optional parameters allow you to broadcast the operating frequency and characteristics, allowing clients to verify compatibility before connecting:</p>
 <dl class="simple">
@@ -1767,6 +1814,7 @@ interface basis under the relevant interface configuration section.</p>
 <li><a class="reference internal" href="#backbone-interface">Backbone Interface</a><ul>
 <li><a class="reference internal" href="#listeners">Listeners</a></li>
 <li><a class="reference internal" href="#connecting-remotes">Connecting Remotes</a></li>
+<li><a class="reference internal" href="#automated-blocking">Automated Blocking</a></li>
 </ul>
 </li>
 <li><a class="reference internal" href="#tcp-server-interface">TCP Server Interface</a></li>
@@ -1803,7 +1851,7 @@ interface basis under the relevant interface configuration section.</p>
       
     </aside>
   </div>
-</div><script src="_static/documentation_options.js?v=70d8fd07"></script>
+</div><script src="_static/documentation_options.js?v=98c25ec5"></script>
     <script src="_static/doctools.js?v=9bcbadda"></script>
     <script src="_static/sphinx_highlight.js?v=dc90522c"></script>
     <script src="_static/scripts/furo.js?v=46bd48cc"></script>

docs/manual/license.html

@@ -7,7 +7,7 @@
         <link rel="prefetch" href="_static/rns_logo_512.png" as="image">
 
     <!-- Generated with Sphinx 8.2.3 and Furo 2025.09.25.dev1 -->
-        <title>Reticulum License - Reticulum Network Stack 1.3.6 documentation</title>
+        <title>Reticulum License - Reticulum Network Stack 1.3.9 documentation</title>
       <link rel="stylesheet" type="text/css" href="_static/pygments.css?v=d111a655" />
     <link rel="stylesheet" type="text/css" href="_static/styles/furo.css?v=580074bf" />
     <link rel="stylesheet" type="text/css" href="_static/copybutton.css?v=76b2166b" />
@@ -180,7 +180,7 @@
       </label>
     </div>
     <div class="header-center">
-      <a href="index.html"><div class="brand">Reticulum Network Stack 1.3.6 documentation</div></a>
+      <a href="index.html"><div class="brand">Reticulum Network Stack 1.3.9 documentation</div></a>
     </div>
     <div class="header-right">
       <div class="theme-toggle-container theme-toggle-header">
@@ -204,7 +204,7 @@
     <img class="sidebar-logo" src="_static/rns_logo_512.png" alt="Logo"/>
   </div>
   
-  <span class="sidebar-brand-text">Reticulum Network Stack 1.3.6 documentation</span>
+  <span class="sidebar-brand-text">Reticulum Network Stack 1.3.9 documentation</span>
   
 </a><form class="sidebar-search-container" method="get" action="search.html" role="search">
   <input class="sidebar-search" placeholder="Search" name="q" aria-label="Search">
@@ -345,7 +345,7 @@ SOFTWARE.
       
     </aside>
   </div>
-</div><script src="_static/documentation_options.js?v=70d8fd07"></script>
+</div><script src="_static/documentation_options.js?v=98c25ec5"></script>
     <script src="_static/doctools.js?v=9bcbadda"></script>
     <script src="_static/sphinx_highlight.js?v=dc90522c"></script>
     <script src="_static/scripts/furo.js?v=46bd48cc"></script>

docs/manual/networks.html

@@ -7,7 +7,7 @@
         <link rel="prefetch" href="_static/rns_logo_512.png" as="image">
 
     <!-- Generated with Sphinx 8.2.3 and Furo 2025.09.25.dev1 -->
-        <title>Building Networks - Reticulum Network Stack 1.3.6 documentation</title>
+        <title>Building Networks - Reticulum Network Stack 1.3.9 documentation</title>
       <link rel="stylesheet" type="text/css" href="_static/pygments.css?v=d111a655" />
     <link rel="stylesheet" type="text/css" href="_static/styles/furo.css?v=580074bf" />
     <link rel="stylesheet" type="text/css" href="_static/copybutton.css?v=76b2166b" />
@@ -180,7 +180,7 @@
       </label>
     </div>
     <div class="header-center">
-      <a href="index.html"><div class="brand">Reticulum Network Stack 1.3.6 documentation</div></a>
+      <a href="index.html"><div class="brand">Reticulum Network Stack 1.3.9 documentation</div></a>
     </div>
     <div class="header-right">
       <div class="theme-toggle-container theme-toggle-header">
@@ -204,7 +204,7 @@
     <img class="sidebar-logo" src="_static/rns_logo_512.png" alt="Logo"/>
   </div>
   
-  <span class="sidebar-brand-text">Reticulum Network Stack 1.3.6 documentation</span>
+  <span class="sidebar-brand-text">Reticulum Network Stack 1.3.9 documentation</span>
   
 </a><form class="sidebar-search-container" method="get" action="search.html" role="search">
   <input class="sidebar-search" placeholder="Search" name="q" aria-label="Search">
@@ -664,7 +664,7 @@ differently than a mobile device roaming between radio cells.</p>
       
     </aside>
   </div>
-</div><script src="_static/documentation_options.js?v=70d8fd07"></script>
+</div><script src="_static/documentation_options.js?v=98c25ec5"></script>
     <script src="_static/doctools.js?v=9bcbadda"></script>
     <script src="_static/sphinx_highlight.js?v=dc90522c"></script>
     <script src="_static/scripts/furo.js?v=46bd48cc"></script>

docs/manual/reference.html

@@ -7,7 +7,7 @@
         <link rel="prefetch" href="_static/rns_logo_512.png" as="image">
 
     <!-- Generated with Sphinx 8.2.3 and Furo 2025.09.25.dev1 -->
-        <title>API Reference - Reticulum Network Stack 1.3.6 documentation</title>
+        <title>API Reference - Reticulum Network Stack 1.3.9 documentation</title>
       <link rel="stylesheet" type="text/css" href="_static/pygments.css?v=d111a655" />
     <link rel="stylesheet" type="text/css" href="_static/styles/furo.css?v=580074bf" />
     <link rel="stylesheet" type="text/css" href="_static/copybutton.css?v=76b2166b" />
@@ -180,7 +180,7 @@
       </label>
     </div>
     <div class="header-center">
-      <a href="index.html"><div class="brand">Reticulum Network Stack 1.3.6 documentation</div></a>
+      <a href="index.html"><div class="brand">Reticulum Network Stack 1.3.9 documentation</div></a>
     </div>
     <div class="header-right">
       <div class="theme-toggle-container theme-toggle-header">
@@ -204,7 +204,7 @@
     <img class="sidebar-logo" src="_static/rns_logo_512.png" alt="Logo"/>
   </div>
   
-  <span class="sidebar-brand-text">Reticulum Network Stack 1.3.6 documentation</span>
+  <span class="sidebar-brand-text">Reticulum Network Stack 1.3.9 documentation</span>
   
 </a><form class="sidebar-search-container" method="get" action="search.html" role="search">
   <input class="sidebar-search" placeholder="Search" name="q" aria-label="Search">
@@ -2519,7 +2519,7 @@ will announce it.</p>
       
     </aside>
   </div>
-</div><script src="_static/documentation_options.js?v=70d8fd07"></script>
+</div><script src="_static/documentation_options.js?v=98c25ec5"></script>
     <script src="_static/doctools.js?v=9bcbadda"></script>
     <script src="_static/sphinx_highlight.js?v=dc90522c"></script>
     <script src="_static/scripts/furo.js?v=46bd48cc"></script>

docs/manual/search.html

@@ -8,7 +8,7 @@
 
     <!-- Generated with Sphinx 8.2.3 and Furo 2025.09.25.dev1 -->
 <meta name="robots" content="noindex" />
-<title>Search - Reticulum Network Stack 1.3.6 documentation</title><link rel="stylesheet" type="text/css" href="_static/pygments.css?v=d111a655" />
+<title>Search - Reticulum Network Stack 1.3.9 documentation</title><link rel="stylesheet" type="text/css" href="_static/pygments.css?v=d111a655" />
     <link rel="stylesheet" type="text/css" href="_static/styles/furo.css?v=580074bf" />
     <link rel="stylesheet" type="text/css" href="_static/copybutton.css?v=76b2166b" />
     <link rel="stylesheet" type="text/css" href="_static/styles/furo-extensions.css?v=8dab3a3b" />
@@ -180,7 +180,7 @@
       </label>
     </div>
     <div class="header-center">
-      <a href="index.html"><div class="brand">Reticulum Network Stack 1.3.6 documentation</div></a>
+      <a href="index.html"><div class="brand">Reticulum Network Stack 1.3.9 documentation</div></a>
     </div>
     <div class="header-right">
       <div class="theme-toggle-container theme-toggle-header">
@@ -204,7 +204,7 @@
     <img class="sidebar-logo" src="_static/rns_logo_512.png" alt="Logo"/>
   </div>
   
-  <span class="sidebar-brand-text">Reticulum Network Stack 1.3.6 documentation</span>
+  <span class="sidebar-brand-text">Reticulum Network Stack 1.3.9 documentation</span>
   
 </a><form class="sidebar-search-container" method="get" action="#" role="search">
   <input class="sidebar-search" placeholder="Search" name="q" aria-label="Search">
@@ -304,7 +304,7 @@
       
     </aside>
   </div>
-</div><script src="_static/documentation_options.js?v=70d8fd07"></script>
+</div><script src="_static/documentation_options.js?v=98c25ec5"></script>
     <script src="_static/doctools.js?v=9bcbadda"></script>
     <script src="_static/sphinx_highlight.js?v=dc90522c"></script>
     <script src="_static/scripts/furo.js?v=46bd48cc"></script>

docs/manual/software.html

@@ -7,7 +7,7 @@
         <link rel="prefetch" href="_static/rns_logo_512.png" as="image">
 
     <!-- Generated with Sphinx 8.2.3 and Furo 2025.09.25.dev1 -->
-        <title>Programs Using Reticulum - Reticulum Network Stack 1.3.6 documentation</title>
+        <title>Programs Using Reticulum - Reticulum Network Stack 1.3.9 documentation</title>
       <link rel="stylesheet" type="text/css" href="_static/pygments.css?v=d111a655" />
     <link rel="stylesheet" type="text/css" href="_static/styles/furo.css?v=580074bf" />
     <link rel="stylesheet" type="text/css" href="_static/copybutton.css?v=76b2166b" />
@@ -180,7 +180,7 @@
       </label>
     </div>
     <div class="header-center">
-      <a href="index.html"><div class="brand">Reticulum Network Stack 1.3.6 documentation</div></a>
+      <a href="index.html"><div class="brand">Reticulum Network Stack 1.3.9 documentation</div></a>
     </div>
     <div class="header-right">
       <div class="theme-toggle-container theme-toggle-header">
@@ -204,7 +204,7 @@
     <img class="sidebar-logo" src="_static/rns_logo_512.png" alt="Logo"/>
   </div>
   
-  <span class="sidebar-brand-text">Reticulum Network Stack 1.3.6 documentation</span>
+  <span class="sidebar-brand-text">Reticulum Network Stack 1.3.9 documentation</span>
   
 </a><form class="sidebar-search-container" method="get" action="search.html" role="search">
   <input class="sidebar-search" placeholder="Search" name="q" aria-label="Search">
@@ -513,7 +513,7 @@ plugin system for expandability.</p>
       
     </aside>
   </div>
-</div><script src="_static/documentation_options.js?v=70d8fd07"></script>
+</div><script src="_static/documentation_options.js?v=98c25ec5"></script>
     <script src="_static/doctools.js?v=9bcbadda"></script>
     <script src="_static/sphinx_highlight.js?v=dc90522c"></script>
     <script src="_static/scripts/furo.js?v=46bd48cc"></script>

docs/manual/support.html

@@ -7,7 +7,7 @@
         <link rel="prefetch" href="_static/rns_logo_512.png" as="image">
 
     <!-- Generated with Sphinx 8.2.3 and Furo 2025.09.25.dev1 -->
-        <title>Support Reticulum - Reticulum Network Stack 1.3.6 documentation</title>
+        <title>Support Reticulum - Reticulum Network Stack 1.3.9 documentation</title>
       <link rel="stylesheet" type="text/css" href="_static/pygments.css?v=d111a655" />
     <link rel="stylesheet" type="text/css" href="_static/styles/furo.css?v=580074bf" />
     <link rel="stylesheet" type="text/css" href="_static/copybutton.css?v=76b2166b" />
@@ -180,7 +180,7 @@
       </label>
     </div>
     <div class="header-center">
-      <a href="index.html"><div class="brand">Reticulum Network Stack 1.3.6 documentation</div></a>
+      <a href="index.html"><div class="brand">Reticulum Network Stack 1.3.9 documentation</div></a>
     </div>
     <div class="header-right">
       <div class="theme-toggle-container theme-toggle-header">
@@ -204,7 +204,7 @@
     <img class="sidebar-logo" src="_static/rns_logo_512.png" alt="Logo"/>
   </div>
   
-  <span class="sidebar-brand-text">Reticulum Network Stack 1.3.6 documentation</span>
+  <span class="sidebar-brand-text">Reticulum Network Stack 1.3.9 documentation</span>
   
 </a><form class="sidebar-search-container" method="get" action="search.html" role="search">
   <input class="sidebar-search" placeholder="Search" name="q" aria-label="Search">
@@ -383,7 +383,7 @@ circumstances, so we rely on old-fashioned human feedback.</p>
       
     </aside>
   </div>
-</div><script src="_static/documentation_options.js?v=70d8fd07"></script>
+</div><script src="_static/documentation_options.js?v=98c25ec5"></script>
     <script src="_static/doctools.js?v=9bcbadda"></script>
     <script src="_static/sphinx_highlight.js?v=dc90522c"></script>
     <script src="_static/scripts/furo.js?v=46bd48cc"></script>

docs/manual/understanding.html

@@ -7,7 +7,7 @@
         <link rel="prefetch" href="_static/rns_logo_512.png" as="image">
 
     <!-- Generated with Sphinx 8.2.3 and Furo 2025.09.25.dev1 -->
-        <title>Understanding Reticulum - Reticulum Network Stack 1.3.6 documentation</title>
+        <title>Understanding Reticulum - Reticulum Network Stack 1.3.9 documentation</title>
       <link rel="stylesheet" type="text/css" href="_static/pygments.css?v=d111a655" />
     <link rel="stylesheet" type="text/css" href="_static/styles/furo.css?v=580074bf" />
     <link rel="stylesheet" type="text/css" href="_static/copybutton.css?v=76b2166b" />
@@ -180,7 +180,7 @@
       </label>
     </div>
     <div class="header-center">
-      <a href="index.html"><div class="brand">Reticulum Network Stack 1.3.6 documentation</div></a>
+      <a href="index.html"><div class="brand">Reticulum Network Stack 1.3.9 documentation</div></a>
     </div>
     <div class="header-right">
       <div class="theme-toggle-container theme-toggle-header">
@@ -204,7 +204,7 @@
     <img class="sidebar-logo" src="_static/rns_logo_512.png" alt="Logo"/>
   </div>
   
-  <span class="sidebar-brand-text">Reticulum Network Stack 1.3.6 documentation</span>
+  <span class="sidebar-brand-text">Reticulum Network Stack 1.3.9 documentation</span>
   
 </a><form class="sidebar-search-container" method="get" action="search.html" role="search">
   <input class="sidebar-search" placeholder="Search" name="q" aria-label="Search">
@@ -1118,7 +1118,7 @@ those risks are acceptable to you.</p>
       
     </aside>
   </div>
-</div><script src="_static/documentation_options.js?v=70d8fd07"></script>
+</div><script src="_static/documentation_options.js?v=98c25ec5"></script>
     <script src="_static/doctools.js?v=9bcbadda"></script>
     <script src="_static/sphinx_highlight.js?v=dc90522c"></script>
     <script src="_static/scripts/furo.js?v=46bd48cc"></script>

docs/manual/using.html

@@ -7,7 +7,7 @@
         <link rel="prefetch" href="_static/rns_logo_512.png" as="image">
 
     <!-- Generated with Sphinx 8.2.3 and Furo 2025.09.25.dev1 -->
-        <title>Using Reticulum on Your System - Reticulum Network Stack 1.3.6 documentation</title>
+        <title>Using Reticulum on Your System - Reticulum Network Stack 1.3.9 documentation</title>
       <link rel="stylesheet" type="text/css" href="_static/pygments.css?v=d111a655" />
     <link rel="stylesheet" type="text/css" href="_static/styles/furo.css?v=580074bf" />
     <link rel="stylesheet" type="text/css" href="_static/copybutton.css?v=76b2166b" />
@@ -180,7 +180,7 @@
       </label>
     </div>
     <div class="header-center">
-      <a href="index.html"><div class="brand">Reticulum Network Stack 1.3.6 documentation</div></a>
+      <a href="index.html"><div class="brand">Reticulum Network Stack 1.3.9 documentation</div></a>
     </div>
     <div class="header-right">
       <div class="theme-toggle-container theme-toggle-header">
@@ -204,7 +204,7 @@
     <img class="sidebar-logo" src="_static/rns_logo_512.png" alt="Logo"/>
   </div>
   
-  <span class="sidebar-brand-text">Reticulum Network Stack 1.3.6 documentation</span>
+  <span class="sidebar-brand-text">Reticulum Network Stack 1.3.9 documentation</span>
   
 </a><form class="sidebar-search-container" method="get" action="search.html" role="search">
   <input class="sidebar-search" placeholder="Search" name="q" aria-label="Search">
@@ -1106,39 +1106,35 @@ positional arguments:
   destination           hexadecimal hash of the destination to connect to
 
 options:
-  -h, --help            show this help message and exit
-  --config, -c CONFIG   path to alternative Reticulum config directory
-  --identity, -i IDENTITY
-                        path to identity file to use
-  -v, --verbose         increase verbosity
-  -q, --quiet           decrease verbosity
-  -p, --print-identity  print identity and destination info and exit
-  --version             show program&#39;s version number and exit
-  -l, --listen          listen (server) mode; any command specified after --
-                        will be used as the default command when the initiator
-                        does not provide one or when remote command execution
-                        is disabled; if no command is specified, the default
-                        shell of the user running rnsh will be used
-  -s, --service SERVICE
-                        service name for identity file if not the default
-  -b, --announce PERIOD
-                        announce on startup and every PERIOD seconds; specify
-                        0 to announce on startup only
-  -a, --allowed HASH    allow this identity to connect (may be specified
-                        multiple times); allowed identities can also be
-                        specified in ~/.rnsh/allowed_identities or
-                        ~/.config/rnsh/allowed_identities, one hash per line
-  -n, --no-auth         disable authentication (allow any identity to connect)
+  -h, --help              show this help message and exit
+  --config, -c PATH       path to config directory
+  --rnsconfig, -c PATH    path to alternative Reticulum config directory
+  --identity, -i IDENTITY path to identity file to use
+  -v, --verbose           increase verbosity
+  -q, --quiet             decrease verbosity
+  -p, --print-identity    print identity and destination info and exit
+  --version               show program&#39;s version number and exit
+  -l, --listen            listen (server) mode; any command specified after --
+                          will be used as the default command when the initiator
+                          does not provide one or when remote command execution
+                          is disabled; if no command is specified, the default
+                          shell of the user running rnsh will be used
+  -s, --service SERVICE   service name for identity file if not the default
+  -b, --announce PERIOD   announce on startup and every PERIOD seconds; specify
+                          0 to announce on startup only
+  -a, --allowed HASH      allow this identity to connect (may be specified
+                          multiple times); allowed identities can also be
+                          specified in ~/.rnsh/allowed_identities or
+                          ~/.config/rnsh/allowed_identities, one hash per line
+  -n, --no-auth           disable authentication (allow any identity to connect)
   -A, --remote-command-as-args
-                        concatenate remote command to the argument list of the
-                        default program or shell
-  -C, --no-remote-command
-                        disable executing command lines received from the
-                        remote initiator
-  -N, --no-id           disable identity announcement on connect
-  -m, --mirror          return with the exit code of the remote process
-  -w, --timeout SECONDS
-                        connect and request timeout in seconds
+                          concatenate remote command to the argument list of the
+                          default program or shell
+  -C, --no-remote-command disable executing command lines received from the
+                          remote initiator
+  -N, --no-id             disable identity announcement on connect
+  -m, --mirror            return with the exit code of the remote process
+  -w, --timeout SECONDS   connect and request timeout in seconds
 
 When specifying a command to execute, separate rnsh options from the command
 and its arguments with --. For example:
@@ -1639,7 +1635,7 @@ systemctl --user enable rnsd.service
       
     </aside>
   </div>
-</div><script src="_static/documentation_options.js?v=70d8fd07"></script>
+</div><script src="_static/documentation_options.js?v=98c25ec5"></script>
     <script src="_static/doctools.js?v=9bcbadda"></script>
     <script src="_static/sphinx_highlight.js?v=dc90522c"></script>
     <script src="_static/scripts/furo.js?v=46bd48cc"></script>

docs/manual/whatis.html

@@ -7,7 +7,7 @@
         <link rel="prefetch" href="_static/rns_logo_512.png" as="image">
 
     <!-- Generated with Sphinx 8.2.3 and Furo 2025.09.25.dev1 -->
-        <title>What is Reticulum? - Reticulum Network Stack 1.3.6 documentation</title>
+        <title>What is Reticulum? - Reticulum Network Stack 1.3.9 documentation</title>
       <link rel="stylesheet" type="text/css" href="_static/pygments.css?v=d111a655" />
     <link rel="stylesheet" type="text/css" href="_static/styles/furo.css?v=580074bf" />
     <link rel="stylesheet" type="text/css" href="_static/copybutton.css?v=76b2166b" />
@@ -180,7 +180,7 @@
       </label>
     </div>
     <div class="header-center">
-      <a href="index.html"><div class="brand">Reticulum Network Stack 1.3.6 documentation</div></a>
+      <a href="index.html"><div class="brand">Reticulum Network Stack 1.3.9 documentation</div></a>
     </div>
     <div class="header-right">
       <div class="theme-toggle-container theme-toggle-header">
@@ -204,7 +204,7 @@
     <img class="sidebar-logo" src="_static/rns_logo_512.png" alt="Logo"/>
   </div>
   
-  <span class="sidebar-brand-text">Reticulum Network Stack 1.3.6 documentation</span>
+  <span class="sidebar-brand-text">Reticulum Network Stack 1.3.9 documentation</span>
   
 </a><form class="sidebar-search-container" method="get" action="search.html" role="search">
   <input class="sidebar-search" placeholder="Search" name="q" aria-label="Search">
@@ -505,7 +505,7 @@ network, and vice versa.</p>
       
     </aside>
   </div>
-</div><script src="_static/documentation_options.js?v=70d8fd07"></script>
+</div><script src="_static/documentation_options.js?v=98c25ec5"></script>
     <script src="_static/doctools.js?v=9bcbadda"></script>
     <script src="_static/sphinx_highlight.js?v=dc90522c"></script>
     <script src="_static/scripts/furo.js?v=46bd48cc"></script>

docs/manual/zen.html

@@ -7,7 +7,7 @@
         <link rel="prefetch" href="_static/rns_logo_512.png" as="image">
 
     <!-- Generated with Sphinx 8.2.3 and Furo 2025.09.25.dev1 -->
-        <title>Zen of Reticulum - Reticulum Network Stack 1.3.6 documentation</title>
+        <title>Zen of Reticulum - Reticulum Network Stack 1.3.9 documentation</title>
       <link rel="stylesheet" type="text/css" href="_static/pygments.css?v=d111a655" />
     <link rel="stylesheet" type="text/css" href="_static/styles/furo.css?v=580074bf" />
     <link rel="stylesheet" type="text/css" href="_static/copybutton.css?v=76b2166b" />
@@ -180,7 +180,7 @@
       </label>
     </div>
     <div class="header-center">
-      <a href="index.html"><div class="brand">Reticulum Network Stack 1.3.6 documentation</div></a>
+      <a href="index.html"><div class="brand">Reticulum Network Stack 1.3.9 documentation</div></a>
     </div>
     <div class="header-right">
       <div class="theme-toggle-container theme-toggle-header">
@@ -204,7 +204,7 @@
     <img class="sidebar-logo" src="_static/rns_logo_512.png" alt="Logo"/>
   </div>
   
-  <span class="sidebar-brand-text">Reticulum Network Stack 1.3.6 documentation</span>
+  <span class="sidebar-brand-text">Reticulum Network Stack 1.3.9 documentation</span>
   
 </a><form class="sidebar-search-container" method="get" action="search.html" role="search">
   <input class="sidebar-search" placeholder="Search" name="q" aria-label="Search">
@@ -677,7 +677,7 @@ Imagine a messaging app. You write it once. It works on a laptop connected to fi
       
     </aside>
   </div>
-</div><script src="_static/documentation_options.js?v=70d8fd07"></script>
+</div><script src="_static/documentation_options.js?v=98c25ec5"></script>
     <script src="_static/doctools.js?v=9bcbadda"></script>
     <script src="_static/sphinx_highlight.js?v=dc90522c"></script>
     <script src="_static/scripts/furo.js?v=46bd48cc"></script>

docs/markdown/index.md

@@ -161,6 +161,7 @@ to participate in the development of Reticulum itself.
   * [Backbone Interface](interfaces.md#backbone-interface)
     * [Listeners](interfaces.md#listeners)
     * [Connecting Remotes](interfaces.md#connecting-remotes)
+    * [Automated Blocking](interfaces.md#automated-blocking)
   * [TCP Server Interface](interfaces.md#tcp-server-interface)
   * [TCP Client Interface](interfaces.md#tcp-client-interface)
   * [UDP Interface](interfaces.md#udp-interface)

docs/markdown/interfaces.md

@@ -212,6 +212,51 @@ specify the target Yggdrasil IPv6 address and port, like so:
     target_port = 4343
 ```
 
+### Automated Blocking
+
+Listener instances of `BackboneInterface` will automatically block fast-flapping clients,
+that repeatedly connect for a short amount of time, and then disconnect. Such behavior usually
+occurs from clients trying to spam the network with announces or path requests, by connecting, dumping
+a massive amount of requests, and then disconnecting in an attempt to bypass rate limits.
+
+While such bypass attempts only have very limited effect on the amount of spam actually dumped (ingress limits
+trigger immediately once a client exceeds rate limits), the behavior is often seen anyways, and
+causes log noise and needless interface rotation. The fast-flapping block ensures such clients
+are never allocated an interface on the transport instance.
+
+Another common cause can simply be clients using implementations that are broken, or automated
+scanning tools attempting to connect to the instance.
+
+```ini
+[[Backbone Listener]]
+  type = BackboneInterface
+  enabled = yes
+  listen_on = 0.0.0.0
+  port = 4242
+
+  # Whether to enable blocking
+  block_fast_flapping = yes
+
+  # How long an IP address stays
+  # blocked, in minutes. Set to
+  # 12 hours by default.
+  fast_flapping_block_time = 720
+
+  # The minimum time, in seconds,
+  # an interface must stay connected
+  # to be considered not fast-flapping.
+  fast_flapping_threshold = 20
+
+  # Amount of fast flaps a remote
+  # IP can perform before having
+  # blocking triggered.
+  fast_flapping_grace = 5
+```
+
+The configuration options listed in the example above are the *default values*, and you do
+not need to add them for automated blocking to work, but you can use them to change the
+behavior from the defaults, if necessary.
+
 ## TCP Server Interface
 
 The TCP Server interface is suitable for allowing other peers to connect over
@@ -939,7 +984,13 @@ If you enable `discovery_encrypt` but do not configure a valid `network_identity
 **Physical Location**
 
 `latitude`, `longitude`, `height`
-: Optional physical coordinates for the interface. These are useful for mapping discovered interfaces geographically or for clients to automatically select the nearest access point. Coordinates should be in decimal degrees, height in meters.
+: Optional physical coordinates for the interface. These are useful for mapping discovered interfaces geographically or for clients to automatically select the nearest access point. Coordinates should be in decimal degrees, height in meters above mean sea level.
+
+`location_cmd`
+: Optional path to executable or script that returns the physical coordinates for the interface. This can be used instead of manually setting `latitude`, `longitude` and `height`. Reticulum expects the script to output the location data to `stdout` on a single line, separated by commas, with values as floating point numbers in the format `LAT, LON, HEIGHT`. Coordinates should be in decimal degrees, height in meters above mean sea level.
+
+#### NOTE
+The height value for interface discovery is specified in *height above mean sea level*! This is the geoid-corrected height value, and is distinct from GPS altitude. If you manually specify height, it will typically be set to what you find on a topographical map. If you are using a script to output the location data, make sure that you are using the geoid-corrected altitude, not height above the GPS ellipsoid. Most GPS systems will make both figures available.
 
 **Radio Parameters**
 

docs/markdown/using.md

@@ -965,39 +965,35 @@ positional arguments:
   destination           hexadecimal hash of the destination to connect to
 
 options:
-  -h, --help            show this help message and exit
-  --config, -c CONFIG   path to alternative Reticulum config directory
-  --identity, -i IDENTITY
-                        path to identity file to use
-  -v, --verbose         increase verbosity
-  -q, --quiet           decrease verbosity
-  -p, --print-identity  print identity and destination info and exit
-  --version             show program's version number and exit
-  -l, --listen          listen (server) mode; any command specified after --
-                        will be used as the default command when the initiator
-                        does not provide one or when remote command execution
-                        is disabled; if no command is specified, the default
-                        shell of the user running rnsh will be used
-  -s, --service SERVICE
-                        service name for identity file if not the default
-  -b, --announce PERIOD
-                        announce on startup and every PERIOD seconds; specify
-                        0 to announce on startup only
-  -a, --allowed HASH    allow this identity to connect (may be specified
-                        multiple times); allowed identities can also be
-                        specified in ~/.rnsh/allowed_identities or
-                        ~/.config/rnsh/allowed_identities, one hash per line
-  -n, --no-auth         disable authentication (allow any identity to connect)
+  -h, --help              show this help message and exit
+  --config, -c PATH       path to config directory
+  --rnsconfig, -c PATH    path to alternative Reticulum config directory
+  --identity, -i IDENTITY path to identity file to use
+  -v, --verbose           increase verbosity
+  -q, --quiet             decrease verbosity
+  -p, --print-identity    print identity and destination info and exit
+  --version               show program's version number and exit
+  -l, --listen            listen (server) mode; any command specified after --
+                          will be used as the default command when the initiator
+                          does not provide one or when remote command execution
+                          is disabled; if no command is specified, the default
+                          shell of the user running rnsh will be used
+  -s, --service SERVICE   service name for identity file if not the default
+  -b, --announce PERIOD   announce on startup and every PERIOD seconds; specify
+                          0 to announce on startup only
+  -a, --allowed HASH      allow this identity to connect (may be specified
+                          multiple times); allowed identities can also be
+                          specified in ~/.rnsh/allowed_identities or
+                          ~/.config/rnsh/allowed_identities, one hash per line
+  -n, --no-auth           disable authentication (allow any identity to connect)
   -A, --remote-command-as-args
-                        concatenate remote command to the argument list of the
-                        default program or shell
-  -C, --no-remote-command
-                        disable executing command lines received from the
-                        remote initiator
-  -N, --no-id           disable identity announcement on connect
-  -m, --mirror          return with the exit code of the remote process
-  -w, --timeout SECONDS
-                        connect and request timeout in seconds
+                          concatenate remote command to the argument list of the
+                          default program or shell
+  -C, --no-remote-command disable executing command lines received from the
+                          remote initiator
+  -N, --no-id             disable identity announcement on connect
+  -m, --mirror            return with the exit code of the remote process
+  -w, --timeout SECONDS   connect and request timeout in seconds
 
 When specifying a command to execute, separate rnsh options from the command
 and its arguments with --. For example:

docs/source/interfaces.rst

@@ -230,6 +230,51 @@ specify the target Yggdrasil IPv6 address and port, like so:
       target_host = 201:5d78:af73:5caf:a4de:a79f:3278:71e5
       target_port = 4343
 
+Automated Blocking
+------------------
+Listener instances of ``BackboneInterface`` will automatically block fast-flapping clients,
+that repeatedly connect for a short amount of time, and then disconnect. Such behavior usually
+occurs from clients trying to spam the network with announces or path requests, by connecting, dumping
+a massive amount of requests, and then disconnecting in an attempt to bypass rate limits.
+
+While such bypass attempts only have very limited effect on the amount of spam actually dumped (ingress limits
+trigger immediately once a client exceeds rate limits), the behavior is often seen anyways, and
+causes log noise and needless interface rotation. The fast-flapping block ensures such clients
+are never allocated an interface on the transport instance.
+
+Another common cause can simply be clients using implementations that are broken, or automated
+scanning tools attempting to connect to the instance.
+
+.. code:: ini
+
+  [[Backbone Listener]]
+    type = BackboneInterface
+    enabled = yes    
+    listen_on = 0.0.0.0
+    port = 4242
+
+    # Whether to enable blocking
+    block_fast_flapping = yes
+
+    # How long an IP address stays
+    # blocked, in minutes. Set to
+    # 12 hours by default.
+    fast_flapping_block_time = 720
+
+    # The minimum time, in seconds,
+    # an interface must stay connected
+    # to be considered not fast-flapping.
+    fast_flapping_threshold = 20
+
+    # Amount of fast flaps a remote
+    # IP can perform before having
+    # blocking triggered.
+    fast_flapping_grace = 5
+
+The configuration options listed in the example above are the *default values*, and you do
+not need to add them for automated blocking to work, but you can use them to change the
+behavior from the defaults, if necessary.
+
 .. _interfaces-tcps:
 
 TCP Server Interface
@@ -998,7 +1043,13 @@ On a real system, you should make the script robust enough to deal with intermit
 **Physical Location**
 
 ``latitude``, ``longitude``, ``height``
-  Optional physical coordinates for the interface. These are useful for mapping discovered interfaces geographically or for clients to automatically select the nearest access point. Coordinates should be in decimal degrees, height in meters.
+  Optional physical coordinates for the interface. These are useful for mapping discovered interfaces geographically or for clients to automatically select the nearest access point. Coordinates should be in decimal degrees, height in meters above mean sea level.
+
+``location_cmd``
+  Optional path to executable or script that returns the physical coordinates for the interface. This can be used instead of manually setting ``latitude``, ``longitude`` and ``height``. Reticulum expects the script to output the location data to ``stdout`` on a single line, separated by commas, with values as floating point numbers in the format ``LAT, LON, HEIGHT``. Coordinates should be in decimal degrees, height in meters above mean sea level.
+
+.. note::
+   The height value for interface discovery is specified in *height above mean sea level*! This is the geoid-corrected height value, and is distinct from GPS altitude. If you manually specify height, it will typically be set to what you find on a topographical map. If you are using a script to output the location data, make sure that you are using the geoid-corrected altitude, not height above the GPS ellipsoid. Most GPS systems will make both figures available.
 
 **Radio Parameters**
 

docs/source/using.rst

@@ -1002,39 +1002,35 @@ available. These are only recognised immediately after a newline character:
     destination           hexadecimal hash of the destination to connect to
 
   options:
-    -h, --help            show this help message and exit
-    --config, -c CONFIG   path to alternative Reticulum config directory
-    --identity, -i IDENTITY
-                          path to identity file to use
-    -v, --verbose         increase verbosity
-    -q, --quiet           decrease verbosity
-    -p, --print-identity  print identity and destination info and exit
-    --version             show program's version number and exit
-    -l, --listen          listen (server) mode; any command specified after --
-                          will be used as the default command when the initiator
-                          does not provide one or when remote command execution
-                          is disabled; if no command is specified, the default
-                          shell of the user running rnsh will be used
-    -s, --service SERVICE
-                          service name for identity file if not the default
-    -b, --announce PERIOD
-                          announce on startup and every PERIOD seconds; specify
-                          0 to announce on startup only
-    -a, --allowed HASH    allow this identity to connect (may be specified
-                          multiple times); allowed identities can also be
-                          specified in ~/.rnsh/allowed_identities or
-                          ~/.config/rnsh/allowed_identities, one hash per line
-    -n, --no-auth         disable authentication (allow any identity to connect)
+    -h, --help              show this help message and exit
+    --config, -c PATH       path to config directory
+    --rnsconfig, -c PATH    path to alternative Reticulum config directory
+    --identity, -i IDENTITY path to identity file to use
+    -v, --verbose           increase verbosity
+    -q, --quiet             decrease verbosity
+    -p, --print-identity    print identity and destination info and exit
+    --version               show program's version number and exit
+    -l, --listen            listen (server) mode; any command specified after --
+                            will be used as the default command when the initiator
+                            does not provide one or when remote command execution
+                            is disabled; if no command is specified, the default
+                            shell of the user running rnsh will be used
+    -s, --service SERVICE   service name for identity file if not the default
+    -b, --announce PERIOD   announce on startup and every PERIOD seconds; specify
+                            0 to announce on startup only
+    -a, --allowed HASH      allow this identity to connect (may be specified
+                            multiple times); allowed identities can also be
+                            specified in ~/.rnsh/allowed_identities or
+                            ~/.config/rnsh/allowed_identities, one hash per line
+    -n, --no-auth           disable authentication (allow any identity to connect)
     -A, --remote-command-as-args
-                          concatenate remote command to the argument list of the
-                          default program or shell
-    -C, --no-remote-command
-                          disable executing command lines received from the
-                          remote initiator
-    -N, --no-id           disable identity announcement on connect
-    -m, --mirror          return with the exit code of the remote process
-    -w, --timeout SECONDS
-                          connect and request timeout in seconds
+                            concatenate remote command to the argument list of the
+                            default program or shell
+    -C, --no-remote-command disable executing command lines received from the
+                            remote initiator
+    -N, --no-id             disable identity announcement on connect
+    -m, --mirror            return with the exit code of the remote process
+    -w, --timeout SECONDS   connect and request timeout in seconds
 
   When specifying a command to execute, separate rnsh options from the command
   and its arguments with --. For example: