wifi: replace NetworkManager with wpa_supplicant

Author: andiradulescu

openpilot/selfdrive/ui/layouts/settings/settings.py

@@ -53,7 +53,6 @@ def __init__(self):
 
     # Panel configuration
     wifi_manager = WifiManager()
-    wifi_manager.set_active(False)
 
     self._panels = {
       PanelType.DEVICE: PanelInfo(tr_noop("Device"), DeviceLayout()),

openpilot/selfdrive/ui/mici/layouts/settings/network/__init__.py

@@ -3,7 +3,8 @@
 from openpilot.selfdrive.ui.mici.layouts.settings.network.wifi_ui import WifiIcon
 from openpilot.selfdrive.ui.mici.widgets.button import BigButton
 from openpilot.system.ui.lib.application import gui_app
-from openpilot.system.ui.lib.wifi_manager import WifiManager, ConnectStatus, SecurityType, normalize_ssid
+from openpilot.system.ui.lib.wifi_manager import WifiManager, ConnectStatus, SecurityType
+from openpilot.system.ui.lib.wpa_ctrl import normalize_ssid
 
 
 class WifiNetworkButton(BigButton):

openpilot/selfdrive/ui/mici/layouts/settings/network/network_layout.py

@@ -14,11 +14,12 @@ def __init__(self):
     super().__init__()
 
     self._wifi_manager = WifiManager()
-    self._wifi_manager.set_active(False)
     self._wifi_ui = WifiUIMici(self._wifi_manager)
 
     self._wifi_manager.add_callbacks(
       networks_updated=self._on_network_updated,
+      activated=lambda: self._on_tethering_finished(),
+      disconnected=lambda: self._on_tethering_finished(),
     )
 
     # ******** Tethering ********
@@ -32,9 +33,13 @@ def tethering_toggle_callback(checked: bool):
 
     def tethering_password_callback(password: str):
       if password:
-        self._tethering_toggle_btn.set_enabled(False)
-        self._tethering_password_btn.set_enabled(False)
         self._wifi_manager.set_tethering_password(password)
+        if self._wifi_manager.is_tethering_active():
+          self._tethering_toggle_btn.set_enabled(False)
+          self._tethering_password_btn.set_enabled(False)
+        else:
+          self._tethering_toggle_btn.set_enabled(True)
+          self._tethering_password_btn.set_enabled(True)
 
     def tethering_password_clicked():
       tethering_password = self._wifi_manager.tethering_password
@@ -100,14 +105,12 @@ def _update_state(self):
 
   def show_event(self):
     super().show_event()
-    self._wifi_manager.set_active(True)
 
     # Process wifi callbacks while at any point in the nav stack
     gui_app.add_nav_stack_tick(self._wifi_manager.process_callbacks)
 
   def hide_event(self):
     super().hide_event()
-    self._wifi_manager.set_active(False)
 
     gui_app.remove_nav_stack_tick(self._wifi_manager.process_callbacks)
 
@@ -123,14 +126,16 @@ def update_apn(apn: str):
     dlg = BigInputDialog("enter APN...", current_apn, minimum_length=0, confirm_callback=update_apn)
     gui_app.push_widget(dlg)
 
-  def _on_network_updated(self, networks: list[Network]):
-    # Update tethering state
+  def _on_tethering_finished(self):
     tethering_active = self._wifi_manager.is_tethering_active()
-    # TODO: use real signals (like activated/settings changed, etc.) to speed up re-enabling buttons
     self._tethering_toggle_btn.set_enabled(True)
     self._tethering_password_btn.set_enabled(True)
-    self._network_metered_btn.set_enabled(lambda: not tethering_active and bool(self._wifi_manager.ipv4_address))
     self._tethering_toggle_btn.set_checked(tethering_active)
+    self._on_network_updated(self._wifi_manager.networks)
+
+  def _on_network_updated(self, networks: list[Network]):
+    tethering_active = self._wifi_manager.is_tethering_active()
+    self._network_metered_btn.set_enabled(lambda: not tethering_active and bool(self._wifi_manager.ipv4_address))
 
     # Update network metered
     self._network_metered_btn.set_value(

openpilot/selfdrive/ui/mici/layouts/settings/network/wifi_ui.py

@@ -9,7 +9,8 @@
 from openpilot.system.ui.lib.application import gui_app, MousePos, FontWeight
 from openpilot.system.ui.widgets import Widget
 from openpilot.system.ui.widgets.scroller import NavScroller
-from openpilot.system.ui.lib.wifi_manager import WifiManager, Network, SecurityType, normalize_ssid
+from openpilot.system.ui.lib.wifi_manager import WifiManager, Network, SecurityType
+from openpilot.system.ui.lib.wpa_ctrl import normalize_ssid
 
 
 class LoadingAnimation(Widget):
@@ -220,7 +221,7 @@ def _update_state(self):
       elif self._is_connected:
         self.set_value("tethering" if self._network.is_tethering else "connected")
       elif self._network_missing:
-        # after connecting/connected since NM will still attempt to connect/stay connected for a while
+        # after connecting/connected since wpa_supplicant will still attempt to connect/stay connected for a while
         self.set_value("not in range")
       else:
         self.set_value("unsupported")
@@ -297,7 +298,6 @@ def any_network_forgetting(self) -> bool:
   def show_event(self):
     # Re-sort scroller items and update from latest scan results
     super().show_event()
-    self._wifi_manager.set_active(True)
     self._networks = {n.ssid: n for n in self._wifi_manager.networks}
     self._update_buttons(re_sort=True)
 
@@ -339,6 +339,9 @@ def _connect_with_password(self, ssid: str, password: str):
     self._move_network_to_front(ssid, scroll=True)
 
   def _connect_to_network(self, ssid: str):
+    if self._wifi_manager.is_tethering_active():
+      return
+
     network = self._networks.get(ssid)
     if network is None:
       cloudlog.warning(f"Trying to connect to unknown network: {ssid}")
@@ -356,11 +359,14 @@ def _connect_to_network(self, ssid: str):
 
   def _on_need_auth(self, ssid, incorrect_password=True):
     if incorrect_password:
+      found = False
       for btn in self._scroller.items:
         if isinstance(btn, WifiButton) and btn.network.ssid == ssid:
           btn.set_wrong_password()
+          found = True
           break
-      return
+      if found:
+        return
 
     dlg = BigInputDialog("enter password...", "", minimum_length=8,
                          confirm_callback=lambda _password: self._connect_with_password(ssid, _password))

openpilot/system/ui/lib/dhcp_client.py

@@ -0,0 +1,107 @@
+"""udhcpc lifecycle for a single interface, with a one-shot default-route metric fixup."""
+import subprocess
+import threading
+
+from openpilot.common.swaglog import cloudlog
+
+
+class DhcpClient:
+  """Manage udhcpc for DHCP on wlan0."""
+
+  # Above NM's eth0 default (metric 100) so ETH keeps priority; matches NM's wifi metric.
+  DEFAULT_ROUTE_METRIC = 600
+
+  def __init__(self, iface: str = "wlan0"):
+    self._iface = iface
+    self._proc: subprocess.Popen | None = None
+    self._metric_thread: threading.Thread | None = None
+    self._metric_stop = threading.Event()
+
+  def start(self):
+    self.stop()
+    # If a previous UI/manager process crashed, its sudo udhcpc -f survives as
+    # an orphan and self.stop() above can't reach it (we only track our own Popen).
+    # Without this, two udhcpc instances would race lease renewals on the same
+    # interface and the orphan can re-add the address after a managed flush.
+    subprocess.run(["sudo", "pkill", "-f", f"udhcpc.*-i {self._iface}"], check=False)
+    self._metric_stop.clear()
+    try:
+      self._proc = subprocess.Popen(
+        ["sudo", "udhcpc", "-i", self._iface, "-f", "-t", "5", "-T", "3"],
+        stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+        start_new_session=True,
+      )
+    except Exception:
+      cloudlog.exception("Failed to start udhcpc")
+      return
+    self._metric_thread = threading.Thread(target=self._fix_default_route_metric, daemon=True)
+    self._metric_thread.start()
+
+  def _fix_default_route_metric(self):
+    """Replace udhcpc's metric-0 default route with metric 600.
+    busybox udhcpc can't set a bind-time metric; without this, wlan0 silently beats
+    eth0 on every DHCP bind. Same-router renewals skip the re-install, so a one-shot
+    bump survives the lease. Polls until the route is bumped or stop() is called;
+    no deadline because udhcpc's worst-case retry window (5×3s + 20s -A backoff)
+    can outlive any short timeout, leaving a metric-0 route to hijack eth0."""
+    while not self._metric_stop.is_set():
+      try:
+        out = subprocess.check_output(
+          ["ip", "-4", "route", "show", "default", "dev", self._iface],
+          text=True, timeout=2,
+        ).strip()
+      except Exception:
+        # Transient: udhcpc may not have installed the route yet, or the iface is briefly down.
+        # Fall through to the throttled wait and retry; stop() unblocks the loop.
+        cloudlog.exception("Failed to query wlan0 default route")
+        out = ""
+
+      for line in out.splitlines():
+        parts = line.split()
+        if "via" not in parts:
+          continue
+        try:
+          gw = parts[parts.index("via") + 1]
+        except IndexError:
+          continue
+        if "metric" in parts:
+          try:
+            if int(parts[parts.index("metric") + 1]) == self.DEFAULT_ROUTE_METRIC:
+              return
+          except (IndexError, ValueError):
+            pass
+        subprocess.run(
+          ["sudo", "ip", "-4", "route", "flush", "exact", "0.0.0.0/0", "dev", self._iface],
+          check=False,
+        )
+        subprocess.run(
+          ["sudo", "ip", "-4", "route", "add", "default", "via", gw,
+           "dev", self._iface, "metric", str(self.DEFAULT_ROUTE_METRIC)],
+          check=False,
+        )
+        return
+
+      self._metric_stop.wait(0.2)
+
+  def stop(self):
+    self._metric_stop.set()
+    if self._metric_thread is not None:
+      self._metric_thread.join(timeout=2)
+      self._metric_thread = None
+    if self._proc is not None:
+      try:
+        self._proc.terminate()
+        self._proc.wait(timeout=3)
+      except Exception:
+        try:
+          self._proc.kill()
+          self._proc.wait()
+        except Exception:
+          pass
+      self._proc = None
+      # Same orphan risk as start(): a previous sudo udhcpc -f can survive our
+      # tracked Popen (e.g. terminate timed out, sudo wrapper died but child
+      # didn't). Without this, the orphan re-adds the address right after the
+      # flush below and resurrects the route after we've moved on.
+      subprocess.run(["sudo", "pkill", "-f", f"udhcpc.*-i {self._iface}"], check=False)
+      subprocess.run(["sudo", "ip", "addr", "flush", "dev", self._iface], capture_output=True, check=False)