remoteRF-server 1.1.0__tar.gz → 1.1.2__tar.gz

{remoterf_server-1.1.0 → remoterf_server-1.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoteRF-server
-Version: 1.1.0
+Version: 1.1.2
 Summary: RemoteRF server-side control package
 License: GPL-3.0-or-later
 Classifier: Programming Language :: Python :: 3
@@ -932,6 +932,7 @@ After running `serverrf --serve`, you’ll enter the **RemoteRF Server Shell**.
 ### Database
 
 * `db purge` — Remove all database entries
+* `wipe` — Factory reset: delete the whole config dir (devices, drivers, databases, certs) and the Global identity keys; the next `serverrf -s` runs first-time setup *(server must be stopped; prompts for confirmation, `-y` skips)*
 
 
 ## Adding Hosts

{remoterf_server-1.1.0 → remoterf_server-1.1.2}/README.md

@@ -901,6 +901,7 @@ After running `serverrf --serve`, you’ll enter the **RemoteRF Server Shell**.
 ### Database
 
 * `db purge` — Remove all database entries
+* `wipe` — Factory reset: delete the whole config dir (devices, drivers, databases, certs) and the Global identity keys; the next `serverrf -s` runs first-time setup *(server must be stopped; prompts for confirmation, `-y` skips)*
 
 
 ## Adding Hosts

{remoterf_server-1.1.0 → remoterf_server-1.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "remoteRF-server"
-version = "1.1.0"
+version = "1.1.2"
 description = "RemoteRF server-side control package"
 license = { text = "GPL-3.0-or-later" }
 requires-python = ">=3.10"

{remoterf_server-1.1.0/src/remoteRF_server/drivers/adalm_pluto → remoterf_server-1.1.2/src/remoteRF_server/common/idl}/pluto_schema.py

@@ -202,6 +202,9 @@ class PlutoSchema(DeviceSchema):
 
     @idl_expose(kind="set")
     def set_rx_buffer_size(self, value):
+        # pyadi reads rx_buffer_size only when it (re)creates the RX buffer.
+        if value != self.device.rx_buffer_size:
+            self.device.rx_destroy_buffer()
         self.device.rx_buffer_size = value
 
     @idl_expose(kind="call")

{remoterf_server-1.1.0 → remoterf_server-1.1.2}/src/remoteRF_server/common/utils/api_token.py

@@ -15,6 +15,7 @@
 
 import os
 import hashlib
+import hmac
 import base64
 import secrets
 from dotenv import load_dotenv, find_dotenv
@@ -33,4 +34,21 @@ def validate_token(salt, hash, token) -> bool:
 def hash_token(token: str) -> tuple[str, str]:
     salt = os.urandom(16).hex()
     hashed = hashlib.sha256(bytes.fromhex(salt) + token.encode()).hexdigest()
-    return salt, hashed
+    return salt, hashed
+
+# Passwords get a real KDF; tokens stay on hash_token (random, high entropy).
+PASSWORD_HASH_PREFIX = "pbkdf2$"
+_PBKDF2_ROUNDS = 210_000
+
+def hash_password(password: str) -> tuple[str, str]:
+    salt = os.urandom(16).hex()
+    digest = hashlib.pbkdf2_hmac('sha256', password.encode(), bytes.fromhex(salt), _PBKDF2_ROUNDS)
+    return salt, f"{PASSWORD_HASH_PREFIX}{_PBKDF2_ROUNDS}${digest.hex()}"
+
+def verify_password(salt, hash, password) -> tuple[bool, bool]:
+    """Returns (matches, needs_rehash). Accepts legacy hash_token() hashes."""
+    if not hash.startswith(PASSWORD_HASH_PREFIX):
+        return validate_token(salt, hash, password), True
+    _, rounds, digest = hash.split('$', 2)
+    computed = hashlib.pbkdf2_hmac('sha256', password.encode(), bytes.fromhex(salt), int(rounds))
+    return hmac.compare_digest(computed.hex(), digest), False

{remoterf_server-1.1.0 → remoterf_server-1.1.2}/src/remoteRF_server/drivers/adalm_pluto/pluto_remote_server.py

@@ -90,8 +90,7 @@ class PlutoServer:
         if result is not None:
             return {function_name: map_arg(result)}
         else:
-            # If there's no return value, return some placeholder
-            return {function_name: map_arg('None')}
+            return {function_name: map_arg(None)}
             
     @staticmethod
     def get(*, function_name, token):

{remoterf_server-1.1.0/src/remoteRF_server/common/idl → remoterf_server-1.1.2/src/remoteRF_server/drivers/adalm_pluto}/pluto_schema.py

@@ -202,6 +202,9 @@ class PlutoSchema(DeviceSchema):
 
     @idl_expose(kind="set")
     def set_rx_buffer_size(self, value):
+        # pyadi reads rx_buffer_size only when it (re)creates the RX buffer.
+        if value != self.device.rx_buffer_size:
+            self.device.rx_destroy_buffer()
         self.device.rx_buffer_size = value
 
     @idl_expose(kind="call")

{remoterf_server-1.1.0 → remoterf_server-1.1.2}/src/remoteRF_server/drivers/adalm_pluto/poe.py

@@ -26,9 +26,11 @@ import threading
 import time
 
 from remoteRF_server.common.utils import get_remoterf_root
+from remoteRF_server.common.utils.ansi_codes import Sty, printf
 
 IIOD_PORT = 30431
-BOOT_TIMEOUT_S = 120
+BOOT_TIMEOUT_S = 45
+LINK_CHECK_S = 30  # no IIOD by then: ask the switch whether the port even has a link
 OFF_S = 3  # long enough for the Pluto to lose power before it is switched back on
 
 
@@ -90,6 +92,19 @@ def set_poe(*, switch, user, password, port, on):
         ros.close()
 
 
+def port_running(*, switch, user, password, port):
+    """Whether the switch port has an Ethernet link (RouterOS 'running')."""
+    ros = RouterOS(switch, user, password)
+    try:
+        replies = ros.cmd("/interface/ethernet/print", f"?name={port}", "=.proplist=name,running")
+    finally:
+        ros.close()
+    for sentence in replies:
+        if sentence[0] == "!re":
+            return "=running=true" in sentence
+    raise RuntimeError(f"switch has no interface {port}")
+
+
 def _iiod_up(ip):
     try:
         socket.create_connection((ip, IIOD_PORT), timeout=1).close()
@@ -110,6 +125,7 @@ class PoePluto:
             _serial=str(serial or "").strip(),
             _switch={"switch": switch, "user": user, "password": password},
             _pluto=None,
+            fault=None,  # message of the last failed boot; None once a boot succeeds
             _lock=threading.RLock(),
         )
 
@@ -119,28 +135,58 @@ class PoePluto:
     def _poe(self, on):
         set_poe(port=self._port, on=on, **self._switch)
 
+    @property
+    def power_state(self):
+        if self.fault:
+            return "fault"
+        return "on" if self._pluto is not None else "standby"
+
     def power_up(self):
         with self._lock:
             if self._pluto is not None:
                 return
-            self._poe(True)
-            deadline = time.monotonic() + BOOT_TIMEOUT_S
-            while not _iiod_up(self._ip):
-                if time.monotonic() > deadline:
-                    self._poe(False)
-                    raise RuntimeError(f"PoE Pluto {self.uri} did not boot within {BOOT_TIMEOUT_S} s on {self._port}")
-                time.sleep(1)
-            import adi
-
-            pluto = adi.Pluto(self.uri)
-            found = str(pluto._ctx.attrs.get("hw_serial", "")).strip()
-            if self._serial and found.lower() != self._serial.lower():
-                del pluto
+            try:
+                self._boot()
+            except Exception as e:
+                vars(self)["fault"] = str(e)
+                printf(f"{time.strftime('%H:%M:%S')} {e}", Sty.GRAY)
+                raise
+            vars(self)["fault"] = None
+
+    def _boot(self):
+        self._poe(True)
+        started = time.monotonic()
+        link_checked = False
+        while not _iiod_up(self._ip):
+            waited = time.monotonic() - started
+            if waited > BOOT_TIMEOUT_S:
                 self._poe(False)
-                raise RuntimeError(f"{self.uri} on {self._port} is Pluto {found}, expected {self._serial}")
-            vars(self)["_pluto"] = pluto
+                raise RuntimeError(f"PoE Pluto {self.uri} did not boot within {BOOT_TIMEOUT_S} s on {self._port}")
+            if waited > LINK_CHECK_S and not link_checked:
+                link_checked = True
+                try:
+                    running = port_running(port=self._port, **self._switch)
+                except Exception:
+                    running = True  # switch unreachable: keep waiting for IIOD
+                if not running:
+                    self._poe(False)
+                    raise RuntimeError(
+                        f"Pluto {self.uri}: PoE on {self._port} but no Ethernet link after {LINK_CHECK_S} s (cable/port/board fault)"
+                    )
+            time.sleep(1)
+        import adi
+
+        pluto = adi.Pluto(self.uri)
+        found = str(pluto._ctx.attrs.get("hw_serial", "")).strip()
+        if self._serial and found.lower() != self._serial.lower():
+            del pluto
+            self._poe(False)
+            raise RuntimeError(f"{self.uri} on {self._port} is Pluto {found}, expected {self._serial}")
+        vars(self)["_pluto"] = pluto
 
     def power_down(self):
+        """Cut power. The Pluto boots with default settings: sample rate, LOs,
+        gains and rx_buffer_size are all reset by the next power_up()."""
         with self._lock:
             # Drop the handle while the Pluto can still answer its buffer teardown.
             vars(self)["_pluto"] = None

{remoterf_server-1.1.0 → remoterf_server-1.1.2}/src/remoteRF_server/server/commands.py

@@ -106,7 +106,7 @@ def _table() -> list[Command]:
         # ---- devices ----
         Command(("devices list",), "Configured devices", _shell("cmd_devices_list"), "Devices"),
         Command(("devices status",), "Live device online/last_seen/route", _daemon("cmd_devices_status"), "Devices", where=D),
-        Command(("devices add",), "Add a device (asks type, name, serial)", _shell("cmd_devices_add"), "Devices", after="reload_devices"),
+        Command(("devices add",), "Add a device (asks type, name, serial)", _shell("cmd_devices_add"), "Devices", after="reload_devices", hidden=True),
         Command(("devices remove",), "Remove a device by id", _shell("cmd_devices_remove"), "Devices", after="reload_devices"),
         Command(("devices rename",), "Rename a device: devices rename <id> <name>", _shell("cmd_devices_rename"), "Devices", after="reload_devices"),
         Command(("devices wipe",), "Remove ALL devices [-y]", _shell("cmd_devices_wipe"), "Devices", after="reload_devices"),
@@ -168,6 +168,7 @@ def _table() -> list[Command]:
         Command(("db export",), "Archive DBs, devices, keys, certs to ~/Downloads [dir]", _shell("cmd_db_export"), "Database"),
         Command(("stats purge",), "Delete the activity log (reservation stats) [-y]", _daemon("cmd_stats_purge"), "Database", where=D),
         Command(("db purge",), "Remove all database entries", _daemon("cmd_db_purge"), "Database", where=D),
+        Command(("wipe",), "Factory reset: delete all config and data [-y]", _shell("cmd_wipe"), "Database"),
     ]
 
 
@@ -263,10 +264,6 @@ def cmd_help(argv: list[str]) -> int:
             return 2
         rows = [c for c in _visible(_IN_DAEMON) if c.section == section]
         lines = [_SECTION_BLURB.get(section, ""), ""] + _columns([(prefix + c.names[0], c.help) for c in rows])
-        if section == "Devices":
-            lines += ["", "Types for `devices add`:",
-                      "  pluto, pluto-mimo, rtl-sdr, hackrf, ti-mmwave,",
-                      "  usrp-2901, usrp-b205-mini, usrp-n210, usrp-profile"]
         print_panel(section, lines, literal=True)
         return 0
     lines: list[str] = []

{remoterf_server-1.1.0 → remoterf_server-1.1.2}/src/remoteRF_server/server/device_manager.py

@@ -77,6 +77,10 @@ def _is_connected(st: _DeviceState) -> bool:
     # host
     return bool(st.online)
 
+def _poe_fault(st: _DeviceState):
+    """Last boot failure of a local PoE Pluto (None otherwise; see drivers/adalm_pluto/poe.py)."""
+    return getattr(getattr(st.dev, "device", None), "fault", None)
+
 # Host device pulling/grabbing
 
 def _get_host_registry():
@@ -187,6 +191,12 @@ def _local_devices_str_snapshot() -> Dict[int, str]:
             name = (st.name or f"device-{gid}").strip()
 
             status = "online" if _is_connected(st) else "offline"
+            fault = _poe_fault(st)
+            power = getattr(getattr(st.dev, "device", None), "power_state", None)
+            if fault:
+                status = f"offline: {fault}"
+            elif power:
+                status = f"{status}, {power}"
             if st.salt or st.hsh:
                 status = f"{status}, reserved"
 
@@ -728,7 +738,7 @@ def describe_devices(ids) -> list[dict]:
             if st is None:
                 continue
             out.append({"id": int(gid), "name": (st.name or f"device-{gid}").strip(),
-                        "type": st.dtype or "", "online": _is_connected(st)})
+                        "type": st.dtype or "", "online": _is_connected(st) and not _poe_fault(st)})
     return out
 
 
@@ -1187,7 +1197,7 @@ def device_inventory_snapshot() -> Dict[int, Dict[str, object]]:
             gid: {
                 "name": st.name or f"device {gid}",
                 "device_type": st.dtype or None,
-                "online": _is_connected(st),
+                "online": _is_connected(st) and not _poe_fault(st),
                 "origin": st.origin,
             }
             for gid, st in _devices.items()

{remoterf_server-1.1.0 → remoterf_server-1.1.2}/src/remoteRF_server/server/direct_path.py

@@ -45,6 +45,7 @@ import os
 import secrets
 import socket
 import threading
+import time
 from pathlib import Path
 from typing import Optional
 
@@ -125,6 +126,20 @@ ALPN = "remoterf-direct/1"
 MAX_FRAME = 100 * 1024 * 1024  # the gRPC message ceiling
 IDLE_SECONDS = 600
 CONNECT_SECONDS = 30  # ICE checks, then the QUIC handshake; a silent client is dropped
+# How long the punch waits for the client's first check when the answer also
+# offered the fixed port. A 2.1.0 client dials that port for 2 s before its
+# first check; a check of ours reaching its NAT before then leaves a stale
+# entry there that shadows the port its own checks are then mapped to (Linux
+# NAT picks another), and the punch can never complete. A check that arrives
+# sooner ends the wait; a client that never reaches us gets ours after it.
+# 3.0 = the 2 s dial plus ~1 s for the relay round trip that carries the
+# answer; a shorter hold reproduces the shadow on a slow relay.
+HOLD_SECONDS = 3.0
+# A client that punches at once ("race" in its offer) sends its first check
+# as soon as the answer reaches it, but that check is dropped at a border
+# that has not seen ours yet, so it cannot end the hold: ours must simply
+# leave after its first check has, and before its retransmit at 0.5 s.
+RACE_HOLD_SECONDS = 0.4
 MAX_PATHS_PER_SESSION = 8  # processes of one login; the oldest path makes room
 DEFAULT_STUN = "stun.l.google.com:19302"
 STUN_SECONDS = 1.5  # a STUN server answers in milliseconds or not at all
@@ -145,6 +160,23 @@ _listener = None
 _listener_port = 0
 
 
+def say(message: str) -> None:
+    """A console line about a path, stamped: paths fail minutes apart."""
+    printf(f"{time.strftime('%H:%M:%S')} {message}", Sty.GRAY)
+
+
+def describe_failure(exc: BaseException, stage: str) -> str:
+    """The exception class and a message that says what did not happen."""
+    if isinstance(exc, asyncio.TimeoutError):
+        return f"TimeoutError: {stage} did not complete within {CONNECT_SECONDS} s"
+    return f"{type(exc).__name__}: {exc}"
+
+
+def describe_remotes(ice: Connection) -> str:
+    """The candidates the client offered, host:port/type each."""
+    return " ".join(f"{c.host}:{c.port}/{c.type}" for c in ice.remote_candidates) or "none"
+
+
 def frame(payload: bytes) -> bytes:
     return len(payload).to_bytes(4, "big") + payload
 
@@ -187,8 +219,15 @@ class Ice(Connection):
     server, and aioice would hold gathering for its whole 5 s timeout on each
     one, on every offer. One interface and a short STUN wait instead; a
     machine without a default route gathers the way aioice does.
+
+    ``heard`` is set by the peer's first check, which may arrive before
+    connect() (aioice holds it as an early check until then).
     """
 
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.heard = asyncio.Event()
+
     async def gather_candidates(self) -> None:
         address = default_route_address()
         if address is None or self._local_candidates_start:
@@ -199,6 +238,10 @@ class Ice(Connection):
         )
         self._local_candidates_end = True
 
+    def request_received(self, *args) -> None:
+        super().request_received(*args)
+        self.heard.set()
+
 
 def peer_address(ice: Connection) -> tuple[str, int]:
     """The remote end of the nominated pair (aioice keeps it private)."""
@@ -299,11 +342,12 @@ class _Protocol(QuicConnectionProtocol):
 class _Path:
     """One client session's punched pair and the QUIC connection over it."""
 
-    def __init__(self, key: str, user: str, ice: Connection, bound: Optional[dict] = None):
+    def __init__(self, key: str, user: str, ice: Connection, bound: Optional[dict] = None, hold: float = 0.0):
         self.key = key
         self.user = user
         self.ice = ice
         self.bound = bound
+        self.hold = hold  # seconds to wait for the client's first check (a fixed port was offered too)
         self.peer: Optional[tuple[str, int]] = None
         self.calls = 0
         self.task: Optional[asyncio.Task] = None
@@ -312,24 +356,31 @@ class _Path:
 
     async def run(self) -> None:
         protocol = None
+        stage = "ICE"
         try:
+            if self.hold:
+                with contextlib.suppress(asyncio.TimeoutError):
+                    await asyncio.wait_for(self.ice.heard.wait(), self.hold)
             await asyncio.wait_for(self.ice.connect(), CONNECT_SECONDS)
             self.peer = peer_address(self.ice)
+            stage = "the QUIC Initial"
             protocol = await asyncio.wait_for(self._accept(), CONNECT_SECONDS)
             pump = asyncio.ensure_future(self._pump(protocol))
             closed = asyncio.ensure_future(protocol.wait_closed())
             try:
+                stage = "the QUIC handshake"
                 try:
                     await asyncio.wait_for(protocol.wait_connected(), CONNECT_SECONDS)
                 except ConnectionError:
                     raise ConnectionError(f"QUIC handshake failed: {protocol.terminated}") from None
                 where = "offsite" if is_offsite(self.peer[0]) else "local"
-                printf(f"Direct path open: {self.user} from {self.peer[0]}:{self.peer[1]} ({where})", Sty.GRAY)
+                say(f"Direct path open: {self.user} from {self.peer[0]}:{self.peer[1]} ({where})")
                 await asyncio.wait({pump, closed}, return_when=asyncio.FIRST_COMPLETED)
             finally:
                 await cancel_tasks((pump, closed))
         except Exception as exc:  # noqa: BLE001 - a failed punch is expected on some networks
-            printf(f"Direct path failed: {self.user}: {type(exc).__name__}: {exc}", Sty.GRAY)
+            held = f"; held {self.hold:g} s" if self.hold else ""
+            say(f"Direct path failed: {self.user}: {describe_failure(exc, stage)}; offered {describe_remotes(self.ice)}{held}")
         finally:
             if protocol is not None:
                 protocol.close()
@@ -339,7 +390,7 @@ class _Path:
             await self.close()
             if self.peer is not None:
                 why = f" ({protocol.terminated})" if protocol is not None and protocol.terminated else ""
-                printf(f"Direct path closed: {self.user} from {self.peer[0]}:{self.peer[1]} after {self.calls} calls{why}", Sty.GRAY)
+                say(f"Direct path closed: {self.user} from {self.peer[0]}:{self.peer[1]} after {self.calls} calls{why}")
 
     async def _accept(self) -> QuicConnectionProtocol:
         """The client's Initial packet decides the connection, as aioquic's server does."""
@@ -423,10 +474,10 @@ async def _serve_call(path, reader: asyncio.StreamReader, writer: asyncio.Stream
     if bad_frame is not None:
         # A client that cannot frame a request is not ours; its bytes are
         # still arriving and would only pile up in this stream's buffer.
-        printf(f"Direct path dropped: {path.user} sent a {bad_frame}", Sty.GRAY)
+        say(f"Direct path dropped: {path.user} sent a {bad_frame}")
         await path.drop()
     if refused is not None:
-        printf(f"Direct path refused: {path.user}: {refused}", Sty.GRAY)
+        say(f"Direct path refused: {path.user}: {refused}")
         await path.drop()
 
 
@@ -475,7 +526,7 @@ class _Conn(_Protocol):
             if self.key is not None and _paths.get(self.key) is self:
                 del _paths[self.key]
                 why = f" ({self.terminated})" if self.terminated else ""
-                printf(f"Direct path closed: {self.user} from {self.peer[0]}:{self.peer[1]} after {self.calls} calls{why}", Sty.GRAY)
+                say(f"Direct path closed: {self.user} from {self.peer[0]}:{self.peer[1]} after {self.calls} calls{why}")
 
     def _stream(self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter) -> None:
         task = asyncio.ensure_future(self._hello(reader, writer) if self.key is None else _serve_call(self, reader, writer))
@@ -487,7 +538,7 @@ class _Conn(_Protocol):
             await self._claim(reader, writer)
         except Exception as exc:  # noqa: BLE001 - a hello that cannot be honoured closes the connection
             logger.warning("direct path fixed-port hello failed: %r", exc)
-            printf(f"Direct path fixed-port hello failed: {type(exc).__name__}: {exc}", Sty.GRAY)
+            say(f"Direct path fixed-port hello failed: {type(exc).__name__}: {exc}")
             self.close()
 
     async def _claim(self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter) -> None:
@@ -509,7 +560,7 @@ class _Conn(_Protocol):
         writer.write(frame(json.dumps({"ok": True}).encode()))
         writer.write_eof()
         where = "offsite" if is_offsite(self.peer[0]) else "local"
-        printf(f"Direct path open: {self.user} from {self.peer[0]}:{self.peer[1]} ({where}, fixed port)", Sty.GRAY)
+        say(f"Direct path open: {self.user} from {self.peer[0]}:{self.peer[1]} ({where}, fixed port)")
 
     async def drop(self) -> None:
         if self.key is not None and _paths.get(self.key) is self:
@@ -569,13 +620,17 @@ async def _offer(key: str, user: str, remote: dict, bound: Optional[dict] = None
     except Exception:
         await close_ice(ice)
         raise
-    path = _paths[key] = _Path(key, user, ice, bound)
+    fixed = _fixed_port_offer(key, user, bound)
+    # A client that races the fixed port against the punch says so ("race")
+    # and needs only a short hold; a 2.1.0 offer has no such key.
+    hold = 0.0 if not fixed else RACE_HOLD_SECONDS if remote.get("race") else HOLD_SECONDS
+    path = _paths[key] = _Path(key, user, ice, bound, hold=hold)
     path.task = asyncio.ensure_future(path.run())
     return {
         "ufrag": ice.local_username,
         "pwd": ice.local_password,
         "candidates": [candidate.to_sdp() for candidate in ice.local_candidates],
-        **_fixed_port_offer(key, user, bound),
+        **fixed,
     }
 
 
@@ -612,8 +667,9 @@ def offer(session_key: str, user: str, ice: str) -> dict:
         answer = asyncio.run_coroutine_threadsafe(
             _offer(key, user, remote), _get_loop()
         ).result(20)
-    except Exception as exc:  # noqa: BLE001
-        return {"ace": map_arg(f"direct path unavailable: {exc}")}
+    except Exception as exc:  # noqa: BLE001 - the console gets the detail, the client a fixed line
+        say(f"Direct path offer failed: {user}: {type(exc).__name__}: {exc}")
+        return {"ace": map_arg("direct path unavailable")}
     return {"ice": map_arg(json.dumps(answer)), "server_name": map_arg(hostname() or "")}