Add multi interface support

Add ability to get target and calculated firmware hash from device

RNS/Interfaces/AutoInterface.py

@@ -77,6 +77,15 @@ class AutoInterface(Interface):
         ifas = self.netinfo.ifaddresses(ifname)
         return ifas
 
+    def interface_name_to_index(self, ifname):
+
+        # socket.if_nametoindex doesn't work with uuid interface names on windows, it wants the ethernet_0 style
+        # we will just get the index from netinfo instead as it seems to work
+        if RNS.vendor.platformutils.is_windows():
+            return self.netinfo.interface_names_to_indexes()[ifname]
+
+        return socket.if_nametoindex(ifname)
+
     def __init__(self, owner, name, group_id=None, discovery_scope=None, discovery_port=None, multicast_address_type=None, data_port=None, allowed_interfaces=None, ignored_interfaces=None, configured_bitrate=None):
         from RNS.vendor.ifaddr import niwrapper
         super().__init__()
@@ -172,69 +181,90 @@ class AutoInterface(Interface):
 
         suitable_interfaces = 0
         for ifname in self.list_interfaces():
-            if RNS.vendor.platformutils.is_darwin() and ifname in AutoInterface.DARWIN_IGNORE_IFS and not ifname in self.allowed_interfaces:
+            try:
-                RNS.log(str(self)+" skipping Darwin AWDL or tethering interface "+str(ifname), RNS.LOG_EXTREME)
+                if RNS.vendor.platformutils.is_darwin() and ifname in AutoInterface.DARWIN_IGNORE_IFS and not ifname in self.allowed_interfaces:
-            elif RNS.vendor.platformutils.is_darwin() and ifname == "lo0":
+                    RNS.log(str(self)+" skipping Darwin AWDL or tethering interface "+str(ifname), RNS.LOG_EXTREME)
-                RNS.log(str(self)+" skipping Darwin loopback interface "+str(ifname), RNS.LOG_EXTREME)
+                elif RNS.vendor.platformutils.is_darwin() and ifname == "lo0":
-            elif RNS.vendor.platformutils.is_android() and ifname in AutoInterface.ANDROID_IGNORE_IFS and not ifname in self.allowed_interfaces:
+                    RNS.log(str(self)+" skipping Darwin loopback interface "+str(ifname), RNS.LOG_EXTREME)
-                RNS.log(str(self)+" skipping Android system interface "+str(ifname), RNS.LOG_EXTREME)
+                elif RNS.vendor.platformutils.is_android() and ifname in AutoInterface.ANDROID_IGNORE_IFS and not ifname in self.allowed_interfaces:
-            elif ifname in self.ignored_interfaces:
+                    RNS.log(str(self)+" skipping Android system interface "+str(ifname), RNS.LOG_EXTREME)
-                RNS.log(str(self)+" ignoring disallowed interface "+str(ifname), RNS.LOG_EXTREME)
+                elif ifname in self.ignored_interfaces:
-            elif ifname in AutoInterface.ALL_IGNORE_IFS:
+                    RNS.log(str(self)+" ignoring disallowed interface "+str(ifname), RNS.LOG_EXTREME)
-                RNS.log(str(self)+" skipping interface "+str(ifname), RNS.LOG_EXTREME)
+                elif ifname in AutoInterface.ALL_IGNORE_IFS:
-            else:
+                    RNS.log(str(self)+" skipping interface "+str(ifname), RNS.LOG_EXTREME)
-                if len(self.allowed_interfaces) > 0 and not ifname in self.allowed_interfaces:
-                    RNS.log(str(self)+" ignoring interface "+str(ifname)+" since it was not allowed", RNS.LOG_EXTREME)
                 else:
-                    addresses = self.list_addresses(ifname)
+                    if len(self.allowed_interfaces) > 0 and not ifname in self.allowed_interfaces:
-                    if self.netinfo.AF_INET6 in addresses:
+                        RNS.log(str(self)+" ignoring interface "+str(ifname)+" since it was not allowed", RNS.LOG_EXTREME)
-                        link_local_addr = None
+                    else:
-                        for address in addresses[self.netinfo.AF_INET6]:
+                        addresses = self.list_addresses(ifname)
-                            if "addr" in address:
+                        if self.netinfo.AF_INET6 in addresses:
-                                if address["addr"].startswith("fe80:"):
+                            link_local_addr = None
-                                    link_local_addr = self.descope_linklocal(address["addr"])
+                            for address in addresses[self.netinfo.AF_INET6]:
-                                    self.link_local_addresses.append(link_local_addr)
+                                if "addr" in address:
-                                    self.adopted_interfaces[ifname] = link_local_addr
+                                    if address["addr"].startswith("fe80:"):
-                                    self.multicast_echoes[ifname] = time.time()
+                                        link_local_addr = self.descope_linklocal(address["addr"])
-                                    RNS.log(str(self)+" Selecting link-local address "+str(link_local_addr)+" for interface "+str(ifname), RNS.LOG_EXTREME)
+                                        self.link_local_addresses.append(link_local_addr)
+                                        self.adopted_interfaces[ifname] = link_local_addr
+                                        self.multicast_echoes[ifname] = time.time()
+                                        nice_name = self.netinfo.interface_name_to_nice_name(ifname)
+                                        if nice_name != None and nice_name != ifname:
+                                            RNS.log(f"{self} Selecting link-local address {link_local_addr} for interface {nice_name} / {ifname}", RNS.LOG_EXTREME)
+                                        else:
+                                            RNS.log(f"{self} Selecting link-local address {link_local_addr} for interface {ifname}", RNS.LOG_EXTREME)
 
-                        if link_local_addr == None:
+                            if link_local_addr == None:
-                            RNS.log(str(self)+" No link-local IPv6 address configured for "+str(ifname)+", skipping interface", RNS.LOG_EXTREME)
+                                RNS.log(str(self)+" No link-local IPv6 address configured for "+str(ifname)+", skipping interface", RNS.LOG_EXTREME)
-                        else:
-                            mcast_addr = self.mcast_discovery_address
-                            RNS.log(str(self)+" Creating multicast discovery listener on "+str(ifname)+" with address "+str(mcast_addr), RNS.LOG_EXTREME)
-
-                            # Struct with interface index
-                            if_struct = struct.pack("I", socket.if_nametoindex(ifname))
-
-                            # Set up multicast socket
-                            discovery_socket = socket.socket(socket.AF_INET6, socket.SOCK_DGRAM)
-                            discovery_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-                            if hasattr(socket, "SO_REUSEPORT"):
-                                discovery_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
-                            discovery_socket.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_MULTICAST_IF, if_struct)
-
-                            # Join multicast group
-                            mcast_group = socket.inet_pton(socket.AF_INET6, mcast_addr) + if_struct
-                            discovery_socket.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_JOIN_GROUP, mcast_group)
-
-                            # Bind socket
-                            if self.discovery_scope == AutoInterface.SCOPE_LINK:
-                                addr_info = socket.getaddrinfo(mcast_addr+"%"+ifname, self.discovery_port, socket.AF_INET6, socket.SOCK_DGRAM)
                             else:
-                                addr_info = socket.getaddrinfo(mcast_addr, self.discovery_port, socket.AF_INET6, socket.SOCK_DGRAM)
+                                mcast_addr = self.mcast_discovery_address
+                                RNS.log(str(self)+" Creating multicast discovery listener on "+str(ifname)+" with address "+str(mcast_addr), RNS.LOG_EXTREME)
 
-                            discovery_socket.bind(addr_info[0][4])
+                                # Struct with interface index
+                                if_struct = struct.pack("I", self.interface_name_to_index(ifname))
 
-                            # Set up thread for discovery packets
+                                # Set up multicast socket
-                            def discovery_loop():
+                                discovery_socket = socket.socket(socket.AF_INET6, socket.SOCK_DGRAM)
-                                self.discovery_handler(discovery_socket, ifname)
+                                discovery_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+                                if hasattr(socket, "SO_REUSEPORT"):
+                                    discovery_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
+                                discovery_socket.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_MULTICAST_IF, if_struct)
 
-                            thread = threading.Thread(target=discovery_loop)
+                                # Join multicast group
-                            thread.daemon = True
+                                mcast_group = socket.inet_pton(socket.AF_INET6, mcast_addr) + if_struct
-                            thread.start()
+                                discovery_socket.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_JOIN_GROUP, mcast_group)
 
-                            suitable_interfaces += 1
+                                # Bind socket
+                                if RNS.vendor.platformutils.is_windows():
+
+                                    # window throws "[WinError 10049] The requested address is not valid in its context"
+                                    # when trying to use the multicast address as host, or when providing interface index
+                                    # passing an empty host appears to work, but probably not exactly how we want it to...
+                                    discovery_socket.bind(('', self.discovery_port))
+
+                                else:
+
+                                    if self.discovery_scope == AutoInterface.SCOPE_LINK:
+                                        addr_info = socket.getaddrinfo(mcast_addr+"%"+ifname, self.discovery_port, socket.AF_INET6, socket.SOCK_DGRAM)
+                                    else:
+                                        addr_info = socket.getaddrinfo(mcast_addr, self.discovery_port, socket.AF_INET6, socket.SOCK_DGRAM)
+
+                                    discovery_socket.bind(addr_info[0][4])
+
+                                # Set up thread for discovery packets
+                                def discovery_loop():
+                                    self.discovery_handler(discovery_socket, ifname)
+
+                                thread = threading.Thread(target=discovery_loop)
+                                thread.daemon = True
+                                thread.start()
+
+                                suitable_interfaces += 1
+
+            except Exception as e:
+                nice_name = self.netinfo.interface_name_to_nice_name(ifname)
+                if nice_name != None and nice_name != ifname:
+                    RNS.log(f"Could not configure the system interface {nice_name} / {ifname} for use with {self}, skipping it. The contained exception was: {e}", RNS.LOG_ERROR)
+                else:
+                    RNS.log(f"Could not configure the system interface {ifname} for use with {self}, skipping it. The contained exception was: {e}", RNS.LOG_ERROR)
 
         if suitable_interfaces == 0:
             RNS.log(str(self)+" could not autoconfigure. This interface currently provides no connectivity.", RNS.LOG_WARNING)
@@ -253,7 +283,7 @@ class AutoInterface(Interface):
             socketserver.UDPServer.address_family = socket.AF_INET6
 
             for ifname in self.adopted_interfaces:
-                local_addr = self.adopted_interfaces[ifname]+"%"+ifname
+                local_addr = self.adopted_interfaces[ifname]+"%"+str(self.interface_name_to_index(ifname))
                 addr_info = socket.getaddrinfo(local_addr, self.data_port, socket.AF_INET6, socket.SOCK_DGRAM)
                 address = addr_info[0][4]
 
@@ -380,7 +410,7 @@ class AutoInterface(Interface):
             announce_socket = socket.socket(socket.AF_INET6, socket.SOCK_DGRAM)
             addr_info = socket.getaddrinfo(self.mcast_discovery_address, self.discovery_port, socket.AF_INET6, socket.SOCK_DGRAM)
 
-            ifis = struct.pack("I", socket.if_nametoindex(ifname))
+            ifis = struct.pack("I", self.interface_name_to_index(ifname))
             announce_socket.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_MULTICAST_IF, ifis)
             announce_socket.sendto(discovery_token, addr_info[0][4])
             announce_socket.close()
@@ -434,7 +464,7 @@ class AutoInterface(Interface):
                     if self.outbound_udp_socket == None:
                         self.outbound_udp_socket = socket.socket(socket.AF_INET6, socket.SOCK_DGRAM)
 
-                    peer_addr = str(peer)+"%"+str(self.peers[peer][0])
+                    peer_addr = str(peer)+"%"+str(self.interface_name_to_index(self.peers[peer][0]))
                     addr_info = socket.getaddrinfo(peer_addr, self.data_port, socket.AF_INET6, socket.SOCK_DGRAM)
                     self.outbound_udp_socket.sendto(data, addr_info[0][4])
 

RNS/Reticulum.py

@@ -22,6 +22,9 @@
 
 from .vendor.platformutils import get_platform
 
+#debug
+import traceback
+
 if get_platform() == "android":
     from .Interfaces import Interface
     from .Interfaces import LocalInterface
@@ -536,46 +539,40 @@ class Reticulum:
 
                             if (("interface_enabled" in c) and c.as_bool("interface_enabled") == True) or (("enabled" in c) and c.as_bool("enabled") == True):
                                 if c["type"] == "AutoInterface":
-                                    if not RNS.vendor.platformutils.is_windows():
+                                    group_id        = c["group_id"] if "group_id" in c else None
-                                        group_id        = c["group_id"] if "group_id" in c else None
+                                    discovery_scope = c["discovery_scope"] if "discovery_scope" in c else None
-                                        discovery_scope = c["discovery_scope"] if "discovery_scope" in c else None
+                                    discovery_port  = int(c["discovery_port"]) if "discovery_port" in c else None
-                                        discovery_port  = int(c["discovery_port"]) if "discovery_port" in c else None
+                                    multicast_address_type = c["multicast_address_type"] if "multicast_address_type" in c else None
-                                        multicast_address_type = c["multicast_address_type"] if "multicast_address_type" in c else None
+                                    data_port  = int(c["data_port"]) if "data_port" in c else None
-                                        data_port  = int(c["data_port"]) if "data_port" in c else None
+                                    allowed_interfaces = c.as_list("devices") if "devices" in c else None
-                                        allowed_interfaces = c.as_list("devices") if "devices" in c else None
+                                    ignored_interfaces = c.as_list("ignored_devices") if "ignored_devices" in c else None
-                                        ignored_interfaces = c.as_list("ignored_devices") if "ignored_devices" in c else None
 
-                                        interface = AutoInterface.AutoInterface(
+                                    interface = AutoInterface.AutoInterface(
-                                            RNS.Transport,
+                                        RNS.Transport,
-                                            name,
+                                        name,
-                                            group_id,
+                                        group_id,
-                                            discovery_scope,
+                                        discovery_scope,
-                                            discovery_port,
+                                        discovery_port,
-                                            multicast_address_type,
+                                        multicast_address_type,
-                                            data_port,
+                                        data_port,
-                                            allowed_interfaces,
+                                        allowed_interfaces,
-                                            ignored_interfaces
+                                        ignored_interfaces
-                                        )
+                                    )
-
-                                        if "outgoing" in c and c.as_bool("outgoing") == False:
-                                            interface.OUT = False
-                                        else:
-                                            interface.OUT = True
-
-                                        interface.mode = interface_mode
-
-                                        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 "outgoing" in c and c.as_bool("outgoing") == False:
+                                        interface.OUT = False
                                     else:
-                                        RNS.log("AutoInterface is not currently supported on Windows, disabling interface.", RNS.LOG_ERROR);
+                                        interface.OUT = True
-                                        RNS.log("Please remove this AutoInterface instance from your configuration file.", RNS.LOG_ERROR);
+
-                                        RNS.log("You will have to manually configure other interfaces for connectivity.", RNS.LOG_ERROR);
+                                    interface.mode = interface_mode
+
+                                    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"] == "UDPInterface":
                                     device       = c["device"] if "device" in c else None
@@ -935,6 +932,71 @@ class Reticulum:
                                     else:
                                         interface.ifac_size = 8
 
+                                if c["type"] == "RNodeMultiInterface":
+                                    count = 0
+                                    for subinterface in c:
+                                        # if the retrieved entry is not a string, it must be a dictionary, which is what we want
+                                        if not isinstance(c[subinterface], str):
+                                            count += 1
+
+                                    # create an array with a row for each subinterface
+                                    subint_config = [[0 for x in range(8)] for y in range(count)]
+                                    subint_index = 0
+
+                                    for subinterface in c:
+                                        # if the retrieved entry is not a string, it must be a dictionary, which is what we want
+                                        if not isinstance(c[subinterface], str):
+                                            subinterface_config = self.config["interfaces"][name][subinterface]
+
+                                            frequency = int(subinterface_config["frequency"]) if "frequency" in subinterface_config else None
+                                            subint_config[subint_index][0] = frequency
+                                            bandwidth = int(subinterface_config["bandwidth"]) if "bandwidth" in subinterface_config else None
+                                            subint_config[subint_index][1] = bandwidth
+                                            txpower = int(subinterface_config["txpower"]) if "txpower" in subinterface_config else None
+                                            subint_config[subint_index][2] = txpower
+                                            spreadingfactor = int(subinterface_config["spreadingfactor"]) if "spreadingfactor" in subinterface_config else None
+                                            subint_config[subint_index][3] = spreadingfactor 
+                                            codingrate = int(subinterface_config["codingrate"]) if "codingrate" in subinterface_config else None
+                                            subint_config[subint_index][4] = codingrate
+                                            flow_control = subinterface_config.as_bool("flow_control") if "flow_control" in subinterface_config else False
+                                            subint_config[subint_index][5] = flow_control 
+                                            st_alock = float(subinterface_config["airtime_limit_short"]) if "airtime_limit_short" in subinterface_config else None
+                                            subint_config[subint_index][6] = st_alock
+                                            lt_alock = float(subinterface_config["airtime_limit_long"]) if "airtime_limit_long" in subinterface_config else None
+                                            subint_config[subint_index][7] = lt_alock
+                                            subint_index += 1
+
+                                    id_interval = int(c["id_interval"]) if "id_interval" in c else None
+                                    id_callsign = c["id_callsign"] if "id_callsign" in c else None
+                                    port = c["port"] if "port" in c else None
+                                    
+                                    if port == None:
+                                        raise ValueError("No port specified for RNodeMulti interface")
+
+                                    interface = RNodeMultiInterface.RNodeMultiInterface(
+                                        RNS.Transport,
+                                        name,
+                                        port,
+                                        subint_config,
+                                        id_interval = id_interval,
+                                        id_callsign = id_callsign
+                                    )
+
+                                    #if "outgoing" in c and c.as_bool("outgoing") == False:
+                                    interface.OUT = False
+                                    #else:
+                                    #    interface.OUT = True
+
+                                    interface.mode = interface_mode
+
+                                    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 = 8
+
                                 if interface != None:
                                     interface.announce_rate_target = announce_rate_target
                                     interface.announce_rate_grace = announce_rate_grace
@@ -979,6 +1041,7 @@ class Reticulum:
                         except Exception as e:
                             RNS.log("The interface \""+name+"\" could not be created. Check your configuration file for errors!", RNS.LOG_ERROR)
                             RNS.log("The contained exception was: "+str(e), RNS.LOG_ERROR)
+                            RNS.log(traceback.print_exc(), RNS.LOG_ERROR)
                             RNS.panic()
                     else:
                         RNS.log("The interface name \""+name+"\" was already used. Check your configuration file for errors!", RNS.LOG_ERROR)

RNS/_version.py

@@ -1 +1 @@
-__version__ = "0.7.4"
+__version__ = "0.7.5"

RNS/vendor/ifaddr/niwrapper.py

@@ -11,6 +11,25 @@ def interfaces() -> List[str]:
     adapters = RNS.vendor.ifaddr.get_adapters(include_unconfigured=True)
     return [a.name for a in adapters]
 
+def interface_names_to_indexes() -> dict:
+    adapters = RNS.vendor.ifaddr.get_adapters(include_unconfigured=True)
+    results = {}
+    for adapter in adapters:
+        results[adapter.name] = adapter.index
+    return results
+
+def interface_name_to_nice_name(ifname) -> str:
+    try:
+        adapters = RNS.vendor.ifaddr.get_adapters(include_unconfigured=True)
+        for adapter in adapters:
+            if adapter.name == ifname:
+                if hasattr(adapter, "nice_name"):
+                    return adapter.nice_name
+    except:
+        return None
+
+    return None
+
 def ifaddresses(ifname) -> dict:
     adapters = RNS.vendor.ifaddr.get_adapters(include_unconfigured=True)
     ifa = {}