Updated manual

Fixed Hop-number in docs

README.md

@@ -62,6 +62,11 @@ For more info, see [unsigned.io/projects/reticulum](https://unsigned.io/projects
   - Total bandwidth cost of setting up an encrypted link is 3 packets totaling 297 bytes
   - Low cost of keeping links open at only 0.44 bits per second
 
+## Development Roadmap
+While Reticulum is already a fully featured and functional networking stack, many improvements and additions are planned for the future.
+
+To learn more about the direction and future of Reticulum, please see the [Development Roadmap](./Roadmap.md).
+
 ## Examples of Reticulum Applications
 If you want to quickly get an idea of what Reticulum can do, take a look at the
 following resources.
@@ -177,39 +182,6 @@ features are implemented and functioning, but additions will probably occur as
 real-world use is explored. There will be bugs. The API and wire-format can be
 considered relatively stable at the moment, but could change if warranted.
 
-## Development Roadmap
-- Version 0.4.0
-  - Improving [the manual](https://markqvist.github.io/Reticulum/manual/) with sections specifically for beginners
-  - Performance and memory optimisations
-  - Utilities for managing identities, signing and encryption
-  - User friendly interface configuration tool
-  - More interface types for even broader compatibility
-    - Plain ESP32 devices (ESP-Now, WiFi, Bluetooth, etc.)
-    - More LoRa transceivers
-    - IR Transceivers
-- Planned, but not yet scheduled
-  - OpenWRT support
-  - Metric-based path selection
-  - Distributed Destination Naming System
-  - Network-wide path balancing
-  - Globally routable multicast
-  - Bindings for other programming languages
-  - Multiple paths in path table for quick recovery on link failures
-  - A portable Reticulum implementation in C, see [#21](https://github.com/markqvist/Reticulum/discussions/21)
-  - Easy way to share interface configurations, see [#19](https://github.com/markqvist/Reticulum/discussions/19)
-  - More interface types
-    - AT-compatible modems
-    - Optical mediums
-    - AWDL / OWL
-    - HF Modems
-    - CAN-bus
-    - ZeroMQ
-    - MQTT
-    - XBee
-    - SPI
-    - i²c
-    - Tor
-
 ## Dependencies
 The installation of the default `rns` package requires the dependencies listed
 below. Almost all systems and distributions have readily available packages for
@@ -273,7 +245,7 @@ file:
   [[RNS Testnet I2P Hub A]]
     type = I2PInterface
     enabled = yes
-    peers = mrwqlsioq4hoo2lmeeud7dkfscnm7yxak7dmiyvsrnpfag3z5tsq.b32.i2p
+    peers = pmlm3l5rpympihoy2o5ago43kluei2jjjzsalcuiuylbve3mwi2a.b32.i2p
 
 # Interface to I2P Hub B
   [[RNS Testnet I2P Hub B]]

RNS/Interfaces/Android/RNodeInterface.py

@@ -85,7 +85,135 @@ class KISS():
         data = data.replace(bytes([0xdb]), bytes([0xdb, 0xdd]))
         data = data.replace(bytes([0xc0]), bytes([0xdb, 0xdc]))
         return data
-    
+
+class AndroidBluetoothManager():
+    def __init__(self, owner, target_device_name = None, target_device_address = None):
+        from jnius import autoclass
+        self.owner = owner
+        self.connected = False
+        self.target_device_name = target_device_name
+        self.target_device_address = target_device_address
+        self.potential_remote_devices = []
+        self.rfcomm_socket = None
+        self.connected_device = None
+        self.connection_failed = False
+        self.bt_adapter = autoclass('android.bluetooth.BluetoothAdapter')
+        self.bt_device  = autoclass('android.bluetooth.BluetoothDevice')
+        self.bt_socket  = autoclass('android.bluetooth.BluetoothSocket')
+        self.bt_rfcomm_service_record = autoclass('java.util.UUID').fromString("00001101-0000-1000-8000-00805F9B34FB")
+        self.buffered_input_stream    = autoclass('java.io.BufferedInputStream')
+
+    def connect(self, device_address=None):
+        self.rfcomm_socket = self.remote_device.createRfcommSocketToServiceRecord(self.bt_rfcomm_service_record)
+
+    def bt_enabled(self):
+        return self.bt_adapter.getDefaultAdapter().isEnabled()
+
+    def get_paired_devices(self):
+        if self.bt_enabled():
+            return self.bt_adapter.getDefaultAdapter().getBondedDevices()
+        else:
+            RNS.log("Could not query paired devices, Bluetooth is disabled", RNS.LOG_DEBUG)
+            return []
+
+    def get_potential_devices(self):
+        potential_devices = []
+        for device in self.get_paired_devices():
+            if self.target_device_address != None:
+                if str(device.getAddress()).replace(":", "").lower() == str(self.target_device_address).replace(":", "").lower():
+                    if self.target_device_name == None:
+                        potential_devices.append(device)
+                    else:
+                        if device.getName().lower() == self.target_device_name.lower():
+                            potential_devices.append(device)
+
+            elif self.target_device_name != None:
+                if device.getName().lower() == self.target_device_name.lower():
+                    potential_devices.append(device)
+
+            else:
+                if device.getName().lower().startswith("rnode "):
+                    potential_devices.append(device)
+
+        return potential_devices
+
+    def connect_any_device(self):
+        if (self.rfcomm_socket != None and not self.rfcomm_socket.isConnected()) or self.rfcomm_socket == None:
+            self.connection_failed = False
+            if len(self.potential_remote_devices) == 0:
+                self.potential_remote_devices = self.get_potential_devices()
+                if len(self.potential_remote_devices) == 0:
+                    RNS.log("No suitable bluetooth devices available, can't connect", RNS.LOG_DEBUG)
+                    return
+
+            while not self.connected and len(self.potential_remote_devices) > 0:
+                device = self.potential_remote_devices.pop()
+                try:
+                    self.rfcomm_socket = device.createRfcommSocketToServiceRecord(self.bt_rfcomm_service_record)
+                    if self.rfcomm_socket == None:
+                        raise IOError("Bluetooth stack returned no socket object")
+                    else:
+                        if not self.rfcomm_socket.isConnected():
+                            try:
+                                self.rfcomm_socket.connect()
+                                self.rfcomm_reader = self.buffered_input_stream(self.rfcomm_socket.getInputStream(), 1024)
+                                self.rfcomm_writer = self.rfcomm_socket.getOutputStream()
+                                self.connected = True
+                                self.connected_device = device
+                                RNS.log("Bluetooth device "+str(self.connected_device.getName())+" "+str(self.connected_device.getAddress())+" connected.")
+                            except Exception as e:
+                                raise IOError("The Bluetooth RFcomm socket could not be connected: "+str(e))
+
+                except Exception as e:
+                    RNS.log("Could not create and connect Bluetooth RFcomm socket for "+str(device.getName())+" "+str(device.getAddress()), RNS.LOG_ERROR)
+                    RNS.log("The contained exception was: "+str(e), RNS.LOG_ERROR)
+
+    def close(self):
+        if self.connected:
+            if self.rfcomm_reader != None:
+                self.rfcomm_reader.close()
+                self.rfcomm_reader = None
+            
+            if self.rfcomm_writer != None:
+                self.rfcomm_writer.close()
+                self.rfcomm_writer = None
+
+            if self.rfcomm_socket != None:
+                self.rfcomm_socket.close()
+
+            self.connected = False
+            self.connected_device = None
+            self.potential_remote_devices = []
+
+
+    def read(self, len = None):
+        if self.connection_failed:
+            raise IOError("Bluetooth connection failed")
+        else:
+            if self.connected and self.rfcomm_reader != None:
+                available = self.rfcomm_reader.available()
+                if available > 0:
+                    if hasattr(self.rfcomm_reader, "readNBytes"):
+                        return self.rfcomm_reader.readNBytes(available)
+                    else:
+                        # Compatibility mode for older android versions lacking readNBytes
+                        rb = self.rfcomm_reader.read().to_bytes(1, "big")
+                        return rb
+                else:
+                    return bytes([])
+            else:
+                raise IOError("No RFcomm socket available")
+
+    def write(self, data):
+        try:
+            self.rfcomm_writer.write(data)
+            self.rfcomm_writer.flush()
+            return len(data)
+        except Exception as e:
+            RNS.log("Bluetooth connection failed for "+str(self), RNS.LOG_ERROR)
+            self.connection_failed = True
+            return 0
+
 
 class RNodeInterface(Interface):
     MAX_CHUNK = 32768
@@ -98,11 +226,95 @@ class RNodeInterface(Interface):
     CALLSIGN_MAX_LEN    = 32
 
     REQUIRED_FW_VER_MAJ = 1
-    REQUIRED_FW_VER_MIN = 51
+    REQUIRED_FW_VER_MIN = 52
 
     RECONNECT_WAIT = 5
+    PORT_IO_TIMEOUT = 3
 
-    def __init__(self, owner, name, port, frequency = None, bandwidth = None, txpower = None, sf = None, cr = None, flow_control = False, id_interval = None, id_callsign = None):
+    @classmethod
+    def bluetooth_control(device_serial = None, port = None, enable_bluetooth = False, disable_bluetooth = False, pairing_mode = False):
+        if (port != None or device_serial != None) and (enable_bluetooth or disable_bluetooth or pairing_mode):
+            serial = None
+            bluetooth_state = None
+            if pairing_mode:
+                bluetooth_state = 0x01
+            elif enable_bluetooth:
+                bluetooth_state = 0x01
+            elif disable_bluetooth:
+                bluetooth_state = 0x00
+
+            if port != None:
+                RNS.log("Opening serial port "+port+"...")
+                # Get device parameters
+                from usb4a import usb
+                device = usb.get_usb_device(port)
+                if device:
+                    vid = device.getVendorId()
+                    pid = device.getProductId()
+
+                    # Driver overrides for speficic chips
+                    from usbserial4a import serial4a as pyserial
+                    if vid == 0x1A86 and pid == 0x55D4:
+                        # Force CDC driver for Qinheng CH34x
+                        RNS.log("Using CDC driver for "+RNS.hexrep(vid)+":"+RNS.hexrep(pid), RNS.LOG_DEBUG)
+                        from usbserial4a.cdcacmserial4a import CdcAcmSerial
+                        proxy = CdcAcmSerial
+
+                    serial = pyserial.get_serial_port(
+                        port,
+                        baudrate = 115200,
+                        bytesize = 8,
+                        parity = "N",
+                        stopbits = 1,
+                        xonxoff = False,
+                        rtscts = False,
+                        timeout = None,
+                        inter_byte_timeout = None,
+                        # write_timeout = wtimeout,
+                        dsrdtr = False,
+                    )
+
+                    if vid == 0x0403:
+                        # Hardware parameters for FTDI devices @ 115200 baud
+                        serial.DEFAULT_READ_BUFFER_SIZE = 16 * 1024
+                        serial.USB_READ_TIMEOUT_MILLIS = 100
+                        serial.timeout = 0.1
+                    elif vid == 0x10C4:
+                        # Hardware parameters for SiLabs CP210x @ 115200 baud
+                        serial.DEFAULT_READ_BUFFER_SIZE = 64 
+                        serial.USB_READ_TIMEOUT_MILLIS = 12
+                        serial.timeout = 0.012
+                    elif vid == 0x1A86 and pid == 0x55D4:
+                        # Hardware parameters for Qinheng CH34x @ 115200 baud
+                        serial.DEFAULT_READ_BUFFER_SIZE = 64
+                        serial.USB_READ_TIMEOUT_MILLIS = 12
+                        serial.timeout = 0.1
+                    else:
+                        # Default values
+                        serial.DEFAULT_READ_BUFFER_SIZE = 1 * 1024
+                        serial.USB_READ_TIMEOUT_MILLIS = 100
+                        serial.timeout = 0.1
+
+            elif device_serial != None:
+                serial = device_serial
+
+            if serial != None:
+                if serial.is_open:
+                    kiss_command = bytes([KISS.FEND, KISS.CMD_BT_CTRL, bluetooth_state, KISS.FEND])
+                    serial.write(kiss_command)
+                    if pairing_mode:
+                        kiss_command = bytes([KISS.FEND, KISS.CMD_BT_CTRL, 0x02, KISS.FEND])
+                        serial.write(kiss_command)
+
+            if port != None:
+                serial.close()
+
+
+    def __init__(
+        self, owner, name, port, frequency = None, bandwidth = None, txpower = None,
+        sf = None, cr = None, flow_control = False, id_interval = None,
+        allow_bluetooth = False, target_device_name = None,
+        target_device_address = None, id_callsign = None):
         import importlib
         if RNS.vendor.platformutils.is_android():
             self.on_android  = True
@@ -115,6 +327,16 @@ class RNodeInterface(Interface):
 
                 from usbserial4a import serial4a as serial
                 self.parity = "N"
+
+                if allow_bluetooth:
+                    self.bt_manager = AndroidBluetoothManager(
+                        owner = self,
+                        target_device_name = target_device_name,
+                        target_device_address = target_device_address
+                    )
+
+                else:
+                    self.bt_manager = None
             
             else:
                 RNS.log("Could not load USB serial module for Android, RNode interface cannot be created.", RNS.LOG_CRITICAL)
@@ -139,6 +361,7 @@ class RNodeInterface(Interface):
         self.timeout     = 150
         self.online      = False
         self.hw_errors   = []
+        self.allow_bluetooth = allow_bluetooth
 
         self.frequency   = frequency
         self.bandwidth   = bandwidth
@@ -175,6 +398,9 @@ class RNodeInterface(Interface):
         self.flow_control    = flow_control
         self.interface_ready = False
         self.announce_rate_target = None
+        self.last_port_io = 0
+        self.port_io_timeout = RNodeInterface.PORT_IO_TIMEOUT
+        self.last_imagedata = None
 
         self.validcfg  = True
         if (self.frequency < RNodeInterface.FREQ_MIN or self.frequency > RNodeInterface.FREQ_MAX):
@@ -215,10 +441,18 @@ class RNodeInterface(Interface):
         try:
             self.open_port()
 
-            if self.serial.is_open:
-                self.configure_device()
+            if self.serial != None:
+                if self.serial.is_open:
+                    self.configure_device()
+                else:
+                    raise IOError("Could not open serial port")
+            elif self.bt_manager != None:
+                if self.bt_manager.connected:
+                    self.configure_device()
+                else:
+                    raise IOError("Could not connect to any Bluetooth devices")
             else:
-                raise IOError("Could not open serial port")
+                raise IOError("Neither serial port nor Bluetooth devices available")
 
         except Exception as e:
             RNS.log("Could not open serial port for interface "+str(self), RNS.LOG_ERROR)
@@ -230,61 +464,87 @@ class RNodeInterface(Interface):
                 thread.start()
 
 
+    def read_mux(self, len=None):
+        if self.serial != None:
+            return self.serial.read()
+        elif self.bt_manager != None:
+            return self.bt_manager.read()
+        else:
+            raise IOError("No ports available for reading")
+
+    def write_mux(self, data):
+        if self.serial != None:
+            written = self.serial.write(data)
+            self.last_port_io = time.time()
+            return written
+        elif self.bt_manager != None:
+            written = self.bt_manager.write(data)
+            if (written == len(data)):
+                self.last_port_io = time.time()
+            return written
+        else:
+            raise IOError("No ports available for writing")
+
     def open_port(self):
-        RNS.log("Opening serial port "+self.port+"...")
-        # Get device parameters
-        from usb4a import usb
-        device = usb.get_usb_device(self.port)
-        if device:
-            vid = device.getVendorId()
-            pid = device.getProductId()
+        if self.port != None:
+            RNS.log("Opening serial port "+self.port+"...")
+            # Get device parameters
+            from usb4a import usb
+            device = usb.get_usb_device(self.port)
+            if device:
+                vid = device.getVendorId()
+                pid = device.getProductId()
 
-            # Driver overrides for speficic chips
-            proxy = self.pyserial.get_serial_port
-            if vid == 0x1A86 and pid == 0x55D4:
-                # Force CDC driver for Qinheng CH34x
-                RNS.log(str(self)+" using CDC driver for "+RNS.hexrep(vid)+":"+RNS.hexrep(pid), RNS.LOG_DEBUG)
-                from usbserial4a.cdcacmserial4a import CdcAcmSerial
-                proxy = CdcAcmSerial
+                # Driver overrides for speficic chips
+                proxy = self.pyserial.get_serial_port
+                if vid == 0x1A86 and pid == 0x55D4:
+                    # Force CDC driver for Qinheng CH34x
+                    RNS.log(str(self)+" using CDC driver for "+RNS.hexrep(vid)+":"+RNS.hexrep(pid), RNS.LOG_DEBUG)
+                    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,
+                    # write_timeout = wtimeout,
+                    dsrdtr = False,
+                )
 
-            if vid == 0x0403:
-                # Hardware parameters for FTDI devices @ 115200 baud
-                self.serial.DEFAULT_READ_BUFFER_SIZE = 16 * 1024
-                self.serial.USB_READ_TIMEOUT_MILLIS = 100
-                self.serial.timeout = 0.1
-            elif vid == 0x10C4:
-                # Hardware parameters for SiLabs CP210x @ 115200 baud
-                self.serial.DEFAULT_READ_BUFFER_SIZE = 64 
-                self.serial.USB_READ_TIMEOUT_MILLIS = 12
-                self.serial.timeout = 0.012
-            elif vid == 0x1A86 and pid == 0x55D4:
-                # Hardware parameters for Qinheng CH34x @ 115200 baud
-                self.serial.DEFAULT_READ_BUFFER_SIZE = 64
-                self.serial.USB_READ_TIMEOUT_MILLIS = 12
-                self.serial.timeout = 0.1
-            else:
-                # Default values
-                self.serial.DEFAULT_READ_BUFFER_SIZE = 1 * 1024
-                self.serial.USB_READ_TIMEOUT_MILLIS = 100
-                self.serial.timeout = 0.1
+                if vid == 0x0403:
+                    # Hardware parameters for FTDI devices @ 115200 baud
+                    self.serial.DEFAULT_READ_BUFFER_SIZE = 16 * 1024
+                    self.serial.USB_READ_TIMEOUT_MILLIS = 100
+                    self.serial.timeout = 0.1
+                elif vid == 0x10C4:
+                    # Hardware parameters for SiLabs CP210x @ 115200 baud
+                    self.serial.DEFAULT_READ_BUFFER_SIZE = 64 
+                    self.serial.USB_READ_TIMEOUT_MILLIS = 12
+                    self.serial.timeout = 0.012
+                elif vid == 0x1A86 and pid == 0x55D4:
+                    # Hardware parameters for Qinheng CH34x @ 115200 baud
+                    self.serial.DEFAULT_READ_BUFFER_SIZE = 64
+                    self.serial.USB_READ_TIMEOUT_MILLIS = 12
+                    self.serial.timeout = 0.1
+                else:
+                    # Default values
+                    self.serial.DEFAULT_READ_BUFFER_SIZE = 1 * 1024
+                    self.serial.USB_READ_TIMEOUT_MILLIS = 100
+                    self.serial.timeout = 0.1
 
-            RNS.log(str(self)+" USB read buffer size set to "+RNS.prettysize(self.serial.DEFAULT_READ_BUFFER_SIZE), RNS.LOG_DEBUG)
-            RNS.log(str(self)+" USB read timeout set to "+str(self.serial.USB_READ_TIMEOUT_MILLIS)+"ms", RNS.LOG_DEBUG)
-            RNS.log(str(self)+" USB write timeout set to "+str(self.serial.USB_WRITE_TIMEOUT_MILLIS)+"ms", RNS.LOG_DEBUG)
+                RNS.log(str(self)+" USB read buffer size set to "+RNS.prettysize(self.serial.DEFAULT_READ_BUFFER_SIZE), RNS.LOG_DEBUG)
+                RNS.log(str(self)+" USB read timeout set to "+str(self.serial.USB_READ_TIMEOUT_MILLIS)+"ms", RNS.LOG_DEBUG)
+                RNS.log(str(self)+" USB write timeout set to "+str(self.serial.USB_WRITE_TIMEOUT_MILLIS)+"ms", RNS.LOG_DEBUG)
+
+        elif self.allow_bluetooth:
+            if self.bt_manager != None:
+                self.bt_manager.connect_any_device()
 
 
     def configure_device(self):
@@ -295,8 +555,7 @@ class RNodeInterface(Interface):
 
         self.detect()
         sleep(0.4)
-            
-        
+
         if not self.detected:
             raise IOError("Could not detect device")
         else:
@@ -306,7 +565,11 @@ class RNodeInterface(Interface):
         if not self.firmware_ok:
             raise IOError("Invalid device firmware")
 
-        RNS.log("Serial port "+self.port+" is now open")
+        if self.serial != None and self.port != None:
+            RNS.log("Serial port "+self.port+" is now open")
+        if self.bt_manager != None and self.bt_manager.connected:
+            RNS.log("Bluetooth connection to RNode now open")
+
         RNS.log("Configuring RNode interface...", RNS.LOG_VERBOSE)
         self.initRadio()
         if (self.validateRadioState()):
@@ -318,7 +581,12 @@ class RNodeInterface(Interface):
             RNS.log("After configuring "+str(self)+", the reported radio parameters did not match your configuration.", RNS.LOG_ERROR)
             RNS.log("Make sure that your hardware actually supports the parameters specified in the configuration", RNS.LOG_ERROR)
             RNS.log("Aborting RNode startup", RNS.LOG_ERROR)
-            self.serial.close()
+            
+            if self.serial != None:
+                self.serial.close()
+            if self.bt_manager != None:
+                self.bt_manager.close()
+
             raise IOError("RNode interface did not pass configuration validation")
             
 
@@ -343,27 +611,45 @@ class RNodeInterface(Interface):
 
     def detect(self):
         kiss_command = bytes([KISS.FEND, KISS.CMD_DETECT, KISS.DETECT_REQ, KISS.FEND, KISS.CMD_FW_VERSION, 0x00, KISS.FEND, KISS.CMD_PLATFORM, 0x00, KISS.FEND, KISS.CMD_MCU, 0x00, KISS.FEND])
-        written = self.serial.write(kiss_command)
+        written = self.write_mux(kiss_command)
         if written != len(kiss_command):
-            raise IOError("An IO error occurred while detecting hardware for "+self(str))
+            raise IOError("An IO error occurred while detecting hardware for "+str(self))
 
     def leave(self):
         kiss_command = bytes([KISS.FEND, KISS.CMD_LEAVE, 0xFF, KISS.FEND])
-        written = self.serial.write(kiss_command)
+        written = self.write_mux(kiss_command)
         if written != len(kiss_command):
             raise IOError("An IO error occurred while sending host left command to device")
     
+    def enable_bluetooth(self):
+        kiss_command = bytes([KISS.FEND, KISS.CMD_BT_CTRL, 0x01, KISS.FEND])
+        written = self.write_mux(kiss_command)
+        if written != len(kiss_command):
+            raise IOError("An IO error occurred while sending bluetooth enable command to device")
+
+    def disable_bluetooth(self):
+        kiss_command = bytes([KISS.FEND, KISS.CMD_BT_CTRL, 0x00, KISS.FEND])
+        written = self.write_mux(kiss_command)
+        if written != len(kiss_command):
+            raise IOError("An IO error occurred while sending bluetooth disable command to device")
+
+    def bluetooth_pair(self):
+        kiss_command = bytes([KISS.FEND, KISS.CMD_BT_CTRL, 0x02, KISS.FEND])
+        written = self.write_mux(kiss_command)
+        if written != len(kiss_command):
+            raise IOError("An IO error occurred while sending bluetooth pair command to device")
+
     def enable_external_framebuffer(self):
         if self.display != None:
             kiss_command = bytes([KISS.FEND, KISS.CMD_FB_EXT, 0x01, KISS.FEND])
-            written = self.serial.write(kiss_command)
+            written = self.write_mux(kiss_command)
             if written != len(kiss_command):
                 raise IOError("An IO error occurred while enabling external framebuffer on device")
 
     def disable_external_framebuffer(self):
         if self.display != None:
             kiss_command = bytes([KISS.FEND, KISS.CMD_FB_EXT, 0x00, KISS.FEND])
-            written = self.serial.write(kiss_command)
+            written = self.write_mux(kiss_command)
             if written != len(kiss_command):
                 raise IOError("An IO error occurred while disabling external framebuffer on device")
 
@@ -372,6 +658,7 @@ class RNodeInterface(Interface):
     FB_PIXELS_PER_BYTE = 8//FB_BITS_PER_PIXEL
     FB_BYTES_PER_LINE  = FB_PIXEL_WIDTH//FB_PIXELS_PER_BYTE
     def display_image(self, imagedata):
+        self.last_imagedata = imagedata
         if self.display != None:
             lines = len(imagedata)//8
             for line in range(lines):
@@ -387,13 +674,13 @@ class RNodeInterface(Interface):
             escaped_data = KISS.escape(data)
             kiss_command = bytes([KISS.FEND])+bytes([KISS.CMD_FB_WRITE])+escaped_data+bytes([KISS.FEND])
             
-            written = self.serial.write(kiss_command)
+            written = self.write_mux(kiss_command)
             if written != len(kiss_command):
                 raise IOError("An IO error occurred while writing framebuffer data device")
 
     def hard_reset(self):
         kiss_command = bytes([KISS.FEND, KISS.CMD_RESET, 0xf8, KISS.FEND])
-        written = self.serial.write(kiss_command)
+        written = self.write_mux(kiss_command)
         if written != len(kiss_command):
             raise IOError("An IO error occurred while restarting device")
         sleep(4.0);
@@ -406,9 +693,9 @@ class RNodeInterface(Interface):
         data = KISS.escape(bytes([c1])+bytes([c2])+bytes([c3])+bytes([c4]))
 
         kiss_command = bytes([KISS.FEND])+bytes([KISS.CMD_FREQUENCY])+data+bytes([KISS.FEND])
-        written = self.serial.write(kiss_command)
+        written = self.write_mux(kiss_command)
         if written != len(kiss_command):
-            raise IOError("An IO error occurred while configuring frequency for "+self(str))
+            raise IOError("An IO error occurred while configuring frequency for "+str(self))
 
     def setBandwidth(self):
         c1 = self.bandwidth >> 24
@@ -418,37 +705,37 @@ class RNodeInterface(Interface):
         data = KISS.escape(bytes([c1])+bytes([c2])+bytes([c3])+bytes([c4]))
 
         kiss_command = bytes([KISS.FEND])+bytes([KISS.CMD_BANDWIDTH])+data+bytes([KISS.FEND])
-        written = self.serial.write(kiss_command)
+        written = self.write_mux(kiss_command)
         if written != len(kiss_command):
-            raise IOError("An IO error occurred while configuring bandwidth for "+self(str))
+            raise IOError("An IO error occurred while configuring bandwidth for "+str(self))
 
     def setTXPower(self):
         txp = bytes([self.txpower])
         kiss_command = bytes([KISS.FEND])+bytes([KISS.CMD_TXPOWER])+txp+bytes([KISS.FEND])
-        written = self.serial.write(kiss_command)
+        written = self.write_mux(kiss_command)
         if written != len(kiss_command):
-            raise IOError("An IO error occurred while configuring TX power for "+self(str))
+            raise IOError("An IO error occurred while configuring TX power for "+str(self))
 
     def setSpreadingFactor(self):
         sf = bytes([self.sf])
         kiss_command = bytes([KISS.FEND])+bytes([KISS.CMD_SF])+sf+bytes([KISS.FEND])
-        written = self.serial.write(kiss_command)
+        written = self.write_mux(kiss_command)
         if written != len(kiss_command):
-            raise IOError("An IO error occurred while configuring spreading factor for "+self(str))
+            raise IOError("An IO error occurred while configuring spreading factor for "+str(self))
 
     def setCodingRate(self):
         cr = bytes([self.cr])
         kiss_command = bytes([KISS.FEND])+bytes([KISS.CMD_CR])+cr+bytes([KISS.FEND])
-        written = self.serial.write(kiss_command)
+        written = self.write_mux(kiss_command)
         if written != len(kiss_command):
-            raise IOError("An IO error occurred while configuring coding rate for "+self(str))
+            raise IOError("An IO error occurred while configuring coding rate for "+str(self))
 
     def setRadioState(self, state):
         self.state = state
         kiss_command = bytes([KISS.FEND])+bytes([KISS.CMD_RADIO_STATE])+bytes([state])+bytes([KISS.FEND])
-        written = self.serial.write(kiss_command)
+        written = self.write_mux(kiss_command)
         if written != len(kiss_command):
-            raise IOError("An IO error occurred while configuring radio state for "+self(str))
+            raise IOError("An IO error occurred while configuring radio state for "+str(self))
 
     def validate_firmware(self):
         if (self.maj_version >= RNodeInterface.REQUIRED_FW_VER_MAJ):
@@ -532,7 +819,7 @@ class RNodeInterface(Interface):
                 data    = KISS.escape(data)
                 frame   = bytes([0xc0])+bytes([0x00])+data+bytes([0xc0])
 
-                written = self.serial.write(frame)
+                written = self.write_mux(frame)
                 self.txb += datalen
 
                 if written != len(frame):
@@ -560,11 +847,14 @@ class RNodeInterface(Interface):
             command_buffer = b""
             last_read_ms = int(time.time()*1000)
 
-            # TODO: Ensure hotplug support
-            while self.serial.is_open:
-                # TODO: Check multibyte reads
-                serial_bytes = self.serial.read()
+            # TODO: Ensure hotplug support for serial drivers
+            # This should work now with the new time-based
+            # detect polling.
+            while (self.serial != None and self.serial.is_open) or (self.bt_manager != None and self.bt_manager.connected):
+                serial_bytes = self.read_mux()
                 got = len(serial_bytes)
+                if got > 0:
+                    self.last_port_io = time.time()
 
                 for byte in serial_bytes:
                     last_read_ms = int(time.time()*1000)
@@ -737,11 +1027,19 @@ class RNodeInterface(Interface):
                             if time.time() > self.first_tx + self.id_interval:
                                 RNS.log("Interface "+str(self)+" is transmitting beacon data: "+str(self.id_callsign.decode("utf-8")), RNS.LOG_DEBUG)
                                 self.processOutgoing(self.id_callsign)
-                    # sleep(0.08)
+                    
+                    if (time.time() - self.last_port_io > self.port_io_timeout):
+                        self.detect()
+                    
+                    if (time.time() - self.last_port_io > self.port_io_timeout*3):
+                        raise IOError("Connected port for "+str(self)+" became unresponsive")
+
+                    if self.bt_manager != None:
+                        sleep(0.08)
 
         except Exception as e:
             self.online = False
-            RNS.log("A serial port error occurred, the contained exception was: "+str(e), RNS.LOG_ERROR)
+            RNS.log("A serial port occurred, the contained exception was: "+str(e), RNS.LOG_ERROR)
             RNS.log("The interface "+str(self)+" experienced an unrecoverable error and is now offline.", RNS.LOG_ERROR)
 
             if RNS.Reticulum.panic_on_interface_error:
@@ -750,19 +1048,43 @@ class RNodeInterface(Interface):
             RNS.log("Reticulum will attempt to reconnect the interface periodically.", RNS.LOG_ERROR)
 
         self.online = False
-        self.serial.close()
+
+        if self.serial != None:
+            self.serial.close()
+
+        if self.bt_manager != None:
+            self.bt_manager.close()
+
         self.reconnect_port()
 
     def reconnect_port(self):
         while not self.online and len(self.hw_errors) == 0:
             try:
                 time.sleep(self.reconnect_w)
-                RNS.log("Attempting to reconnect serial port "+str(self.port)+" for "+str(self)+"...", RNS.LOG_VERBOSE)
+                if self.serial != None and self.port != None:
+                    RNS.log("Attempting to reconnect serial port "+str(self.port)+" for "+str(self)+"...", RNS.LOG_VERBOSE)
+
+                if self.bt_manager != None:
+                    RNS.log("Attempting to reconnect Bluetooth device for "+str(self)+"...", RNS.LOG_VERBOSE)
+
                 self.open_port()
+
                 if hasattr(self, "serial") and self.serial != None and self.serial.is_open:
                     self.configure_device()
+                    if self.online:
+                        if self.last_imagedata != None:
+                            self.display_image(self.last_imagedata)
+                            self.enable_external_framebuffer()
+                
+                elif hasattr(self, "bt_manager") and self.bt_manager != None and self.bt_manager.connected:
+                    self.configure_device()
+                    if self.online:
+                        if self.last_imagedata != None:
+                            self.display_image(self.last_imagedata)
+                            self.enable_external_framebuffer()
+
             except Exception as e:
-                RNS.log("Error while reconnecting port, the contained exception was: "+str(e), RNS.LOG_ERROR)
+                RNS.log("Error while reconnecting RNode, the contained exception was: "+str(e), RNS.LOG_ERROR)
 
         if self.online:
             RNS.log("Reconnected serial port for "+str(self))

RNS/Interfaces/AutoInterface.py

@@ -48,6 +48,11 @@ class AutoInterface(Interface):
 
     BITRATE_GUESS      = 10*1000*1000
 
+    def handler_factory(self, callback):
+        def create_handler(*args, **keys):
+            return AutoInterfaceHandler(callback, *args, **keys)
+        return create_handler
+
     def __init__(self, owner, name, group_id=None, discovery_scope=None, discovery_port=None, data_port=None, allowed_interfaces=None, ignored_interfaces=None, configured_bitrate=None):
         import importlib
         if importlib.util.find_spec('netifaces') != None:
@@ -70,6 +75,7 @@ class AutoInterface(Interface):
         self.peers = {}
         self.link_local_addresses = []
         self.adopted_interfaces = {}
+        self.interface_servers = {}
         self.multicast_echoes = {}
         self.timed_out_interfaces = {}
 
@@ -199,11 +205,6 @@ class AutoInterface(Interface):
             peering_wait = self.announce_interval*1.2
             RNS.log(str(self)+" discovering peers for "+str(round(peering_wait, 2))+" seconds...", RNS.LOG_VERBOSE)
 
-            def handlerFactory(callback):
-                def createHandler(*args, **keys):
-                    return AutoInterfaceHandler(callback, *args, **keys)
-                return createHandler
-
             self.owner = owner
             socketserver.UDPServer.address_family = socket.AF_INET6
 
@@ -212,9 +213,10 @@ class AutoInterface(Interface):
                 addr_info = socket.getaddrinfo(local_addr, self.data_port, socket.AF_INET6, socket.SOCK_DGRAM)
                 address = addr_info[0][4]
 
-                self.server = socketserver.UDPServer(address, handlerFactory(self.processIncoming))
+                udp_server = socketserver.UDPServer(address, self.handler_factory(self.processIncoming))
+                self.interface_servers[ifname] = udp_server
                 
-                thread = threading.Thread(target=self.server.serve_forever)
+                thread = threading.Thread(target=udp_server.serve_forever)
                 thread.daemon = True
                 thread.start()
 
@@ -277,8 +279,32 @@ class AutoInterface(Interface):
                                 if address["addr"].startswith("fe80:"):
                                     link_local_addr = address["addr"].split("%")[0]
                                     if link_local_addr != self.adopted_interfaces[ifname]:
+                                        # TODO: Remove
+                                        # RNS.log("Replacing link-local address for "+str(ifname), RNS.LOG_DEBUG)
                                         self.adopted_interfaces[ifname] = link_local_addr
 
+                                        local_addr = link_local_addr+"%"+ifname
+                                        addr_info = socket.getaddrinfo(local_addr, self.data_port, socket.AF_INET6, socket.SOCK_DGRAM)
+                                        listen_address = addr_info[0][4]
+
+                                        if ifname in self.interface_servers:
+                                            # TODO: Remove
+                                            # RNS.log("Shutting down previous UDP socket server for "+str(ifname), RNS.LOG_DEBUG)
+                                            previous_server = self.interface_servers[ifname]
+                                            def shutdown_server():
+                                                previous_server.shutdown()
+                                            threading.Thread(target=shutdown_server, daemon=True).start()
+
+                                        # TODO: Remove
+                                        # RNS.log("Starting new UDP socket server for "+str(ifname), RNS.LOG_DEBUG)
+
+                                        udp_server = socketserver.UDPServer(listen_address, self.handler_factory(self.processIncoming))
+                                        self.interface_servers[ifname] = udp_server
+
+                                        thread = threading.Thread(target=udp_server.serve_forever)
+                                        thread.daemon = True
+                                        thread.start()
+
                 except Exception as e:
                     RNS.log("Could not get device information while updating link-local addresses for "+str(self)+". The contained exception was: "+str(e), RNS.LOG_ERROR)
 

RNS/Interfaces/I2PInterface.py

@@ -161,8 +161,6 @@ class I2PController:
                                 raise tn.status["exception"]
 
                             else:
-                                self.client_tunnels[i2p_destination] = True
-                                owner.awaiting_i2p_tunnel = False
                                 if owner.socket != None:
                                     if hasattr(owner.socket, "close"):
                                         if callable(owner.socket.close):
@@ -175,6 +173,8 @@ class I2PController:
                                                 owner.socket.close()
                                             except Exception as e:
                                                 RNS.log("Error while closing socket for "+str(owner)+": "+str(e))
+                                self.client_tunnels[i2p_destination] = True
+                                owner.awaiting_i2p_tunnel = False
 
                                 RNS.log(str(owner)+" tunnel setup complete", RNS.LOG_VERBOSE)
 
@@ -383,6 +383,11 @@ class I2PInterfacePeer(Interface):
     I2P_PROBE_AFTER = 10
     I2P_PROBE_INTERVAL = 9
     I2P_PROBES = 5
+    I2P_READ_TIMEOUT = (I2P_PROBE_INTERVAL * I2P_PROBES + I2P_PROBE_AFTER)*2
+
+    TUNNEL_STATE_INIT    = 0x00
+    TUNNEL_STATE_ACTIVE  = 0x01
+    TUNNEL_STATE_STALE   = 0x02
 
     def __init__(self, parent_interface, owner, name, target_i2p_dest=None, connected_socket=None, max_reconnect_tries=None):
         self.rxb = 0
@@ -409,6 +414,30 @@ class I2PInterfacePeer(Interface):
         self.i2p_tunnel_ready = False
         self.mode             = RNS.Interfaces.Interface.Interface.MODE_FULL
         self.bitrate          = I2PInterface.BITRATE_GUESS
+        self.last_read        = 0
+        self.last_write       = 0
+        self.wd_reset         = False
+        self.i2p_tunnel_state = I2PInterfacePeer.TUNNEL_STATE_INIT
+
+        self.ifac_size = self.parent_interface.ifac_size
+        self.ifac_netname = self.parent_interface.ifac_netname
+        self.ifac_netkey = self.parent_interface.ifac_netkey
+        if self.ifac_netname != None or self.ifac_netkey != None:
+            ifac_origin = b""
+            if self.ifac_netname != None:
+                ifac_origin += RNS.Identity.full_hash(self.ifac_netname.encode("utf-8"))
+            if self.ifac_netkey != None:
+                ifac_origin += RNS.Identity.full_hash(self.ifac_netkey.encode("utf-8"))
+
+            ifac_origin_hash = RNS.Identity.full_hash(ifac_origin)
+            self.ifac_key = RNS.Cryptography.hkdf(
+                length=64,
+                derive_from=ifac_origin_hash,
+                salt=RNS.Reticulum.IFAC_SALT,
+                context=None
+            )
+            self.ifac_identity = RNS.Identity.from_bytes(self.ifac_key)
+            self.ifac_signature = self.ifac_identity.sign(RNS.Identity.full_hash(self.ifac_key))
 
         self.announce_rate_target  = None
         self.announce_rate_grace   = None
@@ -454,7 +483,7 @@ class I2PInterfacePeer(Interface):
                         RNS.log("Error while while configuring "+str(self)+": "+str(e), RNS.LOG_ERROR)
                         RNS.log("Check that I2P is installed and running, and that SAM is enabled. Retrying tunnel setup later.", RNS.LOG_ERROR)
 
-                    time.sleep(15)
+                    time.sleep(8)
 
             thread = threading.Thread(target=tunnel_job)
             thread.daemon = True
@@ -463,6 +492,7 @@ class I2PInterfacePeer(Interface):
             def wait_job():
                 while self.awaiting_i2p_tunnel:
                     time.sleep(0.25)
+                time.sleep(2)
                 
                 if not self.kiss_framing:
                     self.wants_tunnel = True
@@ -482,18 +512,11 @@ class I2PInterfacePeer(Interface):
 
 
     def set_timeouts_linux(self):
-        if not self.i2p_tunneled:
-            self.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_USER_TIMEOUT, int(I2PInterfacePeer.TCP_USER_TIMEOUT * 1000))
-            self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
-            self.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPIDLE, int(I2PInterfacePeer.TCP_PROBE_AFTER))
-            self.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPINTVL, int(I2PInterfacePeer.TCP_PROBE_INTERVAL))
-            self.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPCNT, int(I2PInterfacePeer.TCP_PROBES))
-        else:
-            self.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_USER_TIMEOUT, int(I2PInterfacePeer.I2P_USER_TIMEOUT * 1000))
-            self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
-            self.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPIDLE, int(I2PInterfacePeer.I2P_PROBE_AFTER))
-            self.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPINTVL, int(I2PInterfacePeer.I2P_PROBE_INTERVAL))
-            self.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPCNT, int(I2PInterfacePeer.I2P_PROBES))
+        self.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_USER_TIMEOUT, int(I2PInterfacePeer.I2P_USER_TIMEOUT * 1000))
+        self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
+        self.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPIDLE, int(I2PInterfacePeer.I2P_PROBE_AFTER))
+        self.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPINTVL, int(I2PInterfacePeer.I2P_PROBE_INTERVAL))
+        self.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPCNT, int(I2PInterfacePeer.I2P_PROBES))
 
     def set_timeouts_osx(self):
         if hasattr(socket, "TCP_KEEPALIVE"):
@@ -502,22 +525,19 @@ class I2PInterfacePeer(Interface):
             TCP_KEEPIDLE = 0x10
 
         self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
-        
-        if not self.i2p_tunneled:
-            self.socket.setsockopt(socket.IPPROTO_TCP, TCP_KEEPIDLE, int(I2PInterfacePeer.TCP_PROBE_AFTER))
-        else:
-            self.socket.setsockopt(socket.IPPROTO_TCP, TCP_KEEPIDLE, int(I2PInterfacePeer.I2P_PROBE_AFTER))
+        self.socket.setsockopt(socket.IPPROTO_TCP, TCP_KEEPIDLE, int(I2PInterfacePeer.I2P_PROBE_AFTER))
     
-    def shutdown_socket(self, socket):
-        if callable(socket.close):
-            
+    def shutdown_socket(self, target_socket):
+        if callable(target_socket.close):
             try:
-                socket.shutdown(socket.SHUT_RDWR)
+                if socket != None:
+                    target_socket.shutdown(socket.SHUT_RDWR)
             except Exception as e:
                 RNS.log("Error while shutting down socket for "+str(self)+": "+str(e))
 
             try:
-                socket.close()
+                if socket != None:
+                    target_socket.close()
             except Exception as e:
                 RNS.log("Error while closing socket for "+str(self)+": "+str(e))    
     
@@ -571,7 +591,6 @@ class I2PInterfacePeer(Interface):
 
         return True
 
-
     def reconnect(self):
         if self.initiator:
             if not self.reconnecting:
@@ -632,6 +651,7 @@ class I2PInterfacePeer(Interface):
                 self.socket.sendall(data)
                 self.writing = False
                 self.txb += len(data)
+                self.last_write = time.time()
                 
                 if hasattr(self, "parent_interface") and self.parent_interface != None and self.parent_count:
                     self.parent_interface.txb += len(data)
@@ -642,8 +662,59 @@ class I2PInterfacePeer(Interface):
                 self.teardown()
 
 
+    def read_watchdog(self):
+        while self.wd_reset:
+            time.sleep(0.25)
+
+        should_run = True
+        try:
+            while should_run and not self.wd_reset:
+                time.sleep(1)
+
+                if (time.time()-self.last_read > I2PInterfacePeer.I2P_PROBE_AFTER*2):
+                    if self.i2p_tunnel_state != I2PInterfacePeer.TUNNEL_STATE_STALE:
+                        RNS.log("I2P tunnel became unresponsive", RNS.LOG_DEBUG)
+
+                    self.i2p_tunnel_state = I2PInterfacePeer.TUNNEL_STATE_STALE
+                else:
+                    self.i2p_tunnel_state = I2PInterfacePeer.TUNNEL_STATE_ACTIVE
+
+                if (time.time()-self.last_write > I2PInterfacePeer.I2P_PROBE_AFTER*1):
+                    try:
+                        if self.socket != None:
+                            self.socket.sendall(bytes([HDLC.FLAG, HDLC.FLAG]))
+                    except Exception as e:
+                        RNS.log("An error ocurred while sending I2P keepalive. The contained exception was: "+str(e), RNS.LOG_ERROR)
+                        self.shutdown_socket(self.socket)
+                        should_run = False
+                
+                if (time.time()-self.last_read > I2PInterfacePeer.I2P_READ_TIMEOUT):
+                    RNS.log("I2P socket is unresponsive, restarting...", RNS.LOG_WARNING)
+                    if self.socket != None:
+                        try:
+                            self.socket.shutdown(socket.SHUT_RDWR)
+                        except Exception as e:
+                            RNS.log("Error while shutting down socket for "+str(self)+": "+str(e))
+
+                        try:
+                            self.socket.close()
+                        except Exception as e:
+                            RNS.log("Error while closing socket for "+str(self)+": "+str(e))
+
+                    should_run = False
+
+                self.wd_reset = False
+
+        finally:
+            self.wd_reset = False
+
     def read_loop(self):
         try:
+            self.last_read  = time.time()
+            self.last_write = time.time()
+
+            wd_thread = threading.Thread(target=self.read_watchdog, daemon=True).start()
+
             in_frame = False
             escape = False
             data_buffer = b""
@@ -653,6 +724,7 @@ class I2PInterfacePeer(Interface):
                 data_in = self.socket.recv(4096)
                 if len(data_in) > 0:
                     pointer = 0
+                    self.last_read = time.time()
                     while pointer < len(data_in):
                         byte = data_in[pointer]
                         pointer += 1
@@ -705,6 +777,11 @@ class I2PInterfacePeer(Interface):
                                     data_buffer = data_buffer+bytes([byte])
                 else:
                     self.online = False
+
+                    self.wd_reset = True
+                    time.sleep(2)
+                    self.wd_reset = False
+
                     if self.initiator and not self.detached:
                         RNS.log("Socket for "+str(self)+" was closed, attempting to reconnect...", RNS.LOG_WARNING)
                         self.reconnect()
@@ -754,7 +831,7 @@ class I2PInterfacePeer(Interface):
 class I2PInterface(Interface):
     BITRATE_GUESS      = 256*1000
 
-    def __init__(self, owner, name, rns_storagepath, peers, connectable = False):
+    def __init__(self, owner, name, rns_storagepath, peers, connectable = False, ifac_size = 16, ifac_netname = None, ifac_netkey = None):
         self.rxb = 0
         self.txb = 0
         
@@ -780,6 +857,9 @@ class I2PInterface(Interface):
         self.bind_port   = self.i2p.get_free_port()
         self.address = (self.bind_ip, self.bind_port)
         self.bitrate = I2PInterface.BITRATE_GUESS
+        self.ifac_size = ifac_size
+        self.ifac_netname = ifac_netname
+        self.ifac_netkey = ifac_netkey
 
         self.online = False
 
@@ -850,9 +930,27 @@ class I2PInterface(Interface):
         spawned_interface.parent_interface = self
         spawned_interface.online = True
         spawned_interface.bitrate = self.bitrate
+
         spawned_interface.ifac_size = self.ifac_size
         spawned_interface.ifac_netname = self.ifac_netname
         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"))
+
+            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_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))
+
         spawned_interface.announce_rate_target = self.announce_rate_target
         spawned_interface.announce_rate_grace = self.announce_rate_grace
         spawned_interface.announce_rate_penalty = self.announce_rate_penalty

RNS/Interfaces/RNodeInterface.py

@@ -94,7 +94,7 @@ class RNodeInterface(Interface):
     CALLSIGN_MAX_LEN    = 32
 
     REQUIRED_FW_VER_MAJ = 1
-    REQUIRED_FW_VER_MIN = 51
+    REQUIRED_FW_VER_MIN = 52
 
     RECONNECT_WAIT = 5
 
@@ -275,7 +275,7 @@ class RNodeInterface(Interface):
         kiss_command = bytes([KISS.FEND, KISS.CMD_DETECT, KISS.DETECT_REQ, KISS.FEND, KISS.CMD_FW_VERSION, 0x00, KISS.FEND, KISS.CMD_PLATFORM, 0x00, KISS.FEND, KISS.CMD_MCU, 0x00, KISS.FEND])
         written = self.serial.write(kiss_command)
         if written != len(kiss_command):
-            raise IOError("An IO error occurred while detecting hardware for "+self(str))
+            raise IOError("An IO error occurred while detecting hardware for "+str(self))
     
     def leave(self):
         kiss_command = bytes([KISS.FEND, KISS.CMD_LEAVE, 0xFF, KISS.FEND])
@@ -338,7 +338,7 @@ class RNodeInterface(Interface):
         kiss_command = bytes([KISS.FEND])+bytes([KISS.CMD_FREQUENCY])+data+bytes([KISS.FEND])
         written = self.serial.write(kiss_command)
         if written != len(kiss_command):
-            raise IOError("An IO error occurred while configuring frequency for "+self(str))
+            raise IOError("An IO error occurred while configuring frequency for "+str(self))
 
     def setBandwidth(self):
         c1 = self.bandwidth >> 24
@@ -350,35 +350,35 @@ class RNodeInterface(Interface):
         kiss_command = bytes([KISS.FEND])+bytes([KISS.CMD_BANDWIDTH])+data+bytes([KISS.FEND])
         written = self.serial.write(kiss_command)
         if written != len(kiss_command):
-            raise IOError("An IO error occurred while configuring bandwidth for "+self(str))
+            raise IOError("An IO error occurred while configuring bandwidth for "+str(self))
 
     def setTXPower(self):
         txp = bytes([self.txpower])
         kiss_command = bytes([KISS.FEND])+bytes([KISS.CMD_TXPOWER])+txp+bytes([KISS.FEND])
         written = self.serial.write(kiss_command)
         if written != len(kiss_command):
-            raise IOError("An IO error occurred while configuring TX power for "+self(str))
+            raise IOError("An IO error occurred while configuring TX power for "+str(self))
 
     def setSpreadingFactor(self):
         sf = bytes([self.sf])
         kiss_command = bytes([KISS.FEND])+bytes([KISS.CMD_SF])+sf+bytes([KISS.FEND])
         written = self.serial.write(kiss_command)
         if written != len(kiss_command):
-            raise IOError("An IO error occurred while configuring spreading factor for "+self(str))
+            raise IOError("An IO error occurred while configuring spreading factor for "+str(self))
 
     def setCodingRate(self):
         cr = bytes([self.cr])
         kiss_command = bytes([KISS.FEND])+bytes([KISS.CMD_CR])+cr+bytes([KISS.FEND])
         written = self.serial.write(kiss_command)
         if written != len(kiss_command):
-            raise IOError("An IO error occurred while configuring coding rate for "+self(str))
+            raise IOError("An IO error occurred while configuring coding rate for "+str(self))
 
     def setRadioState(self, state):
         self.state = state
         kiss_command = bytes([KISS.FEND])+bytes([KISS.CMD_RADIO_STATE])+bytes([state])+bytes([KISS.FEND])
         written = self.serial.write(kiss_command)
         if written != len(kiss_command):
-            raise IOError("An IO error occurred while configuring radio state for "+self(str))
+            raise IOError("An IO error occurred while configuring radio state for "+str(self))
 
     def validate_firmware(self):
         if (self.maj_version >= RNodeInterface.REQUIRED_FW_VER_MAJ):

RNS/Interfaces/TCPInterface.py

@@ -483,9 +483,27 @@ class TCPServerInterface(Interface):
         spawned_interface.target_port = str(handler.client_address[1])
         spawned_interface.parent_interface = self
         spawned_interface.bitrate = self.bitrate
+        
         spawned_interface.ifac_size = self.ifac_size
         spawned_interface.ifac_netname = self.ifac_netname
         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"))
+
+            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_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))
+
         spawned_interface.announce_rate_target = self.announce_rate_target
         spawned_interface.announce_rate_grace = self.announce_rate_grace
         spawned_interface.announce_rate_penalty = self.announce_rate_penalty

RNS/Reticulum.py

@@ -631,12 +631,18 @@ class Reticulum:
                                     i2p_peers = c.as_list("peers") if "peers" in c else None
                                     connectable = c.as_bool("connectable") if "connectable" in c else False
 
+                                    if ifac_size == None:
+                                        ifac_size = 16
+
                                     interface = I2PInterface.I2PInterface(
                                         RNS.Transport,
                                         name,
                                         Reticulum.storagepath,
                                         i2p_peers,
                                         connectable = connectable,
+                                        ifac_size = ifac_size,
+                                        ifac_netname = ifac_netname,
+                                        ifac_netkey = ifac_netkey,
                                     )
 
                                     if "outgoing" in c and c.as_bool("outgoing") == False:
@@ -653,10 +659,6 @@ class Reticulum:
                                     interface.announce_cap = announce_cap
                                     if configured_bitrate:
                                         interface.bitrate = configured_bitrate
-                                    if ifac_size != None:
-                                        interface.ifac_size = ifac_size
-                                    else:
-                                        interface.ifac_size = 16
 
                                 if c["type"] == "SerialInterface":
                                     port = c["port"] if "port" in c else None
@@ -1071,6 +1073,19 @@ class Reticulum:
                     else:
                         ifstats["i2p_b32"] = None
 
+                if hasattr(interface, "i2p_tunnel_state"):
+                    if interface.i2p_tunnel_state != None:
+                        state_description = "Unknown State"
+                        if interface.i2p_tunnel_state == I2PInterface.I2PInterfacePeer.TUNNEL_STATE_ACTIVE:
+                            state_description = "Tunnel Active"
+                        elif interface.i2p_tunnel_state == I2PInterface.I2PInterfacePeer.TUNNEL_STATE_INIT:
+                            state_description = "Creating Tunnel"
+                        elif interface.i2p_tunnel_state == I2PInterface.I2PInterfacePeer.TUNNEL_STATE_STALE:
+                            state_description = "Tunnel Unresponsive"
+                        ifstats["tunnelstate"] = state_description
+                    else:
+                        ifstats["tunnelstate"] = None
+
                 if hasattr(interface, "bitrate"):
                     if interface.bitrate != None:
                         ifstats["bitrate"] = interface.bitrate

RNS/Transport.py

@@ -144,13 +144,14 @@ class Transport:
                 RNS.log("Loaded Transport Identity from storage", RNS.LOG_VERBOSE)
 
         packet_hashlist_path = RNS.Reticulum.storagepath+"/packet_hashlist"
-        if os.path.isfile(packet_hashlist_path):
-            try:
-                file = open(packet_hashlist_path, "rb")
-                Transport.packet_hashlist = umsgpack.unpackb(file.read())
-                file.close()
-            except Exception as e:
-                RNS.log("Could not load packet hashlist from storage, the contained exception was: "+str(e), RNS.LOG_ERROR)
+        if not Transport.owner.is_connected_to_shared_instance:
+            if os.path.isfile(packet_hashlist_path):
+                try:
+                    file = open(packet_hashlist_path, "rb")
+                    Transport.packet_hashlist = umsgpack.unpackb(file.read())
+                    file.close()
+                except Exception as e:
+                    RNS.log("Could not load packet hashlist from storage, the contained exception was: "+str(e), RNS.LOG_ERROR)
 
         # Create transport-specific destinations
         Transport.path_request_destination = RNS.Destination(None, RNS.Destination.IN, RNS.Destination.PLAIN, Transport.APP_NAME, "path", "request")
@@ -833,7 +834,7 @@ class Transport:
     def inbound(raw, interface=None):
         # If interface access codes are enabled,
         # we must authenticate each packet.
-        if len(raw) > 1:
+        if len(raw) > 2:
             if interface != None and hasattr(interface, "ifac_identity") and interface.ifac_identity != None:
                 # Check that IFAC flag is set
                 if raw[0] & 0x80 == 0x80:
@@ -871,6 +872,9 @@ class Transport:
                     # If the flag is set, drop the packet
                     return
 
+        else:
+            return
+
         while (Transport.jobs_running):
             sleep(0.0005)
 
@@ -2078,41 +2082,42 @@ class Transport:
 
     @staticmethod
     def save_packet_hashlist():
-        if hasattr(Transport, "saving_packet_hashlist"):
-            wait_interval = 0.2
-            wait_timeout = 5
-            wait_start = time.time()
-            while Transport.saving_packet_hashlist:
-                time.sleep(wait_interval)
-                if time.time() > wait_start+wait_timeout:
-                    RNS.log("Could not save packet hashlist to storage, waiting for previous save operation timed out.", RNS.LOG_ERROR)
-                    return False
+        if not Transport.owner.is_connected_to_shared_instance:
+            if hasattr(Transport, "saving_packet_hashlist"):
+                wait_interval = 0.2
+                wait_timeout = 5
+                wait_start = time.time()
+                while Transport.saving_packet_hashlist:
+                    time.sleep(wait_interval)
+                    if time.time() > wait_start+wait_timeout:
+                        RNS.log("Could not save packet hashlist to storage, waiting for previous save operation timed out.", RNS.LOG_ERROR)
+                        return False
 
-        try:
-            Transport.saving_packet_hashlist = True
-            save_start = time.time()
+            try:
+                Transport.saving_packet_hashlist = True
+                save_start = time.time()
 
-            if not RNS.Reticulum.transport_enabled():
-                Transport.packet_hashlist = []
-            else:
-                RNS.log("Saving packet hashlist to storage...", RNS.LOG_DEBUG)
+                if not RNS.Reticulum.transport_enabled():
+                    Transport.packet_hashlist = []
+                else:
+                    RNS.log("Saving packet hashlist to storage...", RNS.LOG_DEBUG)
 
-            packet_hashlist_path = RNS.Reticulum.storagepath+"/packet_hashlist"
-            file = open(packet_hashlist_path, "wb")
-            file.write(umsgpack.packb(Transport.packet_hashlist))
-            file.close()
+                packet_hashlist_path = RNS.Reticulum.storagepath+"/packet_hashlist"
+                file = open(packet_hashlist_path, "wb")
+                file.write(umsgpack.packb(Transport.packet_hashlist))
+                file.close()
 
-            save_time = time.time() - save_start
-            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 packet hashlist in "+time_str, RNS.LOG_DEBUG)
+                save_time = time.time() - save_start
+                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 packet hashlist in "+time_str, RNS.LOG_DEBUG)
 
-        except Exception as e:
-            RNS.log("Could not save packet hashlist to storage, the contained exception was: "+str(e), RNS.LOG_ERROR)
+            except Exception as e:
+                RNS.log("Could not save packet hashlist to storage, the contained exception was: "+str(e), RNS.LOG_ERROR)
 
-        Transport.saving_packet_hashlist = False
+            Transport.saving_packet_hashlist = False
 
 
     @staticmethod

RNS/Utilities/rnodeconf.py

@@ -91,6 +91,7 @@ class KISS():
     CMD_DEV_HASH    = 0x56
     CMD_DEV_SIG     = 0x57
     CMD_FW_HASH     = 0x58
+    CMD_FW_UPD      = 0x61
 
     DETECT_REQ      = 0x73
     DETECT_RESP     = 0x46
@@ -217,7 +218,7 @@ UPD_DIR = None
 FWD_DIR = None
 
 try:
-    CNF_DIR = os.path.expanduser("~/.local/rnodeconf")
+    CNF_DIR = os.path.expanduser("~/.config/rnodeconf")
     UPD_DIR = CNF_DIR+"/update"
     FWD_DIR = CNF_DIR+"/firmware"
 
@@ -551,6 +552,13 @@ class RNode():
         if written != len(kiss_command):
             raise IOError("An IO error occurred while sending firmware hash to device")
 
+    def indicate_firmware_update(self):
+        kiss_command = bytes([KISS.FEND])+bytes([KISS.CMD_FW_UPD])+bytes([0x01])+bytes([KISS.FEND])
+
+        written = self.serial.write(kiss_command)
+        if written != len(kiss_command):
+            raise IOError("An IO error occurred while sending firmware update command to device")
+
     def initRadio(self):
         self.setFrequency()
         self.setBandwidth()
@@ -898,7 +906,7 @@ def ensure_firmware_file(fw_filename):
                     pass
                 else:
                     RNS.log("")
-                    RNS.log("Firmware corrupt.")
+                    RNS.log("Firmware corrupt. Try clearing the local firmware cache with: rnodeconf --clear-cache")
                     exit(96)
 
             except Exception as e:
@@ -1917,6 +1925,8 @@ def main():
                         partition_hash = get_partition_hash(UPD_DIR+"/"+selected_version+"/"+partition_filename)
                         if partition_hash != None:
                             rnode.set_firmware_hash(partition_hash)
+                            rnode.indicate_firmware_update()
+                            sleep(1)
 
                         rnode.disconnect()
                         flash_status = call(get_flasher_call(rnode.platform, fw_filename))
@@ -1994,14 +2004,17 @@ def main():
             if args.bluetooth_on:
                 RNS.log("Enabling Bluetooth...")
                 rnode.enable_bluetooth()
+                rnode.leave()
 
             if args.bluetooth_off:
                 RNS.log("Disabling Bluetooth...")
                 rnode.disable_bluetooth()
+                rnode.leave()
 
             if args.bluetooth_pair:
                 RNS.log("Putting device into Bluetooth pairing mode...")
                 rnode.bluetooth_pair()
+                rnode.leave()
 
             if args.info:
                 if rnode.provisioned:
@@ -2178,7 +2191,6 @@ def main():
 
 
                             RNS.log("Bootstrapping device EEPROM...")
-                            rnode.hard_reset()
 
                             rnode.write_eeprom(ROM.ADDR_PRODUCT, mapped_product)
                             time.sleep(0.006)
@@ -2216,16 +2228,15 @@ def main():
                             RNS.log("EEPROM written! Validating...")
 
                             if wants_fw_provision:
-                                RNS.log("Getting partition data...")
                                 partition_filename = fw_filename.replace(".zip", ".bin")
                                 partition_hash = get_partition_hash(UPD_DIR+"/"+selected_version+"/"+partition_filename)
                                 if partition_hash != None:
-                                    RNS.log("Setting firmware partition hash target")
                                     rnode.set_firmware_hash(partition_hash)
 
+                            rnode.hard_reset()
                             if rnode.platform == ROM.PLATFORM_ESP32:
                                 RNS.log("Waiting for ESP32 reset...")
-                                time.sleep(5)
+                                time.sleep(6.5)
 
                             rnode.download_eeprom()
                             if rnode.provisioned:

RNS/Utilities/rnstatus.py

@@ -135,6 +135,9 @@ def program_setup(configdir, dispall=False, verbosity=0, name_filter=None):
                         if "peers" in ifstat and ifstat["peers"] != None:
                             print("    Peers   : {np} reachable".format(np=ifstat["peers"]))
 
+                        if "tunnelstate" in ifstat and ifstat["tunnelstate"] != None:
+                            print("    I2P     : {ts}".format(ts=ifstat["tunnelstate"]))
+
                         if "ifac_signature" in ifstat and ifstat["ifac_signature"] != None:
                             sigstr = "<…"+RNS.hexrep(ifstat["ifac_signature"][-5:], delimit=False)+">"
                             print("    Access  : {nb}-bit IFAC by {sig}".format(nb=ifstat["ifac_size"]*8, sig=sigstr))

RNS/__init__.py

@@ -217,7 +217,10 @@ def prettytime(time, verbose=False):
 
         tstr += c
 
-    return tstr
+    if tstr == "":
+        return "0s"
+    else:
+        return tstr
 
 def phyparams():
     print("Required Physical Layer MTU : "+str(Reticulum.MTU)+" bytes")

RNS/_version.py

@@ -1 +1 @@
-__version__ = "0.3.18"
+__version__ = "0.4.2"

Roadmap.md

@@ -0,0 +1,106 @@
+# Reticulum Development Roadmap
+The development path for Reticulum is currently laid out in five distinct areas: *Comprehensibility*, *Universality*, *Functionality*, *Usability & Utility* and *Interfaceability*. Conceptualising the development of Reticulum into these areas serves to advance the implementation and work towards the Foundational Goals & Values of Reticulum.
+
+## Comprehensibility
+These efforts are aimed at improving the ease of which Reticulum is understood, and lowering the barrier to entry for people who wish to start building systems on Reticulum.
+
+- Improving [the manual](https://markqvist.github.io/Reticulum/manual/) with tutorials specifically for beginners
+- Updating the documentation to reflect recent changes and improvements
+    - Update descriptions of protocol mechanics
+        - Update announce description
+        - Add in-depth explanation of the IFAC system
+    - Software
+        - Update Sideband screenshots
+        - Update Sideband description
+        - Update NomadNet screenshots
+        - Update Sideband screenshots
+    - Installation
+        - Install docs for fedora, needs `python3-netifaces`
+        - Add a *Reticulum On Raspberry Pi* section
+        - Update *Reticulum On Android* section if necessary
+        - Update Android install documentation.
+    - Communications hardware section
+        - Add information about RNode external displays.
+        - Packet radio modems.
+        - Possibly add other relevant types here as well.
+    - Setup *Best Practices For...* / *Installation Examples* section.
+        - Home or office (example)
+        - Vehicles (example)
+        - No-grid/solar/remote sites (example)
+
+## Universality
+These efforts seek to broaden the universality of the Reticulum software and hardware ecosystem by continously diversifying platform support, and by improving the overall availability and ease of deployment of the Reticulum stack.
+
+- Improved roaming support on Android
+- OpenWRT support
+- Create a standalone RNS Daemon app for Android
+- A lightweight and portable C implementation for microcontrollers, µRNS
+- A portable, high-performance Reticulum implementation in C/C++, see [#21](https://github.com/markqvist/Reticulum/discussions/21)
+- Performance and memory optimisations of the Python implementation
+- Bindings for other programming languages
+
+## Functionality
+These efforts aim to expand and improve the core functionality and reliability of Reticulum.
+
+- Improve storage persist call on local client connect/disconnect
+- Faster path invalidation on physical topography changes
+- Better path invalidation on roaming interfaces
+- Network-wide path balancing
+- Distributed Destination Naming System
+- Globally routable multicast
+- Destination proxying: Create a new random destination, and sign it with the original destination to create verifiable ephemeral destinations. This could actually be a very powerful feature for aggregating routes in the network, and it retains destination owners control over how they are routed
+- [Metric-based path selection and multiple paths](https://github.com/markqvist/Reticulum/discussions/86)
+
+## Usability & Utility
+These effors seek to make Reticulum easier to use and operate, and to expand the utility of the stack on deployed systems.
+
+- Add bluetooth pairing code output to rnodeconf
+- Easy way to share interface configurations, see [#19](https://github.com/markqvist/Reticulum/discussions/19)
+- Transit traffic display in rnstatus
+- JSON output mode for rnstatus
+- rnid utility
+- rnsign utility
+- rncrypt utility
+- rnsconfig utility
+- Expand rnx utility to true interactive remote shell
+
+## Interfaceability
+These efforts aim to expand the types of physical and virtual interfaces that Reticulum can natively use to transport data.
+
+- Filesystem interface
+- Plain ESP32 devices (ESP-Now, WiFi, Bluetooth, etc.)
+- More LoRa transceivers
+- AT-compatible modems
+- Direct SDR Support
+- Optical mediums
+- IR Transceivers
+- AWDL / OWL
+- HF Modems
+- GNU Radio
+- CAN-bus
+- Raw SPI
+- Raw i²c
+- MQTT
+- XBee
+- Tor
+
+## Active Work Areas
+For each release cycle of Reticulum, improvements and additions from the five areas are selected as active work areas, and can be expected to be included in the upcoming releases within that cycle. While not entirely set in stone for each release cycle, they serve as a pointer of what to expect in the near future.
+
+- The current `0.4.x` release cycle aims at completing:
+  - [x] Improve storage persist call on local client connect/disconnect
+  - [x] Improved roaming support on Android
+  - [ ] Updating the documentation to reflect recent changes and improvements
+  - [ ] Add bluetooth pairing code output to rnodeconf
+  - [ ] Improve storage persist call on every local client connect/disconnect
+  - [ ] Transit traffic display in rnstatus
+  - [ ] JSON output mode for rnstatus
+  - [ ] Add `rnid` utility
+  - [ ] Add `rnsign` utility
+  - [ ] Add `rncrypt` utility
+  - [ ] Create a standalone RNS Daemon app for Android
+- Targets for related applications
+  - [x] Add paper offline & paper message transport to LXMF
+  - [x] Implement paper messaging in Nomad Network
+  - [x] Implement paper messaging in Sideband
+  - [x] Expand device support in Sideband to support older Android devices

docs/manual/.buildinfo

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

docs/manual/_sources/understanding.rst.txt

@@ -771,7 +771,7 @@ Wire Format
     |               | |               | |               | |    |
     00000000 00000111 [HASH1, 16 bytes] [CONTEXT, 1 byte] [DATA]
     || | | |    |
-    || | | |    +-- Hops             = 0
+    || | | |    +-- Hops             = 7
     || | | +------- Packet Type      = DATA
     || | +--------- Destination Type = SINGLE
     || +----------- Propagation Type = BROADCAST
@@ -786,7 +786,7 @@ Wire Format
     |               | |             | |               | |               | |    |
     10000000 00000111 [IFAC, N bytes] [HASH1, 16 bytes] [CONTEXT, 1 byte] [DATA]
     || | | |    |
-    || | | |    +-- Hops             = 0
+    || | | |    +-- Hops             = 7
     || | | +------- Packet Type      = DATA
     || | +--------- Destination Type = SINGLE
     || +----------- Propagation Type = BROADCAST

docs/manual/_static/documentation_options.js

@@ -1,6 +1,6 @@
 var DOCUMENTATION_OPTIONS = {
     URL_ROOT: document.getElementById("documentation_options").getAttribute('data-url_root'),
-    VERSION: '0.3.18 beta',
+    VERSION: '0.4.2 beta',
     LANGUAGE: 'en',
     COLLAPSE_INDEX: false,
     BUILDER: 'html',

docs/manual/examples.html

@@ -6,7 +6,7 @@
 <link rel="index" title="Index" href="genindex.html" /><link rel="search" title="Search" href="search.html" /><link rel="next" title="Support Reticulum" href="support.html" /><link rel="prev" title="Building Networks" href="networks.html" />
 
     <meta name="generator" content="sphinx-5.2.2, furo 2022.09.29"/>
-        <title>Code Examples - Reticulum Network Stack 0.3.18 beta documentation</title>
+        <title>Code Examples - Reticulum Network Stack 0.4.2 beta documentation</title>
       <link rel="stylesheet" type="text/css" href="_static/pygments.css" />
     <link rel="stylesheet" type="text/css" href="_static/styles/furo.css?digest=d81277517bee4d6b0349d71bb2661d4890b5617c" />
     <link rel="stylesheet" type="text/css" href="_static/copybutton.css" />
@@ -141,7 +141,7 @@
       </label>
     </div>
     <div class="header-center">
-      <a href="index.html"><div class="brand">Reticulum Network Stack 0.3.18 beta documentation</div></a>
+      <a href="index.html"><div class="brand">Reticulum Network Stack 0.4.2 beta documentation</div></a>
     </div>
     <div class="header-right">
       <div class="theme-toggle-container theme-toggle-header">
@@ -167,7 +167,7 @@
     <img class="sidebar-logo" src="_static/rns_logo_512.png" alt="Logo"/>
   </div>
   
-  <span class="sidebar-brand-text">Reticulum Network Stack 0.3.18 beta documentation</span>
+  <span class="sidebar-brand-text">Reticulum Network Stack 0.4.2 beta 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">

docs/manual/genindex.html

@@ -4,7 +4,7 @@
     <meta name="viewport" content="width=device-width,initial-scale=1"/>
     <meta name="color-scheme" content="light dark"><link rel="index" title="Index" href="#" /><link rel="search" title="Search" href="search.html" />
 
-    <meta name="generator" content="sphinx-5.2.2, furo 2022.09.29"/><title>Index - Reticulum Network Stack 0.3.18 beta documentation</title>
+    <meta name="generator" content="sphinx-5.2.2, furo 2022.09.29"/><title>Index - Reticulum Network Stack 0.4.2 beta documentation</title>
 <link rel="stylesheet" type="text/css" href="_static/pygments.css" />
     <link rel="stylesheet" type="text/css" href="_static/styles/furo.css?digest=d81277517bee4d6b0349d71bb2661d4890b5617c" />
     <link rel="stylesheet" type="text/css" href="_static/copybutton.css" />
@@ -139,7 +139,7 @@
       </label>
     </div>
     <div class="header-center">
-      <a href="index.html"><div class="brand">Reticulum Network Stack 0.3.18 beta documentation</div></a>
+      <a href="index.html"><div class="brand">Reticulum Network Stack 0.4.2 beta documentation</div></a>
     </div>
     <div class="header-right">
       <div class="theme-toggle-container theme-toggle-header">
@@ -165,7 +165,7 @@
     <img class="sidebar-logo" src="_static/rns_logo_512.png" alt="Logo"/>
   </div>
   
-  <span class="sidebar-brand-text">Reticulum Network Stack 0.3.18 beta documentation</span>
+  <span class="sidebar-brand-text">Reticulum Network Stack 0.4.2 beta 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">

docs/manual/gettingstartedfast.html

@@ -6,7 +6,7 @@
 <link rel="index" title="Index" href="genindex.html" /><link rel="search" title="Search" href="search.html" /><link rel="next" title="Using Reticulum on Your System" href="using.html" /><link rel="prev" title="What is Reticulum?" href="whatis.html" />
 
     <meta name="generator" content="sphinx-5.2.2, furo 2022.09.29"/>
-        <title>Getting Started Fast - Reticulum Network Stack 0.3.18 beta documentation</title>
+        <title>Getting Started Fast - Reticulum Network Stack 0.4.2 beta documentation</title>
       <link rel="stylesheet" type="text/css" href="_static/pygments.css" />
     <link rel="stylesheet" type="text/css" href="_static/styles/furo.css?digest=d81277517bee4d6b0349d71bb2661d4890b5617c" />
     <link rel="stylesheet" type="text/css" href="_static/copybutton.css" />
@@ -141,7 +141,7 @@
       </label>
     </div>
     <div class="header-center">
-      <a href="index.html"><div class="brand">Reticulum Network Stack 0.3.18 beta documentation</div></a>
+      <a href="index.html"><div class="brand">Reticulum Network Stack 0.4.2 beta documentation</div></a>
     </div>
     <div class="header-right">
       <div class="theme-toggle-container theme-toggle-header">
@@ -167,7 +167,7 @@
     <img class="sidebar-logo" src="_static/rns_logo_512.png" alt="Logo"/>
   </div>
   
-  <span class="sidebar-brand-text">Reticulum Network Stack 0.3.18 beta documentation</span>
+  <span class="sidebar-brand-text">Reticulum Network Stack 0.4.2 beta 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">

docs/manual/hardware.html

@@ -6,7 +6,7 @@
 <link rel="index" title="Index" href="genindex.html" /><link rel="search" title="Search" href="search.html" /><link rel="next" title="Supported Interfaces" href="interfaces.html" /><link rel="prev" title="Understanding Reticulum" href="understanding.html" />
 
     <meta name="generator" content="sphinx-5.2.2, furo 2022.09.29"/>
-        <title>Communications Hardware - Reticulum Network Stack 0.3.18 beta documentation</title>
+        <title>Communications Hardware - Reticulum Network Stack 0.4.2 beta documentation</title>
       <link rel="stylesheet" type="text/css" href="_static/pygments.css" />
     <link rel="stylesheet" type="text/css" href="_static/styles/furo.css?digest=d81277517bee4d6b0349d71bb2661d4890b5617c" />
     <link rel="stylesheet" type="text/css" href="_static/copybutton.css" />
@@ -141,7 +141,7 @@
       </label>
     </div>
     <div class="header-center">
-      <a href="index.html"><div class="brand">Reticulum Network Stack 0.3.18 beta documentation</div></a>
+      <a href="index.html"><div class="brand">Reticulum Network Stack 0.4.2 beta documentation</div></a>
     </div>
     <div class="header-right">
       <div class="theme-toggle-container theme-toggle-header">
@@ -167,7 +167,7 @@
     <img class="sidebar-logo" src="_static/rns_logo_512.png" alt="Logo"/>
   </div>
   
-  <span class="sidebar-brand-text">Reticulum Network Stack 0.3.18 beta documentation</span>
+  <span class="sidebar-brand-text">Reticulum Network Stack 0.4.2 beta 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">

docs/manual/index.html

@@ -6,7 +6,7 @@
 <link rel="index" title="Index" href="genindex.html" /><link rel="search" title="Search" href="search.html" /><link rel="next" title="What is Reticulum?" href="whatis.html" />
 
     <meta name="generator" content="sphinx-5.2.2, furo 2022.09.29"/>
-        <title>Reticulum Network Stack 0.3.18 beta documentation</title>
+        <title>Reticulum Network Stack 0.4.2 beta documentation</title>
       <link rel="stylesheet" type="text/css" href="_static/pygments.css" />
     <link rel="stylesheet" type="text/css" href="_static/styles/furo.css?digest=d81277517bee4d6b0349d71bb2661d4890b5617c" />
     <link rel="stylesheet" type="text/css" href="_static/copybutton.css" />
@@ -141,7 +141,7 @@
       </label>
     </div>
     <div class="header-center">
-      <a href="#"><div class="brand">Reticulum Network Stack 0.3.18 beta documentation</div></a>
+      <a href="#"><div class="brand">Reticulum Network Stack 0.4.2 beta documentation</div></a>
     </div>
     <div class="header-right">
       <div class="theme-toggle-container theme-toggle-header">
@@ -167,7 +167,7 @@
     <img class="sidebar-logo" src="_static/rns_logo_512.png" alt="Logo"/>
   </div>
   
-  <span class="sidebar-brand-text">Reticulum Network Stack 0.3.18 beta documentation</span>
+  <span class="sidebar-brand-text">Reticulum Network Stack 0.4.2 beta 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">

docs/manual/interfaces.html

@@ -6,7 +6,7 @@
 <link rel="index" title="Index" href="genindex.html" /><link rel="search" title="Search" href="search.html" /><link rel="next" title="Building Networks" href="networks.html" /><link rel="prev" title="Communications Hardware" href="hardware.html" />
 
     <meta name="generator" content="sphinx-5.2.2, furo 2022.09.29"/>
-        <title>Supported Interfaces - Reticulum Network Stack 0.3.18 beta documentation</title>
+        <title>Supported Interfaces - Reticulum Network Stack 0.4.2 beta documentation</title>
       <link rel="stylesheet" type="text/css" href="_static/pygments.css" />
     <link rel="stylesheet" type="text/css" href="_static/styles/furo.css?digest=d81277517bee4d6b0349d71bb2661d4890b5617c" />
     <link rel="stylesheet" type="text/css" href="_static/copybutton.css" />
@@ -141,7 +141,7 @@
       </label>
     </div>
     <div class="header-center">
-      <a href="index.html"><div class="brand">Reticulum Network Stack 0.3.18 beta documentation</div></a>
+      <a href="index.html"><div class="brand">Reticulum Network Stack 0.4.2 beta documentation</div></a>
     </div>
     <div class="header-right">
       <div class="theme-toggle-container theme-toggle-header">
@@ -167,7 +167,7 @@
     <img class="sidebar-logo" src="_static/rns_logo_512.png" alt="Logo"/>
   </div>
   
-  <span class="sidebar-brand-text">Reticulum Network Stack 0.3.18 beta documentation</span>
+  <span class="sidebar-brand-text">Reticulum Network Stack 0.4.2 beta 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">

docs/manual/networks.html

@@ -6,7 +6,7 @@
 <link rel="index" title="Index" href="genindex.html" /><link rel="search" title="Search" href="search.html" /><link rel="next" title="Code Examples" href="examples.html" /><link rel="prev" title="Supported Interfaces" href="interfaces.html" />
 
     <meta name="generator" content="sphinx-5.2.2, furo 2022.09.29"/>
-        <title>Building Networks - Reticulum Network Stack 0.3.18 beta documentation</title>
+        <title>Building Networks - Reticulum Network Stack 0.4.2 beta documentation</title>
       <link rel="stylesheet" type="text/css" href="_static/pygments.css" />
     <link rel="stylesheet" type="text/css" href="_static/styles/furo.css?digest=d81277517bee4d6b0349d71bb2661d4890b5617c" />
     <link rel="stylesheet" type="text/css" href="_static/copybutton.css" />
@@ -141,7 +141,7 @@
       </label>
     </div>
     <div class="header-center">
-      <a href="index.html"><div class="brand">Reticulum Network Stack 0.3.18 beta documentation</div></a>
+      <a href="index.html"><div class="brand">Reticulum Network Stack 0.4.2 beta documentation</div></a>
     </div>
     <div class="header-right">
       <div class="theme-toggle-container theme-toggle-header">
@@ -167,7 +167,7 @@
     <img class="sidebar-logo" src="_static/rns_logo_512.png" alt="Logo"/>
   </div>
   
-  <span class="sidebar-brand-text">Reticulum Network Stack 0.3.18 beta documentation</span>
+  <span class="sidebar-brand-text">Reticulum Network Stack 0.4.2 beta 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">

docs/manual/reference.html

@@ -6,7 +6,7 @@
 <link rel="index" title="Index" href="genindex.html" /><link rel="search" title="Search" href="search.html" /><link rel="prev" title="Support Reticulum" href="support.html" />
 
     <meta name="generator" content="sphinx-5.2.2, furo 2022.09.29"/>
-        <title>API Reference - Reticulum Network Stack 0.3.18 beta documentation</title>
+        <title>API Reference - Reticulum Network Stack 0.4.2 beta documentation</title>
       <link rel="stylesheet" type="text/css" href="_static/pygments.css" />
     <link rel="stylesheet" type="text/css" href="_static/styles/furo.css?digest=d81277517bee4d6b0349d71bb2661d4890b5617c" />
     <link rel="stylesheet" type="text/css" href="_static/copybutton.css" />
@@ -141,7 +141,7 @@
       </label>
     </div>
     <div class="header-center">
-      <a href="index.html"><div class="brand">Reticulum Network Stack 0.3.18 beta documentation</div></a>
+      <a href="index.html"><div class="brand">Reticulum Network Stack 0.4.2 beta documentation</div></a>
     </div>
     <div class="header-right">
       <div class="theme-toggle-container theme-toggle-header">
@@ -167,7 +167,7 @@
     <img class="sidebar-logo" src="_static/rns_logo_512.png" alt="Logo"/>
   </div>
   
-  <span class="sidebar-brand-text">Reticulum Network Stack 0.3.18 beta documentation</span>
+  <span class="sidebar-brand-text">Reticulum Network Stack 0.4.2 beta 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">

docs/manual/search.html

@@ -4,7 +4,7 @@
     <meta name="viewport" content="width=device-width,initial-scale=1"/>
     <meta name="color-scheme" content="light dark"><link rel="index" title="Index" href="genindex.html" /><link rel="search" title="Search" href="#" />
 
-    <meta name="generator" content="sphinx-5.2.2, furo 2022.09.29"/><title>Search - Reticulum Network Stack 0.3.18 beta documentation</title><link rel="stylesheet" type="text/css" href="_static/pygments.css" />
+    <meta name="generator" content="sphinx-5.2.2, furo 2022.09.29"/><title>Search - Reticulum Network Stack 0.4.2 beta documentation</title><link rel="stylesheet" type="text/css" href="_static/pygments.css" />
     <link rel="stylesheet" type="text/css" href="_static/styles/furo.css?digest=d81277517bee4d6b0349d71bb2661d4890b5617c" />
     <link rel="stylesheet" type="text/css" href="_static/copybutton.css" />
     <link rel="stylesheet" type="text/css" href="_static/styles/furo-extensions.css?digest=30d1aed668e5c3a91c3e3bf6a60b675221979f0e" />
@@ -138,7 +138,7 @@
       </label>
     </div>
     <div class="header-center">
-      <a href="index.html"><div class="brand">Reticulum Network Stack 0.3.18 beta documentation</div></a>
+      <a href="index.html"><div class="brand">Reticulum Network Stack 0.4.2 beta documentation</div></a>
     </div>
     <div class="header-right">
       <div class="theme-toggle-container theme-toggle-header">
@@ -164,7 +164,7 @@
     <img class="sidebar-logo" src="_static/rns_logo_512.png" alt="Logo"/>
   </div>
   
-  <span class="sidebar-brand-text">Reticulum Network Stack 0.3.18 beta documentation</span>
+  <span class="sidebar-brand-text">Reticulum Network Stack 0.4.2 beta documentation</span>
   
 </a><form class="sidebar-search-container" method="get" action="#" role="search">
   <input class="sidebar-search" placeholder=Search name="q" aria-label="Search">

docs/manual/support.html

@@ -6,7 +6,7 @@
 <link rel="index" title="Index" href="genindex.html" /><link rel="search" title="Search" href="search.html" /><link rel="next" title="API Reference" href="reference.html" /><link rel="prev" title="Code Examples" href="examples.html" />
 
     <meta name="generator" content="sphinx-5.2.2, furo 2022.09.29"/>
-        <title>Support Reticulum - Reticulum Network Stack 0.3.18 beta documentation</title>
+        <title>Support Reticulum - Reticulum Network Stack 0.4.2 beta documentation</title>
       <link rel="stylesheet" type="text/css" href="_static/pygments.css" />
     <link rel="stylesheet" type="text/css" href="_static/styles/furo.css?digest=d81277517bee4d6b0349d71bb2661d4890b5617c" />
     <link rel="stylesheet" type="text/css" href="_static/copybutton.css" />
@@ -141,7 +141,7 @@
       </label>
     </div>
     <div class="header-center">
-      <a href="index.html"><div class="brand">Reticulum Network Stack 0.3.18 beta documentation</div></a>
+      <a href="index.html"><div class="brand">Reticulum Network Stack 0.4.2 beta documentation</div></a>
     </div>
     <div class="header-right">
       <div class="theme-toggle-container theme-toggle-header">
@@ -167,7 +167,7 @@
     <img class="sidebar-logo" src="_static/rns_logo_512.png" alt="Logo"/>
   </div>
   
-  <span class="sidebar-brand-text">Reticulum Network Stack 0.3.18 beta documentation</span>
+  <span class="sidebar-brand-text">Reticulum Network Stack 0.4.2 beta 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">

docs/manual/understanding.html

@@ -6,7 +6,7 @@
 <link rel="index" title="Index" href="genindex.html" /><link rel="search" title="Search" href="search.html" /><link rel="next" title="Communications Hardware" href="hardware.html" /><link rel="prev" title="Using Reticulum on Your System" href="using.html" />
 
     <meta name="generator" content="sphinx-5.2.2, furo 2022.09.29"/>
-        <title>Understanding Reticulum - Reticulum Network Stack 0.3.18 beta documentation</title>
+        <title>Understanding Reticulum - Reticulum Network Stack 0.4.2 beta documentation</title>
       <link rel="stylesheet" type="text/css" href="_static/pygments.css" />
     <link rel="stylesheet" type="text/css" href="_static/styles/furo.css?digest=d81277517bee4d6b0349d71bb2661d4890b5617c" />
     <link rel="stylesheet" type="text/css" href="_static/copybutton.css" />
@@ -141,7 +141,7 @@
       </label>
     </div>
     <div class="header-center">
-      <a href="index.html"><div class="brand">Reticulum Network Stack 0.3.18 beta documentation</div></a>
+      <a href="index.html"><div class="brand">Reticulum Network Stack 0.4.2 beta documentation</div></a>
     </div>
     <div class="header-right">
       <div class="theme-toggle-container theme-toggle-header">
@@ -167,7 +167,7 @@
     <img class="sidebar-logo" src="_static/rns_logo_512.png" alt="Logo"/>
   </div>
   
-  <span class="sidebar-brand-text">Reticulum Network Stack 0.3.18 beta documentation</span>
+  <span class="sidebar-brand-text">Reticulum Network Stack 0.4.2 beta 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">
@@ -1005,7 +1005,7 @@ proof           11
 |               | |               | |               | |    |
 00000000 00000111 [HASH1, 16 bytes] [CONTEXT, 1 byte] [DATA]
 || | | |    |
-|| | | |    +-- Hops             = 0
+|| | | |    +-- Hops             = 7
 || | | +------- Packet Type      = DATA
 || | +--------- Destination Type = SINGLE
 || +----------- Propagation Type = BROADCAST
@@ -1020,7 +1020,7 @@ proof           11
 |               | |             | |               | |               | |    |
 10000000 00000111 [IFAC, N bytes] [HASH1, 16 bytes] [CONTEXT, 1 byte] [DATA]
 || | | |    |
-|| | | |    +-- Hops             = 0
+|| | | |    +-- Hops             = 7
 || | | +------- Packet Type      = DATA
 || | +--------- Destination Type = SINGLE
 || +----------- Propagation Type = BROADCAST

docs/manual/using.html

@@ -6,7 +6,7 @@
 <link rel="index" title="Index" href="genindex.html" /><link rel="search" title="Search" href="search.html" /><link rel="next" title="Understanding Reticulum" href="understanding.html" /><link rel="prev" title="Getting Started Fast" href="gettingstartedfast.html" />
 
     <meta name="generator" content="sphinx-5.2.2, furo 2022.09.29"/>
-        <title>Using Reticulum on Your System - Reticulum Network Stack 0.3.18 beta documentation</title>
+        <title>Using Reticulum on Your System - Reticulum Network Stack 0.4.2 beta documentation</title>
       <link rel="stylesheet" type="text/css" href="_static/pygments.css" />
     <link rel="stylesheet" type="text/css" href="_static/styles/furo.css?digest=d81277517bee4d6b0349d71bb2661d4890b5617c" />
     <link rel="stylesheet" type="text/css" href="_static/copybutton.css" />
@@ -141,7 +141,7 @@
       </label>
     </div>
     <div class="header-center">
-      <a href="index.html"><div class="brand">Reticulum Network Stack 0.3.18 beta documentation</div></a>
+      <a href="index.html"><div class="brand">Reticulum Network Stack 0.4.2 beta documentation</div></a>
     </div>
     <div class="header-right">
       <div class="theme-toggle-container theme-toggle-header">
@@ -167,7 +167,7 @@
     <img class="sidebar-logo" src="_static/rns_logo_512.png" alt="Logo"/>
   </div>
   
-  <span class="sidebar-brand-text">Reticulum Network Stack 0.3.18 beta documentation</span>
+  <span class="sidebar-brand-text">Reticulum Network Stack 0.4.2 beta 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">

docs/manual/whatis.html

@@ -6,7 +6,7 @@
 <link rel="index" title="Index" href="genindex.html" /><link rel="search" title="Search" href="search.html" /><link rel="next" title="Getting Started Fast" href="gettingstartedfast.html" /><link rel="prev" title="Reticulum Network Stack Manual" href="index.html" />
 
     <meta name="generator" content="sphinx-5.2.2, furo 2022.09.29"/>
-        <title>What is Reticulum? - Reticulum Network Stack 0.3.18 beta documentation</title>
+        <title>What is Reticulum? - Reticulum Network Stack 0.4.2 beta documentation</title>
       <link rel="stylesheet" type="text/css" href="_static/pygments.css" />
     <link rel="stylesheet" type="text/css" href="_static/styles/furo.css?digest=d81277517bee4d6b0349d71bb2661d4890b5617c" />
     <link rel="stylesheet" type="text/css" href="_static/copybutton.css" />
@@ -141,7 +141,7 @@
       </label>
     </div>
     <div class="header-center">
-      <a href="index.html"><div class="brand">Reticulum Network Stack 0.3.18 beta documentation</div></a>
+      <a href="index.html"><div class="brand">Reticulum Network Stack 0.4.2 beta documentation</div></a>
     </div>
     <div class="header-right">
       <div class="theme-toggle-container theme-toggle-header">
@@ -167,7 +167,7 @@
     <img class="sidebar-logo" src="_static/rns_logo_512.png" alt="Logo"/>
   </div>
   
-  <span class="sidebar-brand-text">Reticulum Network Stack 0.3.18 beta documentation</span>
+  <span class="sidebar-brand-text">Reticulum Network Stack 0.4.2 beta 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">

docs/source/understanding.rst

@@ -771,7 +771,7 @@ Wire Format
     |               | |               | |               | |    |
     00000000 00000111 [HASH1, 16 bytes] [CONTEXT, 1 byte] [DATA]
     || | | |    |
-    || | | |    +-- Hops             = 0
+    || | | |    +-- Hops             = 7
     || | | +------- Packet Type      = DATA
     || | +--------- Destination Type = SINGLE
     || +----------- Propagation Type = BROADCAST
@@ -786,7 +786,7 @@ Wire Format
     |               | |             | |               | |               | |    |
     10000000 00000111 [IFAC, N bytes] [HASH1, 16 bytes] [CONTEXT, 1 byte] [DATA]
     || | | |    |
-    || | | |    +-- Hops             = 0
+    || | | |    +-- Hops             = 7
     || | | +------- Packet Type      = DATA
     || | +--------- Destination Type = SINGLE
     || +----------- Propagation Type = BROADCAST