RNS/Cryptography/Fernet.py

@@ -45,10 +45,10 @@ class Fernet():
 
     def __init__(self, key = None):
         if key == None:
-            raise ValueError("Token key cannot be None")
+            raise ValueError("Fernet key cannot be None")
 
         if len(key) != 32:
-            raise ValueError("Token key must be 32 bytes, not "+str(len(key)))
+            raise ValueError("Fernet key must be 32 bytes, not "+str(len(key)))
             
         self._signing_key = key[:16]
         self._encryption_key = key[16:]
@@ -72,7 +72,7 @@ class Fernet():
         current_time = int(time.time())
 
         if not isinstance(data, bytes):
-            raise TypeError("Token plaintext input must be bytes")
+            raise TypeError("Fernet token plaintext input must be bytes")
 
         ciphertext = AES_128_CBC.encrypt(
             plaintext = PKCS7.pad(data),
@@ -87,10 +87,10 @@ class Fernet():
 
     def decrypt(self, token = None):
         if not isinstance(token, bytes):
-            raise TypeError("Token must be bytes")
+            raise TypeError("Fernet token must be bytes")
 
         if not self.verify_hmac(token):
-            raise ValueError("Token HMAC was invalid")
+            raise ValueError("Fernet token HMAC was invalid")
 
         iv = token[:16]
         ciphertext = token[16:-32]
@@ -107,4 +107,4 @@ class Fernet():
             return plaintext
 
         except Exception as e:
-            raise ValueError("Could not decrypt token")
+            raise ValueError("Could not decrypt Fernet token")

RNS/Interfaces/Android/RNodeInterface.py

@@ -233,10 +233,6 @@ class RNodeInterface(Interface):
     RECONNECT_WAIT = 5
     PORT_IO_TIMEOUT = 3
 
-    Q_SNR_MIN_BASE = -9
-    Q_SNR_MAX      = 6
-    Q_SNR_STEP     = 2
-
     @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):
@@ -865,6 +861,9 @@ class RNodeInterface(Interface):
             self.owner.inbound(data, self)
         threading.Thread(target=af, daemon=True).start()
 
+        self.r_stat_rssi = None
+        self.r_stat_snr = None
+
 
     def processOutgoing(self,data):
         datalen = len(data)
@@ -1046,19 +1045,6 @@ class RNodeInterface(Interface):
                             self.r_stat_rssi = byte-RNodeInterface.RSSI_OFFSET
                         elif (command == KISS.CMD_STAT_SNR):
                             self.r_stat_snr = int.from_bytes(bytes([byte]), byteorder="big", signed=True) * 0.25
-                            try:
-                                sfs = self.r_sf-7
-                                snr = self.r_stat_snr
-                                q_snr_min = RNodeInterface.Q_SNR_MIN_BASE-sfs*RNodeInterface.Q_SNR_STEP
-                                q_snr_max = RNodeInterface.Q_SNR_MAX
-                                q_snr_span = q_snr_max-q_snr_min
-                                quality = round(((snr-q_snr_min)/(q_snr_span))*100,1)
-                                if quality > 100.0: quality = 100.0
-                                if quality < 0.0: quality = 0.0
-                                self.r_stat_q = quality
-                            except:
-                                pass
-
                         elif (command == KISS.CMD_ST_ALOCK):
                             if (byte == KISS.FESC):
                                 escape = True

RNS/Interfaces/RNodeInterface.py

@@ -103,10 +103,6 @@ class RNodeInterface(Interface):
 
     RECONNECT_WAIT = 5
 
-    Q_SNR_MIN_BASE = -9
-    Q_SNR_MAX      = 6
-    Q_SNR_STEP     = 2
-
     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, st_alock = None, lt_alock = None):
         if RNS.vendor.platformutils.is_android():
             raise SystemError("Invlaid interface type. The Android-specific RNode interface must be used on Android")
@@ -676,18 +672,6 @@ class RNodeInterface(Interface):
                             self.r_stat_rssi = byte-RNodeInterface.RSSI_OFFSET
                         elif (command == KISS.CMD_STAT_SNR):
                             self.r_stat_snr = int.from_bytes(bytes([byte]), byteorder="big", signed=True) * 0.25
-                            try:
-                                sfs = self.r_sf-7
-                                snr = self.r_stat_snr
-                                q_snr_min = RNodeInterface.Q_SNR_MIN_BASE-sfs*RNodeInterface.Q_SNR_STEP
-                                q_snr_max = RNodeInterface.Q_SNR_MAX
-                                q_snr_span = q_snr_max-q_snr_min
-                                quality = round(((snr-q_snr_min)/(q_snr_span))*100,1)
-                                if quality > 100.0: quality = 100.0
-                                if quality < 0.0: quality = 0.0
-                                self.r_stat_q = quality
-                            except:
-                                pass
                         elif (command == KISS.CMD_ST_ALOCK):
                             if (byte == KISS.FESC):
                                 escape = True

RNS/Link.py

@@ -153,9 +153,6 @@ class Link:
         self.rx = 0
         self.txbytes = 0
         self.rxbytes = 0
-        self.rssi = None
-        self.snr = None
-        self.q = None
         self.traffic_timeout_factor = Link.TRAFFIC_TIMEOUT_FACTOR
         self.keepalive_timeout_factor = Link.KEEPALIVE_TIMEOUT_FACTOR
         self.keepalive = Link.KEEPALIVE
@@ -475,7 +472,6 @@ class Link:
                     self.teardown_reason = Link.DESTINATION_CLOSED
                 else:
                     self.teardown_reason = Link.INITIATOR_CLOSED
-                self.__update_phy_stats(packet)
                 self.link_closed()
         except Exception as e:
             pass
@@ -581,14 +577,6 @@ class Link:
                 sleep(sleep_time)
 
 
-    def __update_phy_stats(self, packet):
-        if packet.rssi != None:
-            self.rssi = packet.rssi
-        if packet.snr != None:
-            self.snr = packet.snr
-        if packet.q != None:
-            self.q = packet.q
-    
     def send_keepalive(self):
         keepalive_packet = RNS.Packet(self, bytes([0xFF]), context=RNS.Packet.KEEPALIVE)
         keepalive_packet.send()
@@ -719,8 +707,6 @@ class Link:
                                 except Exception as e:
                                     RNS.log("Error while executing proof request callback from "+str(self)+". The contained exception was: "+str(e), RNS.LOG_ERROR)
 
-                        self.__update_phy_stats(packet)
-
                     elif packet.context == RNS.Packet.LINKIDENTIFY:
                         plaintext = self.decrypt(packet.data)
 
@@ -738,8 +724,6 @@ class Link:
                                         self.callbacks.remote_identified(self, self.__remote_identity)
                                     except Exception as e:
                                         RNS.log("Error while executing remote identified callback from "+str(self)+". The contained exception was: "+str(e), RNS.LOG_ERROR)
-                            
-                                self.__update_phy_stats(packet)
 
                     elif packet.context == RNS.Packet.REQUEST:
                         try:
@@ -747,7 +731,6 @@ class Link:
                             packed_request = self.decrypt(packet.data)
                             unpacked_request = umsgpack.unpackb(packed_request)
                             self.handle_request(request_id, unpacked_request)
-                            self.__update_phy_stats(packet)
                         except Exception as e:
                             RNS.log("Error occurred while handling request. The contained exception was: "+str(e), RNS.LOG_ERROR)
 
@@ -759,21 +742,18 @@ class Link:
                             response_data = unpacked_response[1]
                             transfer_size = len(umsgpack.packb(response_data))-2
                             self.handle_response(request_id, response_data, transfer_size, transfer_size)
-                            self.__update_phy_stats(packet)
                         except Exception as e:
                             RNS.log("Error occurred while handling response. The contained exception was: "+str(e), RNS.LOG_ERROR)
 
                     elif packet.context == RNS.Packet.LRRTT:
                         if not self.initiator:
                             self.rtt_packet(packet)
-                            self.__update_phy_stats(packet)
 
                     elif packet.context == RNS.Packet.LINKCLOSE:
                         self.teardown_packet(packet)
 
                     elif packet.context == RNS.Packet.RESOURCE_ADV:
                         packet.plaintext = self.decrypt(packet.data)
-                        self.__update_phy_stats(packet)
 
                         if RNS.ResourceAdvertisement.is_request(packet):
                             RNS.Resource.accept(packet, callback=self.request_resource_concluded)
@@ -801,7 +781,6 @@ class Link:
 
                     elif packet.context == RNS.Packet.RESOURCE_REQ:
                         plaintext = self.decrypt(packet.data)
-                        self.__update_phy_stats(packet)
                         if ord(plaintext[:1]) == RNS.Resource.HASHMAP_IS_EXHAUSTED:
                             resource_hash = plaintext[1+RNS.Resource.MAPHASH_LEN:RNS.Identity.HASHLENGTH//8+1+RNS.Resource.MAPHASH_LEN]
                         else:
@@ -817,7 +796,6 @@ class Link:
 
                     elif packet.context == RNS.Packet.RESOURCE_HMU:
                         plaintext = self.decrypt(packet.data)
-                        self.__update_phy_stats(packet)
                         resource_hash = plaintext[:RNS.Identity.HASHLENGTH//8]
                         for resource in self.incoming_resources:
                             if resource_hash == resource.hash:
@@ -825,7 +803,6 @@ class Link:
 
                     elif packet.context == RNS.Packet.RESOURCE_ICL:
                         plaintext = self.decrypt(packet.data)
-                        self.__update_phy_stats(packet)
                         resource_hash = plaintext[:RNS.Identity.HASHLENGTH//8]
                         for resource in self.incoming_resources:
                             if resource_hash == resource.hash:
@@ -845,7 +822,6 @@ class Link:
                     elif packet.context == RNS.Packet.RESOURCE:
                         for resource in self.incoming_resources:
                             resource.receive_part(packet)
-                            self.__update_phy_stats(packet)
 
                     elif packet.context == RNS.Packet.CHANNEL:
                         if not self._channel:
@@ -866,7 +842,6 @@ class Link:
 
                             packet.prove()
                             plaintext = self.decrypt(packet.data)
-                            self.__update_phy_stats(packet)
                             self._channel._receive(plaintext)
 
                 elif packet.packet_type == RNS.Packet.PROOF:
@@ -875,7 +850,6 @@ class Link:
                         for resource in self.outgoing_resources:
                             if resource_hash == resource.hash:
                                 resource.validate_proof(packet.data)
-                                self.__update_phy_stats(packet)
 
         self.watchdog_lock = False
 

RNS/Packet.py

@@ -138,7 +138,6 @@ class Packet:
         self.receiving_interface = None
         self.rssi = None
         self.snr = None
-        self.q = None
 
     def get_packed_flags(self):
         if self.context == Packet.LRPROOF:

RNS/Transport.py

@@ -116,7 +116,6 @@ class Transport:
 
     local_client_rssi_cache    = []
     local_client_snr_cache     = []
-    local_client_q_cache     = []
     LOCAL_CLIENT_CACHE_MAXSIZE = 512
 
     pending_local_path_requests = {}
@@ -1097,15 +1096,6 @@ class Transport:
                         while len(Transport.local_client_snr_cache) > Transport.LOCAL_CLIENT_CACHE_MAXSIZE:
                             Transport.local_client_snr_cache.pop(0)
 
-            if hasattr(interface, "r_stat_q"):
-                if interface.r_stat_q != None:
-                    packet.q = interface.r_stat_q
-                    if len(Transport.local_client_interfaces) > 0:
-                        Transport.local_client_q_cache.append([packet.packet_hash, packet.q])
-
-                        while len(Transport.local_client_q_cache) > Transport.LOCAL_CLIENT_CACHE_MAXSIZE:
-                            Transport.local_client_q_cache.pop(0)
-
         if len(Transport.local_client_interfaces) > 0:
             if Transport.is_local_client_interface(interface):
                 packet.hops -= 1

RNS/__init__.py

@@ -192,52 +192,32 @@ def prettyfrequency(hz, suffix="Hz"):
 
     return "%.2f%s%s" % (num, last_unit, suffix)
 
-def prettydistance(hz, suffix="m"):
-    num = hz*1e6
-    units = ["µ", "m", "", "K","M","G","T","P","E","Z"]
-    last_unit = "Y"
-
-    for unit in units:
-        if abs(num) < 1000.0:
-            return "%.2f %s%s" % (num, unit, suffix)
-        num /= 1000.0
-
-    return "%.2f%s%s" % (num, last_unit, suffix)
-
-def prettytime(time, verbose=False, compact=False):
+def prettytime(time, verbose=False):
     days = int(time // (24 * 3600))
     time = time % (24 * 3600)
     hours = int(time // 3600)
     time %= 3600
     minutes = int(time // 60)
     time %= 60
-    if compact:
-        seconds = int(time)
-    else:
-        seconds = round(time, 2)
+    seconds = round(time, 2)
     
     ss = "" if seconds == 1 else "s"
     sm = "" if minutes == 1 else "s"
     sh = "" if hours == 1 else "s"
     sd = "" if days == 1 else "s"
 
-    displayed = 0
     components = []
-    if days > 0 and ((not compact) or displayed < 2):
+    if days > 0:
         components.append(str(days)+" day"+sd if verbose else str(days)+"d")
-        displayed += 1
 
-    if hours > 0 and ((not compact) or displayed < 2):
+    if hours > 0:
         components.append(str(hours)+" hour"+sh if verbose else str(hours)+"h")
-        displayed += 1
 
-    if minutes > 0 and ((not compact) or displayed < 2):
+    if minutes > 0:
         components.append(str(minutes)+" minute"+sm if verbose else str(minutes)+"m")
-        displayed += 1
 
-    if seconds > 0 and ((not compact) or displayed < 2):
+    if seconds > 0:
         components.append(str(seconds)+" second"+ss if verbose else str(seconds)+"s")
-        displayed += 1
 
     i = 0
     tstr = ""