Listen to AccessPoints changes

Author: teclator

rust/agama-network/src/action.rs

@@ -54,6 +54,10 @@ pub enum Action {
     GetConnections(Responder<Vec<Connection>>),
     /// Gets all scanned access points
     GetAccessPoints(Responder<Vec<AccessPoint>>),
+    /// Adds a new access point.
+    AddAccessPoint(Box<AccessPoint>),
+    /// Removes an access point by its hardware address.
+    RemoveAccessPoint(String),
     /// Adds a new device.
     AddDevice(Box<Device>),
     /// Updates a device by its `name`.

rust/agama-network/src/error.rs

@@ -40,6 +40,8 @@ pub enum NetworkStateError {
     CannotUpdateConnection(String),
     #[error("Unknown device '{0}'")]
     UnknownDevice(String),
+    #[error("Unknown access point '{0}'")]
+    UnknownAccessPoint(String),
     #[error("Invalid connection UUID: '{0}'")]
     InvalidUuid(String),
     #[error("Invalid IP address: '{0}'")]

rust/agama-network/src/model.rs

@@ -343,6 +343,32 @@ impl NetworkState {
         Ok(())
     }
 
+    pub fn add_access_point(&mut self, ap: AccessPoint) -> Result<(), NetworkStateError> {
+        if let Some(position) = self
+            .access_points
+            .iter()
+            .position(|a| a.hw_address == ap.hw_address)
+        {
+            self.access_points.remove(position);
+        }
+        self.access_points.push(ap);
+
+        Ok(())
+    }
+
+    pub fn remove_access_point(&mut self, hw_address: &str) -> Result<(), NetworkStateError> {
+        let Some(position) = self
+            .access_points
+            .iter()
+            .position(|a| a.hw_address == hw_address)
+        else {
+            return Err(NetworkStateError::UnknownAccessPoint(hw_address.to_string()));
+        };
+
+        self.access_points.remove(position);
+        Ok(())
+    }
+
     /// Sets a controller's ports.
     ///
     /// If the connection is not a controller, returns an error.
@@ -460,6 +486,57 @@ mod tests {
         assert!(matches!(error, NetworkStateError::UnknownConnection(_)));
     }
 
+    #[test]
+    fn test_remove_device() {
+        let mut state = NetworkState::default();
+        let device = Device {
+            name: "eth0".to_string(),
+            ..Default::default()
+        };
+        state.add_device(device).unwrap();
+        state.remove_device("eth0").unwrap();
+        assert!(state.get_device("eth0").is_none());
+    }
+
+    #[test]
+    fn test_add_access_point() {
+        let mut state = NetworkState::default();
+        let ap = AccessPoint {
+            hw_address: "AA:BB:CC:DD:EE:FF".to_string(),
+            ssid: SSID(b"test".to_vec()),
+            ..Default::default()
+        };
+        state.add_access_point(ap.clone()).unwrap();
+        assert_eq!(state.access_points.len(), 1);
+        assert_eq!(state.access_points[0].hw_address, "AA:BB:CC:DD:EE:FF");
+
+        // Adding same AP should replace it (in our implementation we remove and push)
+        let mut ap2 = ap.clone();
+        ap2.strength = 80;
+        state.add_access_point(ap2).unwrap();
+        assert_eq!(state.access_points.len(), 1);
+        assert_eq!(state.access_points[0].strength, 80);
+    }
+
+    #[test]
+    fn test_remove_access_point() {
+        let mut state = NetworkState::default();
+        let ap = AccessPoint {
+            hw_address: "AA:BB:CC:DD:EE:FF".to_string(),
+            ..Default::default()
+        };
+        state.add_access_point(ap).unwrap();
+        state.remove_access_point("AA:BB:CC:DD:EE:FF").unwrap();
+        assert_eq!(state.access_points.len(), 0);
+    }
+
+    #[test]
+    fn test_remove_unknown_access_point() {
+        let mut state = NetworkState::default();
+        let error = state.remove_access_point("unknown").unwrap_err();
+        assert!(matches!(error, NetworkStateError::UnknownAccessPoint(_)));
+    }
+
     #[test]
     fn test_is_loopback() {
         let conn = Connection::new("eth0".to_string(), DeviceType::Ethernet);
@@ -1740,6 +1817,10 @@ pub enum NetworkChange {
         id: String,
         state: ConnectionState,
     },
+    /// A new access point has been added.
+    AccessPointAdded(AccessPoint),
+    /// An access point has been removed.
+    AccessPointRemoved(String),
 }
 
 #[derive(Default, Debug, PartialEq, Clone, Deserialize, Serialize, utoipa::ToSchema)]

rust/agama-network/src/nm/builder.rs

@@ -25,9 +25,12 @@ use crate::{
     nm::{
         dbus::connection_from_dbus,
         model::NmDeviceType,
-        proxies::{ConnectionProxy, DeviceProxy, IP4ConfigProxy, IP6ConfigProxy},
+        proxies::{AccessPointProxy, ConnectionProxy, DeviceProxy, IP4ConfigProxy, IP6ConfigProxy},
+    },
+    types::{
+        AccessPoint, ConnectionFlags, Device, DeviceState, DeviceType, IpConfig, IpRoute,
+        MacAddress, SSID,
     },
-    types::{ConnectionFlags, Device, DeviceState, DeviceType, IpConfig, IpRoute, MacAddress},
 };
 use cidr::IpInet;
 use std::{collections::HashMap, net::IpAddr, str::FromStr};
@@ -44,6 +47,38 @@ pub struct DeviceFromProxyBuilder<'a> {
     proxy: &'a DeviceProxy<'a>,
 }
 
+/// Builder to create an [AccessPoint] from its corresponding NetworkManager D-Bus representation.
+pub struct AccessPointFromProxyBuilder<'a> {
+    device_name: String,
+    proxy: &'a AccessPointProxy<'a>,
+}
+
+impl<'a> AccessPointFromProxyBuilder<'a> {
+    pub fn new(device_name: String, proxy: &'a AccessPointProxy<'a>) -> Self {
+        Self { device_name, proxy }
+    }
+
+    /// Creates an [AccessPoint] starting on the [AccessPointProxy].
+    pub async fn build(&self) -> Result<AccessPoint, NmError> {
+        let ssid = SSID(self.proxy.ssid().await?);
+        let hw_address = self.proxy.hw_address().await?;
+        let strength = self.proxy.strength().await?;
+        let flags = self.proxy.flags().await?;
+        let rsn_flags = self.proxy.rsn_flags().await?;
+        let wpa_flags = self.proxy.wpa_flags().await?;
+
+        Ok(AccessPoint {
+            device: self.device_name.clone(),
+            ssid,
+            hw_address,
+            strength,
+            flags,
+            rsn_flags,
+            wpa_flags,
+        })
+    }
+}
+
 impl<'a> ConnectionFromProxyBuilder<'a> {
     pub fn new(_connection: &zbus::Connection, proxy: &'a ConnectionProxy<'a>) -> Self {
         Self { proxy }

rust/agama-network/src/nm/streams/common.rs

@@ -35,6 +35,8 @@ pub enum NmChange {
     ActiveConnectionAdded(OwnedObjectPath),
     ActiveConnectionUpdated(OwnedObjectPath),
     ActiveConnectionRemoved(OwnedObjectPath),
+    AccessPointAdded(OwnedObjectPath, OwnedObjectPath),
+    AccessPointRemoved(OwnedObjectPath, OwnedObjectPath),
 }
 
 pub async fn build_added_and_removed_stream(
@@ -63,3 +65,17 @@ pub async fn build_properties_changed_stream(
     let stream = MessageStream::for_match_rule(rule, connection, Some(1)).await?;
     Ok(stream)
 }
+
+/// Returns a stream of wireless signals to be used by DeviceChangedStream.
+///
+/// It listens for AccessPointAdded and AccessPointRemoved signals.
+pub async fn build_wireless_signals_stream(
+    connection: &zbus::Connection,
+) -> Result<MessageStream, NmError> {
+    let rule = MatchRule::builder()
+        .msg_type(MessageType::Signal)
+        .interface("org.freedesktop.NetworkManager.Device.Wireless")?
+        .build();
+    let stream = MessageStream::for_match_rule(rule, connection, Some(1)).await?;
+    Ok(stream)
+}

rust/agama-network/src/nm/streams/devices.rs

@@ -33,7 +33,10 @@ use zbus::{
     Message, MessageStream,
 };
 
-use super::common::{build_added_and_removed_stream, build_properties_changed_stream, NmChange};
+use super::common::{
+    build_added_and_removed_stream, build_properties_changed_stream, build_wireless_signals_stream,
+    NmChange,
+};
 use crate::nm::error::NmError;
 
 /// Stream of device-related events.
@@ -64,6 +67,10 @@ impl DeviceChangedStream {
             "properties",
             build_properties_changed_stream(&connection).await?,
         );
+        inner.insert(
+            "wireless",
+            build_wireless_signals_stream(&connection).await?,
+        );
         Ok(Self { connection, inner })
     }
 
@@ -161,6 +168,25 @@ impl DeviceChangedStream {
             return Self::handle_changed(changed);
         }
 
+        let header = message.header();
+        let interface = header.interface()?;
+        if interface == "org.freedesktop.NetworkManager.Device.Wireless" {
+            let path = OwnedObjectPath::from(header.path()?.to_owned());
+            let member = header.member()?;
+
+            match member.as_str() {
+                "AccessPointAdded" => {
+                    let ap_path: OwnedObjectPath = message.body().deserialize().ok()?;
+                    return Some(NmChange::AccessPointAdded(path, ap_path));
+                }
+                "AccessPointRemoved" => {
+                    let ap_path: OwnedObjectPath = message.body().deserialize().ok()?;
+                    return Some(NmChange::AccessPointRemoved(path, ap_path));
+                }
+                _ => {}
+            }
+        }
+
         None
     }
 }