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

Added comparing hw_address everywhere

Browse source
This commit is contained in:
András 2024-12-04 22:33:41 +02:00 • committed by Michael Murphy
parent b743c724ff
commit 2198fa9b9a
5 changed files with 479 additions and 279 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -34,9 +34,13 @@ use zbus::Connection;
use crate::{ use crate::{
config, fl, config, fl,
network_manager::{ network_manager::{
active_conns::active_conns_subscription, available_wifi::AccessPoint, active_conns::active_conns_subscription,
current_networks::ActiveConnectionInfo, devices::devices_subscription, available_wifi::AccessPoint,
network_manager_subscription, wireless_enabled::wireless_enabled_subscription, current_networks::ActiveConnectionInfo,
devices::devices_subscription,
hw_address::{self, HwAddress},
network_manager_subscription,
wireless_enabled::wireless_enabled_subscription,
NetworkManagerEvent, NetworkManagerRequest, NetworkManagerState, NetworkManagerEvent, NetworkManagerRequest, NetworkManagerState,
}, },
}; };
@ -67,6 +71,17 @@ impl NewConnectionState {
} }
.ssid .ssid
} }
pub fn hw_address(&self) -> HwAddress {
match self {
Self::EnterPassword {
access_point,
password: _,
} => access_point,
Self::Waiting(ap) => ap,
Self::Failure(ap) => ap,
}
.hw_address
}
} }
impl From<NewConnectionState> for AccessPoint { impl From<NewConnectionState> for AccessPoint {
@ -100,6 +115,7 @@ struct CosmicNetworkApplet {
toggle_wifi_ctr: u128, toggle_wifi_ctr: u128,
token_tx: Option<calloop::channel::Sender<TokenRequest>>, token_tx: Option<calloop::channel::Sender<TokenRequest>>,
failed_known_ssids: HashSet<String>, failed_known_ssids: HashSet<String>,
hw_device_to_show: Option<HwAddress>,
} }
fn wifi_icon(strength: u8) -> &'static str { fn wifi_icon(strength: u8) -> &'static str {
@ -201,12 +217,28 @@ impl CosmicNetworkApplet {
timeline.start(); timeline.start();
} }
} }
fn view_window_return<'a>(&self, mut content: Column<'a, Message>) -> Element<'a, Message> {
let Spacing {
space_xxs, space_s, ..
} = theme::active().cosmic().spacing;
content = content
.push(padded_control(divider::horizontal::default()).padding([space_xxs, space_s]))
.push(menu_button(text::body(fl!("settings"))).on_press(Message::OpenSettings));
self.core
.applet
.popup_container(content.padding([8, 0, 8, 0]))
.max_width(400.)
.max_height(800.)
.into()
}
} }
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub(crate) enum Message { pub(crate) enum Message {
ActivateKnownWifi(String), ActivateKnownWifi(String, HwAddress),
Disconnect(String), Disconnect(String, HwAddress),
TogglePopup, TogglePopup,
CloseRequested(window::Id), CloseRequested(window::Id),
ToggleAirplaneMode(bool), ToggleAirplaneMode(bool),
@ -220,7 +252,8 @@ pub(crate) enum Message {
Frame(Instant), Frame(Instant),
Token(TokenUpdate), Token(TokenUpdate),
OpenSettings, OpenSettings,
ResetFailedKnownSsid(String), ResetFailedKnownSsid(String, HwAddress),
OpenHwDevice(Option<HwAddress>),
// Errored(String), // Errored(String),
} }
@ -316,15 +349,15 @@ impl cosmic::Application for CosmicNetworkApplet {
success, success,
req, req,
} => { } => {
if let NetworkManagerRequest::SelectAccessPoint(ssid) = &req { if let NetworkManagerRequest::SelectAccessPoint(ssid, hw_address) = &req {
let conn_match = self let conn_match = self
.new_connection .new_connection
.as_ref() .as_ref()
.map(|c| c.ssid() == ssid) .map(|c| c.ssid() == ssid && c.hw_address() == *hw_address)
.unwrap_or_default(); .unwrap_or_default();
if conn_match && success { if conn_match && success {
if let Some(s) = if let Some(s) =
state.active_conns.iter_mut().find(|ap| &ap.name() == ssid) state.active_conns.iter_mut().find(|ap| &ap.name() == ssid && ap.hw_address() == *hw_address)
{ {
match s { match s {
ActiveConnectionInfo::WiFi { state, .. } => { ActiveConnectionInfo::WiFi { state, .. } => {
@ -343,11 +376,11 @@ impl cosmic::Application for CosmicNetworkApplet {
{ {
self.failed_known_ssids.insert(ssid.clone()); self.failed_known_ssids.insert(ssid.clone());
} }
} else if let NetworkManagerRequest::Password(ssid, _) = &req { } else if let NetworkManagerRequest::Password(ssid, _, hw_address) = &req {
if let Some(NewConnectionState::Waiting(access_point)) = if let Some(NewConnectionState::Waiting(access_point)) =
self.new_connection.clone() self.new_connection.clone()
{ {
if !success && ssid == &access_point.ssid { if !success && ssid == &access_point.ssid && *hw_address == access_point.hw_address {
self.new_connection = self.new_connection =
Some(NewConnectionState::Failure(access_point.clone())); Some(NewConnectionState::Failure(access_point.clone()));
} else { } else {
@ -358,7 +391,7 @@ impl cosmic::Application for CosmicNetworkApplet {
access_point, .. access_point, ..
}) = self.new_connection.clone() }) = self.new_connection.clone()
{ {
if success && ssid == &access_point.ssid { 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;
} }
@ -396,6 +429,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(),
)); ));
self.new_connection = Some(NewConnectionState::EnterPassword { self.new_connection = Some(NewConnectionState::EnterPassword {
@ -430,18 +464,19 @@ impl cosmic::Application for CosmicNetworkApplet {
let _ = tx.unbounded_send(NetworkManagerRequest::Password( let _ = tx.unbounded_send(NetworkManagerRequest::Password(
access_point.ssid.clone(), access_point.ssid.clone(),
password, password,
access_point.hw_address,
)); ));
self.new_connection self.new_connection
.replace(NewConnectionState::Waiting(access_point)); .replace(NewConnectionState::Waiting(access_point));
}; };
} }
Message::ActivateKnownWifi(ssid) => { Message::ActivateKnownWifi(ssid, hw_address) => {
let tx = if let Some(tx) = self.nm_sender.as_ref() { let tx = if let Some(tx) = self.nm_sender.as_ref() {
if let Some(ap) = self if let Some(ap) = self
.nm_state .nm_state
.known_access_points .known_access_points
.iter_mut() .iter_mut()
.find(|c| c.ssid == ssid) .find(|c| c.ssid == ssid && c.hw_address == hw_address)
{ {
ap.working = true; ap.working = true;
} }
@ -449,19 +484,20 @@ impl cosmic::Application for CosmicNetworkApplet {
} else { } else {
return Task::none(); return Task::none();
}; };
let _ = tx.unbounded_send(NetworkManagerRequest::SelectAccessPoint(ssid)); let _ =
tx.unbounded_send(NetworkManagerRequest::SelectAccessPoint(ssid, hw_address));
} }
Message::CancelNewConnection => { Message::CancelNewConnection => {
self.new_connection = None; self.new_connection = None;
} }
Message::Disconnect(ssid) => { Message::Disconnect(ssid, hw_address) => {
self.new_connection = None; self.new_connection = None;
let tx = if let Some(tx) = self.nm_sender.as_ref() { let tx = if let Some(tx) = self.nm_sender.as_ref() {
if let Some(ActiveConnectionInfo::WiFi { state, .. }) = self if let Some(ActiveConnectionInfo::WiFi { state, .. }) = self
.nm_state .nm_state
.active_conns .active_conns
.iter_mut() .iter_mut()
.find(|c| c.name() == ssid) .find(|c| c.name() == ssid && c.hw_address() == hw_address)
{ {
*state = ActiveConnectionState::Deactivating; *state = ActiveConnectionState::Deactivating;
} }
@ -472,6 +508,7 @@ impl cosmic::Application for CosmicNetworkApplet {
let _ = tx.unbounded_send(NetworkManagerRequest::Disconnect(ssid)); let _ = tx.unbounded_send(NetworkManagerRequest::Disconnect(ssid));
} }
Message::CloseRequested(id) => { Message::CloseRequested(id) => {
self.hw_device_to_show = None;
if Some(id) == self.popup { if Some(id) == self.popup {
self.popup = None; self.popup = None;
} }
@ -502,24 +539,27 @@ impl cosmic::Application for CosmicNetworkApplet {
tokio::spawn(cosmic::process::spawn(cmd)); tokio::spawn(cosmic::process::spawn(cmd));
} }
}, },
Message::ResetFailedKnownSsid(ssid) => { Message::OpenHwDevice(hw_address) => {
self.hw_device_to_show = 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
.known_access_points .known_access_points
.iter() .iter()
.position(|ap| ap.ssid == ssid) .position(|ap| ap.ssid == ssid && ap.hw_address == hw_address)
{ {
self.nm_state.known_access_points.remove(pos) self.nm_state.known_access_points.remove(pos)
} else if let Some((pos, ap)) = self } else if let Some((pos, ap)) = self
.nm_state .nm_state
.active_conns .active_conns
.iter() .iter()
.position(|conn| conn.name() == ssid) .position(|conn| conn.name() == ssid && conn.hw_address() == hw_address)
.zip( .zip(
self.nm_state self.nm_state
.wireless_access_points .wireless_access_points
.iter() .iter()
.find(|ap| ap.ssid == ssid), .find(|ap| ap.ssid == ssid && ap.hw_address == hw_address),
) )
{ {
self.nm_state.active_conns.remove(pos); self.nm_state.active_conns.remove(pos);
@ -556,6 +596,9 @@ impl cosmic::Application for CosmicNetworkApplet {
for conn in &self.nm_state.active_conns { for conn in &self.nm_state.active_conns {
match conn { match conn {
ActiveConnectionInfo::Vpn { name, ip_addresses } => { ActiveConnectionInfo::Vpn { name, ip_addresses } => {
if self.hw_device_to_show.is_some() {
continue;
}
let mut ipv4 = Vec::with_capacity(ip_addresses.len() + 1); let mut ipv4 = Vec::with_capacity(ip_addresses.len() + 1);
ipv4.push(text::body(name).into()); ipv4.push(text::body(name).into());
for addr in ip_addresses { for addr in ip_addresses {
@ -583,10 +626,15 @@ impl cosmic::Application for CosmicNetworkApplet {
} }
ActiveConnectionInfo::Wired { ActiveConnectionInfo::Wired {
name, name,
hw_address: _, hw_address,
speed, speed,
ip_addresses, ip_addresses,
} => { } => {
if self.hw_device_to_show.is_some()
&& *hw_address != self.hw_device_to_show.unwrap()
{
continue;
}
let mut ipv4 = Vec::with_capacity(ip_addresses.len() + 1); let mut ipv4 = Vec::with_capacity(ip_addresses.len() + 1);
ipv4.push(text::body(name).into()); ipv4.push(text::body(name).into());
for addr in ip_addresses { for addr in ip_addresses {
@ -622,8 +670,13 @@ impl cosmic::Application for CosmicNetworkApplet {
ip_addresses, ip_addresses,
state, state,
strength, strength,
.. hw_address,
} => { } => {
if self.hw_device_to_show.is_some()
&& hw_address != self.hw_device_to_show.as_ref().unwrap()
{
continue;
}
let mut ipv4 = Vec::with_capacity(ip_addresses.len()); let mut ipv4 = Vec::with_capacity(ip_addresses.len());
for addr in ip_addresses { for addr in ip_addresses {
ipv4.push(text(format!("{}: {}", fl!("ipv4"), addr)).size(12).into()); ipv4.push(text(format!("{}: {}", fl!("ipv4"), addr)).size(12).into());
@ -660,7 +713,7 @@ impl cosmic::Application for CosmicNetworkApplet {
from_name("view-refresh-symbolic").size(16), from_name("view-refresh-symbolic").size(16),
) )
.icon_size(16) .icon_size(16)
.on_press(Message::ResetFailedKnownSsid(name.clone())) .on_press(Message::ResetFailedKnownSsid(name.clone(), *hw_address))
.into(), .into(),
) )
} }
@ -671,14 +724,35 @@ impl cosmic::Application for CosmicNetworkApplet {
.align_y(Alignment::Center) .align_y(Alignment::Center)
.spacing(8) .spacing(8)
) )
.on_press(Message::Disconnect(name.clone()))] .on_press(Message::Disconnect(name.clone(), *hw_address))]
.align_x(Alignment::Center), .align_x(Alignment::Center),
)); ));
} }
}; };
} }
let mut content = column![ let mut content = if let Some(hw_device_to_show) = self.hw_device_to_show.as_ref() {
column![
vpn_ethernet_col,
menu_button(row![
container(
icon::from_name("go-previous-symbolic")
.size(16)
.symbolic(true)
)
.align_x(Alignment::Start)
.align_y(Alignment::Center)
.width(Length::Fixed(24.0))
.height(Length::Fixed(24.0)),
text::body(hw_device_to_show.to_string())
.width(Length::Fill)
.height(Length::Fixed(24.0))
.align_y(Alignment::Center),
])
.on_press(Message::OpenHwDevice(None))
]
} else {
column![
vpn_ethernet_col, vpn_ethernet_col,
padded_control( padded_control(
anim!( anim!(
@ -706,7 +780,9 @@ impl cosmic::Application for CosmicNetworkApplet {
.width(Length::Fill) .width(Length::Fill)
), ),
] ]
.align_x(Alignment::Center); .align_x(Alignment::Center)
};
if self.nm_state.airplane_mode { if self.nm_state.airplane_mode {
content = content.push( content = content.push(
column!( column!(
@ -722,12 +798,59 @@ impl cosmic::Application for CosmicNetworkApplet {
.align_x(Alignment::Center) .align_x(Alignment::Center)
.width(Length::Fill), .width(Length::Fill),
); );
} else { return self.view_window_return(content);
if self.nm_state.wifi_enabled { }
content = content.push(
padded_control(divider::horizontal::default()).padding([space_xxs, space_s]), if !self.nm_state.wifi_enabled {
); return self.view_window_return(content);
}
content = content
.push(padded_control(divider::horizontal::default()).padding([space_xxs, space_s]));
let wireless_hw_devices = self
.nm_state
.wireless_access_points
.iter()
.map(|ap| ap.hw_address)
.collect::<std::collections::BTreeSet<_>>();
if wireless_hw_devices.len() > 1 && self.hw_device_to_show.is_none() {
for hw_device in wireless_hw_devices {
let display_name = hw_device.to_string();
let btn_content = vec![
column![
text::body(display_name),
Column::with_children(vec![text("Adapter").size(10).into()])
]
.width(Length::Fill)
.into(),
icon::from_name("go-next-symbolic")
.size(16)
.symbolic(true)
.into(),
];
content = content.push(Element::from(
column![menu_button(
Row::with_children(btn_content)
.align_y(Alignment::Center)
.spacing(8)
)
.on_press(Message::OpenHwDevice(Some(hw_device.clone())))]
.align_x(Alignment::Center),
));
}
return self.view_window_return(content);
}
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 filter_hw_address != &known.hw_address {
continue;
}
}
let mut btn_content = Vec::with_capacity(2); let mut btn_content = Vec::with_capacity(2);
let ssid = text::body(&known.ssid).width(Length::Fill); let ssid = text::body(&known.ssid).width(Length::Fill);
if known.working { if known.working {
@ -764,11 +887,12 @@ impl cosmic::Application for CosmicNetworkApplet {
if self.failed_known_ssids.contains(&known.ssid) { if self.failed_known_ssids.contains(&known.ssid) {
btn_content.push( btn_content.push(
cosmic::widget::button::icon( cosmic::widget::button::icon(from_name("view-refresh-symbolic").size(16))
from_name("view-refresh-symbolic").size(16),
)
.icon_size(16) .icon_size(16)
.on_press(Message::ResetFailedKnownSsid(known.ssid.clone())) .on_press(Message::ResetFailedKnownSsid(
known.ssid.clone(),
known.hw_address,
))
.into(), .into(),
) )
} }
@ -783,24 +907,22 @@ impl cosmic::Application for CosmicNetworkApplet {
| DeviceState::Unknown | DeviceState::Unknown
| DeviceState::Unmanaged | DeviceState::Unmanaged
| DeviceState::Disconnected | DeviceState::Disconnected
| DeviceState::NeedAuth => { | DeviceState::NeedAuth => btn.on_press(Message::ActivateKnownWifi(
btn.on_press(Message::ActivateKnownWifi(known.ssid.clone())) known.ssid.clone(),
} known.hw_address.clone(),
)),
DeviceState::Activated => { DeviceState::Activated => {
btn.on_press(Message::Disconnect(known.ssid.clone())) btn.on_press(Message::Disconnect(known.ssid.clone(), known.hw_address))
} }
_ => btn, _ => btn,
}; };
known_wifi.push(Element::from(row![btn].align_y(Alignment::Center))); known_wifi.push(Element::from(row![btn].align_y(Alignment::Center)));
} }
let has_known_wifi = !known_wifi.is_empty(); let has_known_wifi = !known_wifi.is_empty();
content = content.push(Column::with_children(known_wifi)); content = content.push(Column::with_children(known_wifi));
if has_known_wifi { if has_known_wifi {
content = content.push( content = content
padded_control(divider::horizontal::default()) .push(padded_control(divider::horizontal::default()).padding([space_xxs, space_s]));
.padding([space_xxs, space_s]),
);
} }
let dropdown_icon = if self.show_visible_networks { let dropdown_icon = if self.show_visible_networks {
@ -818,9 +940,11 @@ 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);
}
if let Some(new_conn_state) = self.new_connection.as_ref() { if let Some(new_conn_state) = self.new_connection.as_ref() {
match new_conn_state { match new_conn_state {
NewConnectionState::EnterPassword { NewConnectionState::EnterPassword {
@ -850,8 +974,7 @@ impl cosmic::Application for CosmicNetworkApplet {
row![ row![
button::standard(fl!("cancel")) button::standard(fl!("cancel"))
.on_press(Message::CancelNewConnection), .on_press(Message::CancelNewConnection),
button::suggested(fl!("connect")) button::suggested(fl!("connect")).on_press(Message::SubmitPassword)
.on_press(Message::SubmitPassword)
] ]
.spacing(24) .spacing(24)
] ]
@ -918,11 +1041,22 @@ impl cosmic::Application for CosmicNetworkApplet {
} else if self.nm_state.wifi_enabled { } else if self.nm_state.wifi_enabled {
let mut list_col = Vec::with_capacity(self.nm_state.wireless_access_points.len()); let mut list_col = Vec::with_capacity(self.nm_state.wireless_access_points.len());
for ap in &self.nm_state.wireless_access_points { for ap in &self.nm_state.wireless_access_points {
if ap.hw_address != self.hw_device_to_show.unwrap_or(ap.hw_address) {
continue;
}
if self if self
.nm_state .nm_state
.active_conns .active_conns
.iter() .iter()
.any(|a| ap.ssid == a.name()) .any(|a| ap.ssid == a.name() && ap.hw_address == a.hw_address())
{
continue;
}
if self
.nm_state
.known_access_points
.iter()
.any(|a| ap.ssid == a.ssid && ap.hw_address == a.hw_address)
{ {
continue; continue;
} }
@ -942,17 +1076,8 @@ impl cosmic::Application for CosmicNetworkApplet {
content = content content = content
.push(scrollable(Column::with_children(list_col)).height(Length::Fixed(300.0))); .push(scrollable(Column::with_children(list_col)).height(Length::Fixed(300.0)));
} }
}
content = content
.push(padded_control(divider::horizontal::default()).padding([space_xxs, space_s]))
.push(menu_button(text::body(fl!("settings"))).on_press(Message::OpenSettings));
self.core self.view_window_return(content)
.applet
.popup_container(content.padding([8, 0, 8, 0]))
.max_width(400.)
.max_height(800.)
.into()
} }
fn subscription(&self) -> Subscription<Message> { fn subscription(&self) -> Subscription<Message> {

9
cosmic-applet-network/src/network_manager/available_wifi.rs
View file

@ -7,6 +7,8 @@ use itertools::Itertools;
use std::collections::HashMap; use std::collections::HashMap;
use zbus::zvariant::ObjectPath; use zbus::zvariant::ObjectPath;
use super::hw_address::HwAddress;
pub async fn handle_wireless_device( pub async fn handle_wireless_device(
device: WirelessDevice<'_>, device: WirelessDevice<'_>,
hw_address: Option<String>, hw_address: Option<String>,
@ -45,7 +47,10 @@ pub async fn handle_wireless_device(
state, state,
working: false, working: false,
path: ap.inner().path().to_owned(), path: ap.inner().path().to_owned(),
hw_address: hw_address.as_ref().unwrap_or(&"".to_string()).clone(), hw_address: hw_address
.as_ref()
.and_then(|str_addr| HwAddress::from_str(str_addr))
.unwrap_or_default(),
}, },
); );
} }
@ -63,5 +68,5 @@ pub struct AccessPoint {
pub state: DeviceState, pub state: DeviceState,
pub working: bool, pub working: bool,
pub path: ObjectPath<'static>, pub path: ObjectPath<'static>,
pub hw_address: String, pub hw_address: HwAddress,
} }

21
cosmic-applet-network/src/network_manager/current_networks.rs
View file

@ -6,6 +6,8 @@ use cosmic_dbus_networkmanager::{
}; };
use std::net::Ipv4Addr; use std::net::Ipv4Addr;
use super::hw_address::HwAddress;
pub async fn active_connections( pub async fn active_connections(
active_connections: Vec<ActiveConnection<'_>>, active_connections: Vec<ActiveConnection<'_>>,
) -> zbus::Result<Vec<ActiveConnectionInfo>> { ) -> zbus::Result<Vec<ActiveConnectionInfo>> {
@ -40,7 +42,8 @@ pub async fn active_connections(
Some(SpecificDevice::Wired(wired_device)) => { Some(SpecificDevice::Wired(wired_device)) => {
info.push(ActiveConnectionInfo::Wired { info.push(ActiveConnectionInfo::Wired {
name: connection.id().await?, name: connection.id().await?,
hw_address: wired_device.hw_address().await?, hw_address: HwAddress::from_string(&wired_device.hw_address().await?)
.unwrap_or_default(),
speed: wired_device.speed().await?, speed: wired_device.speed().await?,
ip_addresses: addresses.clone(), ip_addresses: addresses.clone(),
}); });
@ -50,7 +53,10 @@ pub async fn active_connections(
info.push(ActiveConnectionInfo::WiFi { info.push(ActiveConnectionInfo::WiFi {
name: String::from_utf8_lossy(&access_point.ssid().await?).into_owned(), name: String::from_utf8_lossy(&access_point.ssid().await?).into_owned(),
ip_addresses: addresses.clone(), ip_addresses: addresses.clone(),
hw_address: wireless_device.hw_address().await?, hw_address: HwAddress::from_string(
&wireless_device.hw_address().await?,
)
.unwrap_or_default(),
state, state,
strength: access_point.strength().await.unwrap_or_default(), strength: access_point.strength().await.unwrap_or_default(),
}); });
@ -83,14 +89,14 @@ pub async fn active_connections(
pub enum ActiveConnectionInfo { pub enum ActiveConnectionInfo {
Wired { Wired {
name: String, name: String,
hw_address: String, hw_address: HwAddress,
speed: u32, speed: u32,
ip_addresses: Vec<Ipv4Addr>, ip_addresses: Vec<Ipv4Addr>,
}, },
WiFi { WiFi {
name: String, name: String,
ip_addresses: Vec<Ipv4Addr>, ip_addresses: Vec<Ipv4Addr>,
hw_address: String, hw_address: HwAddress,
state: ActiveConnectionState, state: ActiveConnectionState,
strength: u8, strength: u8,
}, },
@ -108,4 +114,11 @@ impl ActiveConnectionInfo {
Self::Vpn { name, .. } => name.clone(), Self::Vpn { name, .. } => name.clone(),
} }
} }
pub fn hw_address(&self) -> HwAddress {
match &self {
Self::Wired { hw_address, .. } => *hw_address,
Self::WiFi { hw_address, .. } => *hw_address,
Self::Vpn { .. } => HwAddress::default(),
}
}
} }

39
cosmic-applet-network/src/network_manager/hw_address.rs Normal file
View file

@ -0,0 +1,39 @@
#[derive(Copy, Clone, PartialEq, Eq, Default, Debug, PartialOrd, Ord)]
pub struct HwAddress {
address: u64,
}
impl HwAddress {
pub fn from_str(arg: &str) -> Option<Self> {
let columnless_vec = arg.split(":").collect::<Vec<&str>>();
if columnless_vec.len() * 3 - 1 != arg.len() {
return None;
}
for byte in &columnless_vec {
if byte.len() != 2 {
return None;
}
}
u64::from_str_radix(columnless_vec.join("").as_str(), 16)
.ok()
.and_then(|address| Some(HwAddress { address }))
}
pub fn from_string(arg: &String) -> Option<Self> {
HwAddress::from_str(arg.as_str())
}
pub fn to_string(&self) -> String {
// return if self.address > 100000000000000 {
// "Intel Corp".to_string()
// } else {
// "TP-Link".to_string()
// };
format!("{:#x}", self.address)
.trim_start_matches("0x")
.chars()
.collect::<Vec<_>>()
.chunks(2)
.map(|chunk| chunk.iter().cloned().collect::<String>())
.collect::<Vec<String>>()
.join(":")
}
}

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

@ -2,6 +2,7 @@ pub mod active_conns;
pub mod available_wifi; pub mod available_wifi;
pub mod current_networks; pub mod current_networks;
pub mod devices; pub mod devices;
pub mod hw_address;
pub mod wireless_enabled; pub mod wireless_enabled;
use std::{collections::HashMap, fmt::Debug, time::Duration}; use std::{collections::HashMap, fmt::Debug, time::Duration};
@ -24,6 +25,7 @@ use futures::{
channel::mpsc::{unbounded, UnboundedReceiver, UnboundedSender}, channel::mpsc::{unbounded, UnboundedReceiver, UnboundedSender},
SinkExt, StreamExt, SinkExt, StreamExt,
}; };
use hw_address::HwAddress;
use tokio::process::Command; use tokio::process::Command;
use zbus::{ use zbus::{
zvariant::{self, Value}, zvariant::{self, Value},
@ -172,15 +174,19 @@ async fn start_listening(
}; };
_ = output.send(response).await; _ = output.send(response).await;
} }
Some(NetworkManagerRequest::Password(ssid, password)) => { Some(NetworkManagerRequest::Password(ssid, password, hw_address)) => {
let nm_state = NetworkManagerState::new(&conn).await.unwrap_or_default(); let nm_state = NetworkManagerState::new(&conn).await.unwrap_or_default();
let success = nm_state let success = nm_state
.connect_wifi(&conn, &ssid, Some(&password)) .connect_wifi(&conn, &ssid, Some(&password), hw_address)
.await .await
.is_ok(); .is_ok();
let status = Some(NetworkManagerEvent::RequestResponse { let status = Some(NetworkManagerEvent::RequestResponse {
req: NetworkManagerRequest::Password(ssid.clone(), password.clone()), req: NetworkManagerRequest::Password(
ssid.clone(),
password.clone(),
hw_address,
),
success, success,
state: NetworkManagerState::new(&conn).await.unwrap_or_default(), state: NetworkManagerState::new(&conn).await.unwrap_or_default(),
}); });
@ -190,16 +196,18 @@ async fn start_listening(
} else { } else {
_ = output _ = output
.send(NetworkManagerEvent::RequestResponse { .send(NetworkManagerEvent::RequestResponse {
req: NetworkManagerRequest::Password(ssid, password), req: NetworkManagerRequest::Password(ssid, password, hw_address),
success: false, success: false,
state: NetworkManagerState::new(&conn).await.unwrap_or_default(), state: NetworkManagerState::new(&conn).await.unwrap_or_default(),
}) })
.await; .await;
} }
} }
Some(NetworkManagerRequest::SelectAccessPoint(ssid)) => { Some(NetworkManagerRequest::SelectAccessPoint(ssid, hw_address)) => {
let state = NetworkManagerState::new(&conn).await.unwrap_or_default(); let state = NetworkManagerState::new(&conn).await.unwrap_or_default();
let success = if let Err(err) = state.connect_wifi(&conn, &ssid, None).await { let success = if let Err(err) =
state.connect_wifi(&conn, &ssid, None, hw_address).await
{
tracing::error!("Failed to connect to access point: {:?}", err); tracing::error!("Failed to connect to access point: {:?}", err);
false false
} else { } else {
@ -208,7 +216,7 @@ async fn start_listening(
_ = output _ = output
.send(NetworkManagerEvent::RequestResponse { .send(NetworkManagerEvent::RequestResponse {
req: NetworkManagerRequest::SelectAccessPoint(ssid.clone()), req: NetworkManagerRequest::SelectAccessPoint(ssid.clone(), hw_address),
success, success,
state: NetworkManagerState::new(&conn).await.unwrap_or_default(), state: NetworkManagerState::new(&conn).await.unwrap_or_default(),
}) })
@ -266,9 +274,9 @@ async fn start_listening(
pub enum NetworkManagerRequest { pub enum NetworkManagerRequest {
SetAirplaneMode(bool), SetAirplaneMode(bool),
SetWiFi(bool), SetWiFi(bool),
SelectAccessPoint(String), SelectAccessPoint(String, HwAddress),
Disconnect(String), Disconnect(String),
Password(String, String), Password(String, String, HwAddress),
Forget(String), Forget(String),
Reload, Reload,
} }
@ -382,7 +390,10 @@ impl NetworkManagerState {
let known_access_points: Vec<_> = wireless_access_points let known_access_points: Vec<_> = wireless_access_points
.iter() .iter()
.filter(|a| { .filter(|a| {
known_ssid.contains(&a.ssid) && !active_conns.iter().any(|ac| ac.name() == a.ssid) known_ssid.contains(&a.ssid)
&& !active_conns
.iter()
.any(|ac| ac.name() == a.ssid && ac.hw_address() == a.hw_address)
}) })
.cloned() .cloned()
.collect(); .collect();
@ -407,6 +418,7 @@ impl NetworkManagerState {
conn: &Connection, conn: &Connection,
ssid: &str, ssid: &str,
password: Option<&str>, password: Option<&str>,
hw_address: HwAddress,
) -> anyhow::Result<()> { ) -> anyhow::Result<()> {
let nm = NetworkManager::new(conn).await?; let nm = NetworkManager::new(conn).await?;
@ -423,7 +435,7 @@ impl NetworkManagerState {
let Some(ap) = self let Some(ap) = self
.wireless_access_points .wireless_access_points
.iter() .iter()
.find(|ap| ap.ssid == ssid) .find(|ap| ap.ssid == ssid && ap.hw_address == hw_address)
else { else {
return Err(anyhow::anyhow!("Access point not found")); return Err(anyhow::anyhow!("Access point not found"));
}; };
@ -468,13 +480,19 @@ 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
.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 { if cur_ssid == ssid && hw_address == cur_hw_address.unwrap_or_default() {
known_conn = Some(c); known_conn = Some(c);
break; break;
} }