Add Wi-Fi and Bluetooth settings and compact controls

shell/ferese-settings/src/connections/contracts.rs

@@ -0,0 +1,572 @@
+//! Private-bus contracts exercise serialized method/property signatures without hardware.
+use std::collections::HashMap;
+use std::io::{BufRead, BufReader};
+use std::process::{Child, Command, Stdio};
+use std::sync::{Arc, Mutex};
+use std::time::Duration;
+
+use zbus::Connection;
+use zbus::message::Header;
+use zbus::zvariant::{OwnedObjectPath, OwnedValue, Str};
+use zeroize::Zeroizing;
+
+use super::agent::Kind;
+use super::{Client, Command as Action, proxy};
+
+const NM: &str = "org.freedesktop.NetworkManager";
+const ROOT: &str = "/org/freedesktop/NetworkManager";
+const ADAPTER: &str = "/org/bluez/hci0";
+const DEVICE: &str = "/org/bluez/hci0/dev_1";
+type Settings = HashMap<String, HashMap<String, OwnedValue>>;
+
+fn path(value: &str) -> OwnedObjectPath {
+    OwnedObjectPath::try_from(value).unwrap()
+}
+
+struct Bus {
+    child: Child,
+    address: String,
+}
+
+impl Bus {
+    fn new() -> Self {
+        let mut child = Command::new("dbus-daemon")
+            .args(["--session", "--nofork", "--print-address=1"])
+            .stdout(Stdio::piped())
+            .spawn()
+            .unwrap();
+        let mut address = String::new();
+        BufReader::new(child.stdout.take().unwrap())
+            .read_line(&mut address)
+            .unwrap();
+        assert!(
+            !address.trim().is_empty(),
+            "dbus-daemon did not provide an address; check whether Unix sockets are permitted"
+        );
+        Self {
+            child,
+            address: address.trim().to_owned(),
+        }
+    }
+
+    async fn connect(&self) -> Connection {
+        zbus::connection::Builder::address(self.address.as_str())
+            .unwrap()
+            .method_timeout(Duration::from_secs(5))
+            .build()
+            .await
+            .unwrap()
+    }
+}
+
+impl Drop for Bus {
+    fn drop(&mut self) {
+        let _ = self.child.kill();
+        let _ = self.child.wait();
+    }
+}
+
+#[derive(Default)]
+struct NetworkState {
+    enabled: bool,
+    scans: usize,
+    activated: bool,
+    deleted: bool,
+    updates: usize,
+    received: Option<Settings>,
+}
+
+struct Manager(Arc<Mutex<NetworkState>>);
+
+#[zbus::interface(name = "org.freedesktop.NetworkManager")]
+impl Manager {
+    fn get_devices(&self) -> Vec<OwnedObjectPath> {
+        vec![path("/device")]
+    }
+
+    #[zbus(property)]
+    fn wireless_enabled(&self) -> bool {
+        self.0.lock().unwrap().enabled
+    }
+
+    #[zbus(property)]
+    fn set_wireless_enabled(&self, enabled: bool) {
+        self.0.lock().unwrap().enabled = enabled;
+    }
+
+    #[zbus(property)]
+    fn wireless_hardware_enabled(&self) -> bool {
+        true
+    }
+
+    fn activate_connection(
+        &self,
+        connection: OwnedObjectPath,
+        device: OwnedObjectPath,
+        ap: OwnedObjectPath,
+    ) -> OwnedObjectPath {
+        assert_eq!(connection.as_str(), "/profile");
+        assert_eq!(device.as_str(), "/device");
+        assert_eq!(ap.as_str(), "/ap");
+        self.0.lock().unwrap().activated = true;
+        path("/active")
+    }
+
+    fn add_and_activate_connection(
+        &self,
+        settings: Settings,
+        device: OwnedObjectPath,
+        ap: OwnedObjectPath,
+    ) -> (OwnedObjectPath, OwnedObjectPath) {
+        assert_eq!(device.as_str(), "/device");
+        assert_eq!(ap.as_str(), "/ap");
+        let mut state = self.0.lock().unwrap();
+        state.received = Some(settings);
+        state.activated = true;
+        (path("/profile"), path("/active"))
+    }
+}
+
+struct Wireless(Arc<Mutex<NetworkState>>);
+
+#[zbus::interface(name = "org.freedesktop.NetworkManager.Device.Wireless")]
+impl Wireless {
+    fn get_all_access_points(&self) -> Vec<OwnedObjectPath> {
+        vec![path("/ap")]
+    }
+
+    fn request_scan(&self, options: HashMap<String, OwnedValue>) {
+        assert!(options.is_empty());
+        self.0.lock().unwrap().scans += 1;
+    }
+
+    #[zbus(property)]
+    fn active_access_point(&self) -> OwnedObjectPath {
+        path(if self.0.lock().unwrap().activated { "/ap" } else { "/" })
+    }
+}
+
+struct NetworkDevice(Arc<Mutex<NetworkState>>);
+
+#[zbus::interface(name = "org.freedesktop.NetworkManager.Device")]
+impl NetworkDevice {
+    #[zbus(property)]
+    fn device_type(&self) -> u32 {
+        2
+    }
+
+    #[zbus(property)]
+    fn interface(&self) -> &str {
+        "wlan0"
+    }
+
+    #[zbus(property)]
+    fn state(&self) -> u32 {
+        if self.0.lock().unwrap().activated { 100 } else { 30 }
+    }
+
+    fn disconnect(&self) {
+        self.0.lock().unwrap().activated = false;
+    }
+}
+
+struct AccessPoint;
+
+#[zbus::interface(name = "org.freedesktop.NetworkManager.AccessPoint")]
+impl AccessPoint {
+    #[zbus(property)]
+    fn ssid(&self) -> Vec<u8> {
+        b"Test network".to_vec()
+    }
+
+    #[zbus(property)]
+    fn strength(&self) -> u8 {
+        75
+    }
+
+    #[zbus(property)]
+    fn flags(&self) -> u32 {
+        1
+    }
+
+    #[zbus(property)]
+    fn wpa_flags(&self) -> u32 {
+        0
+    }
+
+    #[zbus(property)]
+    fn rsn_flags(&self) -> u32 {
+        0x100
+    }
+}
+
+struct Profiles(Arc<Mutex<NetworkState>>);
+
+#[zbus::interface(name = "org.freedesktop.NetworkManager.Settings")]
+impl Profiles {
+    fn list_connections(&self) -> Vec<OwnedObjectPath> {
+        if self.0.lock().unwrap().deleted {
+            vec![]
+        } else {
+            vec![path("/profile")]
+        }
+    }
+}
+
+struct Profile(Arc<Mutex<NetworkState>>);
+
+#[zbus::interface(name = "org.freedesktop.NetworkManager.Settings.Connection")]
+impl Profile {
+    fn get_settings(&self) -> Settings {
+        HashMap::from([
+            (
+                "connection".into(),
+                HashMap::from([("id".into(), OwnedValue::from(Str::from("Test network")))]),
+            ),
+            (
+                "802-11-wireless".into(),
+                HashMap::from([(
+                    "ssid".into(),
+                    OwnedValue::try_from(zbus::zvariant::Value::from(b"Test network".as_slice())).unwrap(),
+                )]),
+            ),
+            (
+                "802-11-wireless-security".into(),
+                HashMap::from([("key-mgmt".into(), OwnedValue::from(Str::from("wpa-psk")))]),
+            ),
+        ])
+    }
+
+    fn update(&self, settings: Settings) {
+        let mut state = self.0.lock().unwrap();
+        state.updates += 1;
+        state.received = Some(settings);
+    }
+
+    fn delete(&self) {
+        self.0.lock().unwrap().deleted = true;
+    }
+}
+
+struct Active;
+
+#[zbus::interface(name = "org.freedesktop.NetworkManager.Connection.Active")]
+impl Active {
+    #[zbus(property)]
+    fn state(&self) -> u32 {
+        2
+    }
+}
+
+async fn network_service(bus: &Bus, state: &Arc<Mutex<NetworkState>>) -> Connection {
+    let server = bus.connect().await;
+    server.request_name(NM).await.unwrap();
+    let objects = server.object_server();
+    objects.at(ROOT, Manager(state.clone())).await.unwrap();
+    objects.at("/device", Wireless(state.clone())).await.unwrap();
+    objects.at("/device", NetworkDevice(state.clone())).await.unwrap();
+    objects.at("/ap", AccessPoint).await.unwrap();
+    objects
+        .at("/org/freedesktop/NetworkManager/Settings", Profiles(state.clone()))
+        .await
+        .unwrap();
+    objects.at("/profile", Profile(state.clone())).await.unwrap();
+    objects.at("/active", Active).await.unwrap();
+    server
+}
+
+#[tokio::test]
+#[ignore = "requires dbus-daemon; uses a private bus, never the system bus"]
+async fn wifi_controls_and_missing_bluetooth_are_independent() {
+    let bus = Bus::new();
+    let state = Arc::new(Mutex::new(NetworkState::default()));
+    let _server = network_service(&bus, &state).await;
+    let client = Client::with_connection(bus.connect().await);
+    let initial = client.snapshot().await;
+    assert!(initial.bluetooth.is_err());
+    assert!(!initial.wifi.unwrap().enabled);
+    client.execute(Action::WifiPower(true)).await.unwrap();
+    client.execute(Action::WifiScan).await.unwrap();
+    let wifi = client.snapshot().await.wifi.unwrap();
+    assert!(wifi.enabled);
+    assert_eq!(wifi.networks[0].name, "Test network");
+    assert_eq!(wifi.networks[0].saved.as_deref(), Some("/profile"));
+    client
+        .execute(Action::WifiConnect(
+            wifi.networks[0].clone(),
+            Zeroizing::new("updated-password".into()),
+        ))
+        .await
+        .unwrap();
+    {
+        let state = state.lock().unwrap();
+        assert_eq!(state.updates, 1);
+        assert_eq!(state.scans, 1);
+        assert_eq!(
+            <&str>::try_from(&state.received.as_ref().unwrap()["802-11-wireless-security"]["psk"]).unwrap(),
+            "updated-password"
+        );
+    }
+    assert!(client.snapshot().await.wifi.unwrap().networks[0].connected);
+    client.execute(Action::WifiDisconnect("/device".into())).await.unwrap();
+    assert!(!client.snapshot().await.wifi.unwrap().networks[0].connected);
+    let mut unsaved = wifi.networks[0].clone();
+    unsaved.saved = None;
+    client
+        .execute(Action::WifiConnect(unsaved, Zeroizing::new("new-password".into())))
+        .await
+        .unwrap();
+    client.execute(Action::WifiForget("/profile".into())).await.unwrap();
+    assert!(client.snapshot().await.wifi.unwrap().saved.is_empty());
+}
+
+#[derive(Default)]
+struct BluetoothState {
+    powered: bool,
+    discovering: bool,
+    paired: bool,
+    connected: bool,
+    trusted: bool,
+    starts: usize,
+    stops: usize,
+    removed: bool,
+    agent: Option<(String, OwnedObjectPath)>,
+}
+
+struct Adapter(Arc<Mutex<BluetoothState>>);
+
+#[zbus::interface(name = "org.bluez.Adapter1")]
+impl Adapter {
+    #[zbus(property)]
+    fn alias(&self) -> &str {
+        "Laptop"
+    }
+
+    #[zbus(property)]
+    fn powered(&self) -> bool {
+        self.0.lock().unwrap().powered
+    }
+
+    #[zbus(property)]
+    fn set_powered(&self, powered: bool) {
+        self.0.lock().unwrap().powered = powered;
+    }
+
+    #[zbus(property)]
+    fn discovering(&self) -> bool {
+        self.0.lock().unwrap().discovering
+    }
+
+    fn start_discovery(&self) {
+        let mut s = self.0.lock().unwrap();
+        s.discovering = true;
+        s.starts += 1;
+    }
+
+    fn stop_discovery(&self) {
+        let mut s = self.0.lock().unwrap();
+        s.discovering = false;
+        s.stops += 1;
+    }
+
+    fn remove_device(&self, device: OwnedObjectPath) {
+        assert_eq!(device.as_str(), DEVICE);
+        self.0.lock().unwrap().removed = true;
+    }
+}
+
+struct BluetoothDevice(Arc<Mutex<BluetoothState>>);
+
+#[zbus::interface(name = "org.bluez.Device1")]
+impl BluetoothDevice {
+    #[zbus(property)]
+    fn adapter(&self) -> OwnedObjectPath {
+        path(ADAPTER)
+    }
+
+    #[zbus(property)]
+    fn alias(&self) -> &str {
+        "Headphones"
+    }
+
+    #[zbus(property)]
+    fn address(&self) -> &str {
+        "AA:BB:CC:DD:EE:FF"
+    }
+
+    #[zbus(property)]
+    fn icon(&self) -> &str {
+        "audio-headset"
+    }
+
+    #[zbus(property)]
+    fn connected(&self) -> bool {
+        self.0.lock().unwrap().connected
+    }
+
+    #[zbus(property)]
+    fn paired(&self) -> bool {
+        self.0.lock().unwrap().paired
+    }
+
+    #[zbus(property)]
+    fn trusted(&self) -> bool {
+        self.0.lock().unwrap().trusted
+    }
+
+    #[zbus(property)]
+    fn set_trusted(&self, trusted: bool) {
+        self.0.lock().unwrap().trusted = trusted;
+    }
+
+    async fn pair(&self, #[zbus(connection)] connection: &Connection) -> zbus::fdo::Result<()> {
+        let (owner, agent) = self.0.lock().unwrap().agent.clone().unwrap();
+        proxy(connection, &owner, agent.as_str(), "org.bluez.Agent1")
+            .await
+            .map_err(zbus::fdo::Error::Failed)?
+            .call::<_, _, ()>("RequestConfirmation", &(path(DEVICE), 123456u32))
+            .await
+            .map_err(|e| zbus::fdo::Error::Failed(e.to_string()))?;
+        self.0.lock().unwrap().paired = true;
+        Ok(())
+    }
+
+    fn connect(&self) {
+        self.0.lock().unwrap().connected = true;
+    }
+
+    fn disconnect(&self) {
+        self.0.lock().unwrap().connected = false;
+    }
+
+    fn cancel_pairing(&self) {}
+}
+
+struct AgentManager(Arc<Mutex<BluetoothState>>);
+
+#[zbus::interface(name = "org.bluez.AgentManager1")]
+impl AgentManager {
+    fn register_agent(&self, agent: OwnedObjectPath, capability: String, #[zbus(header)] header: Header<'_>) {
+        assert_eq!(capability, "KeyboardDisplay");
+        self.0.lock().unwrap().agent = Some((header.sender().unwrap().to_string(), agent));
+    }
+}
+
+async fn bluetooth_service(bus: &Bus, state: &Arc<Mutex<BluetoothState>>) -> Connection {
+    let server = bus.connect().await;
+    server.request_name("org.bluez").await.unwrap();
+    let objects = server.object_server();
+    objects.at("/", zbus::fdo::ObjectManager).await.unwrap();
+    objects.at("/org/bluez", AgentManager(state.clone())).await.unwrap();
+    objects.at(ADAPTER, Adapter(state.clone())).await.unwrap();
+    objects.at(DEVICE, BluetoothDevice(state.clone())).await.unwrap();
+    server
+}
+
+async fn wait_for_prompt(client: &Client) -> super::agent::Prompt {
+    tokio::time::timeout(Duration::from_secs(3), async {
+        loop {
+            if let Some(prompt) = client.prompt() {
+                break prompt;
+            }
+            tokio::time::sleep(Duration::from_millis(10)).await;
+        }
+    })
+    .await
+    .unwrap()
+}
+
+#[tokio::test]
+#[ignore = "requires dbus-daemon; uses a private bus, never the system bus"]
+async fn bluetooth_pairing_controls_and_close_cleanup() {
+    let bus = Bus::new();
+    let state = Arc::new(Mutex::new(BluetoothState::default()));
+    let _server = bluetooth_service(&bus, &state).await;
+    let client = Client::with_connection(bus.connect().await);
+    let epoch = client.epoch();
+    client.leave_now();
+    assert!(
+        client
+            .execute_checked(Action::BluetoothPower(ADAPTER.into(), true), epoch)
+            .await
+            .is_err()
+    );
+    assert!(!state.lock().unwrap().powered);
+    client
+        .execute(Action::BluetoothPower(ADAPTER.into(), true))
+        .await
+        .unwrap();
+    client.execute(Action::BluetoothScan(ADAPTER.into())).await.unwrap();
+    client.execute(Action::BluetoothScan(ADAPTER.into())).await.unwrap();
+    assert_eq!(state.lock().unwrap().starts, 1);
+    let snapshot = client.snapshot().await;
+    assert!(snapshot.wifi.is_err());
+    let bluetooth = snapshot.bluetooth.unwrap();
+    assert!(bluetooth.adapters[0].powered);
+    assert_eq!(bluetooth.devices[0].name, "Headphones");
+    let other = client.clone();
+    let pairing = tokio::spawn(async move { other.execute(Action::BluetoothPair(DEVICE.into())).await });
+    let prompt = wait_for_prompt(&client).await;
+    assert_eq!(prompt.kind, Kind::Confirm(123456));
+    client.reply(prompt.id, Some(Zeroizing::new(String::new())));
+    pairing.await.unwrap().unwrap();
+    {
+        let state = state.lock().unwrap();
+        assert!(state.paired && state.connected && state.trusted);
+    }
+    client
+        .execute(Action::BluetoothDisconnect(DEVICE.into()))
+        .await
+        .unwrap();
+    client
+        .execute(Action::BluetoothTrust(DEVICE.into(), false))
+        .await
+        .unwrap();
+    assert!(!state.lock().unwrap().trusted);
+    client.execute(Action::BluetoothConnect(DEVICE.into())).await.unwrap();
+    client
+        .execute(Action::BluetoothForget(ADAPTER.into(), DEVICE.into()))
+        .await
+        .unwrap();
+    assert!(state.lock().unwrap().removed);
+    let other = client.clone();
+    let pairing = tokio::spawn(async move { other.execute(Action::BluetoothPair(DEVICE.into())).await });
+    wait_for_prompt(&client).await;
+    // Window destruction happens on a UI thread outside Tokio's context.
+    let closing = client.clone();
+    std::thread::spawn(move || closing.shutdown()).join().unwrap();
+    assert!(pairing.await.unwrap().is_err());
+    assert!(client.execute(Action::BluetoothConnect(DEVICE.into())).await.is_err());
+    assert!(client.prompt().is_none());
+    tokio::time::timeout(Duration::from_secs(3), async {
+        while state.lock().unwrap().discovering {
+            tokio::time::sleep(Duration::from_millis(10)).await;
+        }
+    })
+    .await
+    .unwrap();
+    assert_eq!(state.lock().unwrap().stops, 1);
+}
+
+#[tokio::test]
+#[ignore = "requires dbus-daemon; uses a private bus, never the system bus"]
+async fn bluetooth_agent_recovers_after_service_restart() {
+    let bus = Bus::new();
+    let state = Arc::new(Mutex::new(BluetoothState::default()));
+    let old_server = bluetooth_service(&bus, &state).await;
+    let client = Client::with_connection(bus.connect().await);
+    let other = client.clone();
+    let pairing = tokio::spawn(async move { other.execute(Action::BluetoothPair(DEVICE.into())).await });
+    let prompt = wait_for_prompt(&client).await;
+    client.reply(prompt.id, Some(Zeroizing::new(String::new())));
+    pairing.await.unwrap().unwrap();
+    old_server.release_name("org.bluez").await.unwrap();
+    let new_state = Arc::new(Mutex::new(BluetoothState::default()));
+    let _server = bluetooth_service(&bus, &new_state).await;
+    let other = client.clone();
+    let pairing = tokio::spawn(async move { other.execute(Action::BluetoothPair(DEVICE.into())).await });
+    let prompt = wait_for_prompt(&client).await;
+    client.reply(prompt.id, Some(Zeroizing::new(String::new())));
+    pairing.await.unwrap().unwrap();
+    assert!(new_state.lock().unwrap().paired);
+}