feat(#177): add is_connecting() for concurrency protection

Author: cachebag

nmrs/CHANGELOG.md

@@ -3,6 +3,8 @@
 All notable changes to the `nmrs` crate will be documented in this file.
 
 ## [Unreleased]
+### Added
+- Concurrency protection ([#268](https://github.com/cachebag/nmrs/pull/268))
 ### Changed
 - Convert BDADDR to BlueZ device path via `bluez_device_path` helper ([#266](https://github.com/cachebag/nmrs/pull/266))
 

nmrs/src/api/network_manager.rs

@@ -11,7 +11,8 @@ use crate::core::connection_settings::{
     get_saved_connection_path, has_saved_connection, list_saved_connections,
 };
 use crate::core::device::{
-    list_bluetooth_devices, list_devices, set_wifi_enabled, wait_for_wifi_ready, wifi_enabled,
+    is_connecting, list_bluetooth_devices, list_devices, set_wifi_enabled, wait_for_wifi_ready,
+    wifi_enabled,
 };
 use crate::core::scan::{current_network, list_networks, scan_networks};
 use crate::core::vpn::{connect_vpn, disconnect_vpn, get_vpn_info, list_vpn_connections};
@@ -114,6 +115,14 @@ use crate::Result;
 ///
 /// `NetworkManager` is `Clone` and can be safely shared across async tasks.
 /// Each clone shares the same underlying D-Bus connection.
+///
+/// # Concurrency
+///
+/// Concurrent connection operations (e.g. calling [`connect`](Self::connect)
+/// from multiple tasks simultaneously) are **not supported** and may cause
+/// race conditions. Use [`is_connecting`](Self::is_connecting) to check
+/// whether a connection operation is already in progress before starting
+/// a new one.
 #[derive(Debug, Clone)]
 pub struct NetworkManager {
     conn: Connection,
@@ -425,6 +434,32 @@ impl NetworkManager {
         scan_networks(&self.conn).await
     }
 
+    /// Returns whether any network device is currently in a transitional state.
+    ///
+    /// A device is considered "connecting" when its state is one of:
+    /// Prepare, Config, NeedAuth, IpConfig, IpCheck, Secondaries, or Deactivating.
+    ///
+    /// Use this to guard against concurrent connection attempts, which are
+    /// not supported and may cause undefined behavior.
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// use nmrs::NetworkManager;
+    ///
+    /// # async fn example() -> nmrs::Result<()> {
+    /// let nm = NetworkManager::new().await?;
+    ///
+    /// if nm.is_connecting().await? {
+    ///     eprintln!("A connection operation is already in progress");
+    /// }
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub async fn is_connecting(&self) -> Result<bool> {
+        is_connecting(&self.conn).await
+    }
+
     /// Check if a network is connected
     pub async fn is_connected(&self, ssid: &str) -> Result<bool> {
         is_connected(&self.conn, ssid).await

nmrs/src/core/device.rs

@@ -134,6 +134,37 @@ pub(crate) async fn list_devices(conn: &Connection) -> Result<Vec<Device>> {
     Ok(devices)
 }
 
+/// Returns `true` if any network device is in a transitional state
+/// (preparing, configuring, authenticating, obtaining IP, etc.).
+///
+/// Useful for guarding against concurrent connection attempts.
+pub(crate) async fn is_connecting(conn: &Connection) -> Result<bool> {
+    let nm = NMProxy::new(conn).await?;
+    let devices = nm.get_devices().await?;
+
+    for dp in devices {
+        let dev = NMDeviceProxy::builder(conn)
+            .path(dp.clone())?
+            .build()
+            .await?;
+
+        let raw_state = dev
+            .state()
+            .await
+            .map_err(|e| ConnectionError::DbusOperation {
+                context: format!("failed to get state for device {}", dp.as_str()),
+                source: e,
+            })?;
+
+        let state: DeviceState = raw_state.into();
+        if state.is_transitional() {
+            return Ok(true);
+        }
+    }
+
+    Ok(false)
+}
+
 pub(crate) async fn list_bluetooth_devices(conn: &Connection) -> Result<Vec<BluetoothDevice>> {
     let proxy = NMProxy::new(conn).await?;
     let paths = proxy.get_devices().await?;