leyoda/cosmic-applets
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Fixed connecting and disconnecting to wrong hw_device

Browse source
This commit is contained in:
András 2024-12-06 21:32:37 +02:00 • committed by Michael Murphy
parent 2198fa9b9a
commit 95abfcab27
2 changed files with 72 additions and 51 deletions
Download patch file Download diff file Expand all files Collapse all files

73
cosmic-applet-network/src/app.rs
View file

@ -34,14 +34,11 @@ use zbus::Connection;
use crate::{ use crate::{
config, fl, config, fl,
network_manager::{ network_manager::{
active_conns::active_conns_subscription, active_conns::active_conns_subscription, available_wifi::AccessPoint,
available_wifi::AccessPoint, current_networks::ActiveConnectionInfo, devices::devices_subscription,
current_networks::ActiveConnectionInfo, hw_address::HwAddress, network_manager_subscription,
devices::devices_subscription, wireless_enabled::wireless_enabled_subscription, NetworkManagerEvent,
hw_address::{self, HwAddress}, NetworkManagerRequest, NetworkManagerState,
network_manager_subscription,
wireless_enabled::wireless_enabled_subscription,
NetworkManagerEvent, NetworkManagerRequest, NetworkManagerState,
}, },
}; };
@ -391,7 +388,7 @@ impl cosmic::Application for CosmicNetworkApplet {
access_point, .. access_point, ..
}) = self.new_connection.clone() }) = self.new_connection.clone()
{ {
if success && ssid == &access_point.ssid && *hw_address == access_point.hw_address{ if success && ssid == &access_point.ssid && *hw_address == access_point.hw_address {
self.new_connection = None; self.new_connection = None;
self.show_visible_networks = false; self.show_visible_networks = false;
} }
@ -429,7 +426,7 @@ impl cosmic::Application for CosmicNetworkApplet {
let _ = tx.unbounded_send(NetworkManagerRequest::SelectAccessPoint( let _ = tx.unbounded_send(NetworkManagerRequest::SelectAccessPoint(
access_point.ssid.clone(), access_point.ssid.clone(),
access_point.hw_address.clone(), access_point.hw_address,
)); ));
self.new_connection = Some(NewConnectionState::EnterPassword { self.new_connection = Some(NewConnectionState::EnterPassword {
@ -505,7 +502,7 @@ impl cosmic::Application for CosmicNetworkApplet {
} else { } else {
return Task::none(); return Task::none();
}; };
let _ = tx.unbounded_send(NetworkManagerRequest::Disconnect(ssid)); let _ = tx.unbounded_send(NetworkManagerRequest::Disconnect(ssid, hw_address));
} }
Message::CloseRequested(id) => { Message::CloseRequested(id) => {
self.hw_device_to_show = None; self.hw_device_to_show = None;
@ -539,9 +536,7 @@ impl cosmic::Application for CosmicNetworkApplet {
tokio::spawn(cosmic::process::spawn(cmd)); tokio::spawn(cosmic::process::spawn(cmd));
} }
}, },
Message::OpenHwDevice(hw_address) => { Message::OpenHwDevice(hw_address) => self.hw_device_to_show = hw_address,
self.hw_device_to_show = hw_address;
}
Message::ResetFailedKnownSsid(ssid, hw_address) => { Message::ResetFailedKnownSsid(ssid, hw_address) => {
let ap = if let Some(pos) = self let ap = if let Some(pos) = self
.nm_state .nm_state
@ -569,7 +564,8 @@ impl cosmic::Application for CosmicNetworkApplet {
return Task::none(); return Task::none();
}; };
if let Some(tx) = self.nm_sender.as_ref() { if let Some(tx) = self.nm_sender.as_ref() {
let _ = tx.unbounded_send(NetworkManagerRequest::Forget(ssid.clone())); let _ =
tx.unbounded_send(NetworkManagerRequest::Forget(ssid.clone(), hw_address));
self.show_visible_networks = true; self.show_visible_networks = true;
return self.update(Message::SelectWirelessAccessPoint(ap)); return self.update(Message::SelectWirelessAccessPoint(ap));
} }
@ -731,7 +727,7 @@ impl cosmic::Application for CosmicNetworkApplet {
}; };
} }
let mut content = if let Some(hw_device_to_show) = self.hw_device_to_show.as_ref() { let mut content = if let Some(hw_device_to_show) = self.hw_device_to_show {
column![ column![
vpn_ethernet_col, vpn_ethernet_col,
menu_button(row![ menu_button(row![
@ -819,18 +815,31 @@ impl cosmic::Application for CosmicNetworkApplet {
for hw_device in wireless_hw_devices { for hw_device in wireless_hw_devices {
let display_name = hw_device.to_string(); let display_name = hw_device.to_string();
let btn_content = vec![ let is_connected = self
column![ .nm_state
text::body(display_name), .active_conns
Column::with_children(vec![text("Adapter").size(10).into()]) .iter()
] .any(|conn| conn.hw_address() == hw_device);
.width(Length::Fill) let mut btn_content = vec![column![
.into(), text::body(display_name),
Column::with_children(vec![text("Adapter").size(10).into()])
]
.width(Length::Fill)
.into()];
if is_connected {
btn_content.push(
text::body(fl!("connected"))
.width(Length::Fill)
.align_x(Alignment::End)
.into(),
);
}
btn_content.push(
icon::from_name("go-next-symbolic") icon::from_name("go-next-symbolic")
.size(16) .size(16)
.symbolic(true) .symbolic(true)
.into(), .into(),
]; );
content = content.push(Element::from( content = content.push(Element::from(
column![menu_button( column![menu_button(
Row::with_children(btn_content) Row::with_children(btn_content)
@ -846,8 +855,8 @@ impl cosmic::Application for CosmicNetworkApplet {
} }
for known in &self.nm_state.known_access_points { for known in &self.nm_state.known_access_points {
if let Some(filter_hw_address) = self.hw_device_to_show.as_ref() { if let Some(filter_hw_address) = self.hw_device_to_show {
if filter_hw_address != &known.hw_address { if filter_hw_address != known.hw_address {
continue; continue;
} }
} }
@ -909,7 +918,7 @@ impl cosmic::Application for CosmicNetworkApplet {
| DeviceState::Disconnected | DeviceState::Disconnected
| DeviceState::NeedAuth => btn.on_press(Message::ActivateKnownWifi( | DeviceState::NeedAuth => btn.on_press(Message::ActivateKnownWifi(
known.ssid.clone(), known.ssid.clone(),
known.hw_address.clone(), known.hw_address,
)), )),
DeviceState::Activated => { DeviceState::Activated => {
btn.on_press(Message::Disconnect(known.ssid.clone(), known.hw_address)) btn.on_press(Message::Disconnect(known.ssid.clone(), known.hw_address))
@ -941,7 +950,7 @@ impl cosmic::Application for CosmicNetworkApplet {
.on_press(Message::ToggleVisibleNetworks); .on_press(Message::ToggleVisibleNetworks);
content = content.push(available_connections_btn); content = content.push(available_connections_btn);
if self.show_visible_networks { if !self.show_visible_networks {
return self.view_window_return(content); return self.view_window_return(content);
} }
@ -1052,14 +1061,6 @@ impl cosmic::Application for CosmicNetworkApplet {
{ {
continue; continue;
} }
if self
.nm_state
.known_access_points
.iter()
.any(|a| ap.ssid == a.ssid && ap.hw_address == a.hw_address)
{
continue;
}
let button = menu_button( let button = menu_button(
row![ row![
icon::from_name(wifi_icon(ap.strength)) icon::from_name(wifi_icon(ap.strength))

50
cosmic-applet-network/src/network_manager/mod.rs
View file

@ -93,14 +93,26 @@ async fn start_listening(
}; };
match rx.next().await { match rx.next().await {
Some(NetworkManagerRequest::Disconnect(ssid)) => { Some(NetworkManagerRequest::Disconnect(ssid, hw_address)) => {
let mut success = false; let mut success = false;
for c in network_manager for c in network_manager
.active_connections() .active_connections()
.await .await
.unwrap_or_default() .unwrap_or_default()
{ {
if c.id().await.unwrap_or_default() == ssid if c.id().await.unwrap_or_default() != ssid {
continue;
}
let mut is_there_device = false;
for device in c.devices().await.unwrap_or_default() {
if HwAddress::from_string(device.hw_address().await.as_ref().unwrap())
== Some(hw_address)
{
is_there_device = true;
}
}
if is_there_device
&& network_manager.deactivate_connection(&c).await.is_ok() && network_manager.deactivate_connection(&c).await.is_ok()
{ {
success = true; success = true;
@ -126,7 +138,7 @@ async fn start_listening(
} }
_ = output _ = output
.send(NetworkManagerEvent::RequestResponse { .send(NetworkManagerEvent::RequestResponse {
req: NetworkManagerRequest::Disconnect(ssid.clone()), req: NetworkManagerRequest::Disconnect(ssid.clone(), hw_address),
success, success,
state: NetworkManagerState::new(&conn).await.unwrap_or_default(), state: NetworkManagerState::new(&conn).await.unwrap_or_default(),
}) })
@ -232,7 +244,7 @@ async fn start_listening(
}) })
.await; .await;
} }
Some(NetworkManagerRequest::Forget(ssid)) => { Some(NetworkManagerRequest::Forget(ssid, hw_address)) => {
let s = NetworkManagerSettings::new(&conn).await.unwrap(); let s = NetworkManagerSettings::new(&conn).await.unwrap();
let known_conns = s.list_connections().await.unwrap_or_default(); let known_conns = s.list_connections().await.unwrap_or_default();
let mut success = false; let mut success = false;
@ -245,6 +257,7 @@ async fn start_listening(
.and_then(|ssid| String::from_utf8(ssid).ok()) .and_then(|ssid| String::from_utf8(ssid).ok())
.is_some_and(|s| s == ssid) .is_some_and(|s| s == ssid)
{ {
// todo most likely we can here forget ssid from wrong hw_address
_ = c.delete().await; _ = c.delete().await;
success = true; success = true;
break; break;
@ -253,7 +266,7 @@ async fn start_listening(
let state = NetworkManagerState::new(&conn).await.unwrap_or_default(); let state = NetworkManagerState::new(&conn).await.unwrap_or_default();
_ = output _ = output
.send(NetworkManagerEvent::RequestResponse { .send(NetworkManagerEvent::RequestResponse {
req: NetworkManagerRequest::Forget(ssid.clone()), req: NetworkManagerRequest::Forget(ssid.clone(), hw_address),
success, success,
state, state,
}) })
@ -275,9 +288,9 @@ pub enum NetworkManagerRequest {
SetAirplaneMode(bool), SetAirplaneMode(bool),
SetWiFi(bool), SetWiFi(bool),
SelectAccessPoint(String, HwAddress), SelectAccessPoint(String, HwAddress),
Disconnect(String), Disconnect(String, HwAddress),
Password(String, String, HwAddress), Password(String, String, HwAddress),
Forget(String), Forget(String, HwAddress),
Reload, Reload,
} }
@ -426,7 +439,7 @@ impl NetworkManagerState {
if self if self
.wireless_access_points .wireless_access_points
.iter() .iter()
.any(|w| Ok(Some(w.ssid.clone())) == c.cached_id()) .any(|w| Ok(Some(w.ssid.clone())) == c.cached_id() && w.hw_address == hw_address)
{ {
_ = nm.deactivate_connection(&c).await; _ = nm.deactivate_connection(&c).await;
} }
@ -466,6 +479,18 @@ impl NetworkManagerState {
let devices = nm.devices().await?; let devices = nm.devices().await?;
for device in devices { for device in devices {
let device_hw_address = device.hw_address().await;
if device_hw_address.is_err() {
continue;
}
let device_hw_address = HwAddress::from_string(&device_hw_address.unwrap());
if device_hw_address.is_none() {
continue;
}
let device_hw_address = device_hw_address.unwrap();
if device_hw_address != hw_address {
continue;
}
if !matches!( if !matches!(
device.device_type().await.unwrap_or(DeviceType::Other), device.device_type().await.unwrap_or(DeviceType::Other),
DeviceType::Wifi DeviceType::Wifi
@ -480,19 +505,14 @@ impl NetworkManagerState {
let settings = c.get_settings().await.ok().unwrap_or_default(); let settings = c.get_settings().await.ok().unwrap_or_default();
let s = Settings::new(settings); let s = Settings::new(settings);
let cur_hw_address = s // todo try to add hw_address comparing here if it changes anything
.wifi
.as_ref()
.and_then(|w| w.assigned_mac_address.as_ref())
.and_then(|mac| HwAddress::from_string(&mac));
// s.wifi.clone().
if let Some(cur_ssid) = s if let Some(cur_ssid) = s
.wifi .wifi
.clone() .clone()
.and_then(|w| w.ssid) .and_then(|w| w.ssid)
.and_then(|ssid| String::from_utf8(ssid).ok()) .and_then(|ssid| String::from_utf8(ssid).ok())
{ {
if cur_ssid == ssid && hw_address == cur_hw_address.unwrap_or_default() { if cur_ssid == ssid {
known_conn = Some(c); known_conn = Some(c);
break; break;
} }