Start9/start-os
2
0
Fork 0
mirror of https://github.com/Start9Labs/start-os.git synced 2026-03-30 12:11:56 +00:00
Code Issues Packages Projects Releases Wiki Activity

feature: Swapping to use nmcli (#1015)

Browse Source 
The reason is that we get better errors and that we get signal strength.
Reworking all the commands to use nmcli instead.
Feat: Wifi List Available
Feat: strength sort for available
fix: Backend to match the frontend asking
feat: New get with all information
chore: Make backend changing country not for NonWire

Co-authored-by: Drew Ansbacher <drew.ansbacher@spiredigital.com>

Co-authored-by: Drew Ansbacher <drew.ansbacher@spiredigital.com>
This commit is contained in:
J M
2022-01-10 12:38:49 -07:00
committed by Aiden McClelland
parent 689b449d7a
commit 1086ce13d2
12 changed files with 795 additions and 412 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
appmgr/src/context/rpc.rs
View File

@@ -206,10 +206,7 @@ impl RpcContext {
notification_manager,
open_authed_websockets: Mutex::new(BTreeMap::new()),
rpc_stream_continuations: Mutex::new(BTreeMap::new()),
wifi_manager: Arc::new(RwLock::new(WpaCli::init(
"wlan0".to_string(),
base.datadir().join("main"),
))),
wifi_manager: Arc::new(RwLock::new(WpaCli::init("wlan0".to_string()))),
});
let metrics_seed = seed.clone();
tokio::spawn(async move {

4
appmgr/src/db/model.rs
View File

@@ -3,6 +3,7 @@ use std::sync::Arc;
use chrono::{DateTime, Utc};
use emver::VersionRange;
use isocountry::CountryCode;
use patch_db::json_ptr::JsonPointer;
use patch_db::{HasModel, Map, MapModel, OptionModel};
use reqwest::Url;
@@ -44,6 +45,7 @@ impl Database {
id,
version: Current::new().semver().into(),
last_backup: None,
last_wifi_region: None,
eos_version_compat: Current::new().compat().clone(),
lan_address: format!("https://{}.local", hostname).parse().unwrap(),
tor_address: format!("http://{}", tor_key.public().get_onion_address())
@@ -85,6 +87,8 @@ pub struct ServerInfo {
pub id: String,
pub version: Version,
pub last_backup: Option<DateTime<Utc>>,
/// Used in the wifi to determine the region to set the system to
pub last_wifi_region: Option<CountryCode>,
pub eos_version_compat: VersionRange,
pub lan_address: Url,
pub tor_address: Url,

22
appmgr/src/init.rs
View File

@@ -59,12 +59,26 @@ pub async fn init(cfg: &RpcContextConfig) -> Result<(), Error> {
crate::ssh::sync_keys_from_db(&secret_store, "/root/.ssh/authorized_keys").await?;
tracing::info!("Synced SSH Keys");
crate::net::wifi::synchronize_wpa_supplicant_conf(&cfg.datadir().join("main")).await?;
tracing::info!("Synchronized wpa_supplicant.conf");
let db = cfg.db(&secret_store).await?;
let mut handle = db.handle();
crate::net::wifi::synchronize_wpa_supplicant_conf(
&cfg.datadir().join("main"),
&*crate::db::DatabaseModel::new()
.server_info()
.last_wifi_region()
.get(&mut handle, false)
.await
.map_err(|_e| {
Error::new(
color_eyre::eyre::eyre!("Could not find the last wifi region"),
crate::ErrorKind::NotFound,
)
})?,
)
.await?;
tracing::info!("Synchronized wpa_supplicant.conf");
let mut info = crate::db::DatabaseModel::new()
.server_info()
.get_mut(&mut handle)

726
appmgr/src/net/wifi.rs
View File

@@ -1,10 +1,13 @@
use std::collections::BTreeMap;
use std::path::{Path, PathBuf};
use std::collections::{BTreeMap, HashMap};
use std::path::Path;
use std::sync::Arc;
use std::time::Duration;
use clap::ArgMatches;
use isocountry::CountryCode;
use lazy_static::lazy_static;
use patch_db::DbHandle;
use regex::Regex;
use rpc_toolkit::command;
use tokio::process::Command;
use tokio::sync::RwLock;
@@ -15,13 +18,23 @@ use crate::util::serde::{display_serializable, IoFormat};
use crate::util::{display_none, Invoke};
use crate::{Error, ErrorKind};
#[command(subcommands(add, connect, delete, get, set_country))]
#[command(subcommands(add, connect, delete, get, country, available))]
pub async fn wifi() -> Result<(), Error> {
Ok(())
}
#[command(subcommands(get_available))]
pub async fn available() -> Result<(), Error> {
Ok(())
}
#[command(subcommands(set_country))]
pub async fn country() -> Result<(), Error> {
Ok(())
}
#[command(display(display_none))]
#[instrument(skip(ctx))]
#[instrument(skip(ctx, password))]
pub async fn add(
#[context] ctx: RpcContext,
#[arg] ssid: String,
@@ -42,48 +55,32 @@ pub async fn add(
));
}
async fn add_procedure(
db: impl DbHandle,
wifi_manager: Arc<RwLock<WpaCli>>,
ssid: &str,
password: &str,
ssid: &Ssid,
password: &Psk,
priority: isize,
connect: bool,
) -> Result<(), Error> {
tracing::info!("Adding new WiFi network: '{}'", ssid);
tracing::info!("Adding new WiFi network: '{}'", ssid.0);
let mut wpa_supplicant = wifi_manager.write().await;
wpa_supplicant.add_network(ssid, password, priority).await?;
wpa_supplicant
.add_network(db, ssid, password, priority)
.await?;
drop(wpa_supplicant);
if connect {
let wpa_supplicant = wifi_manager.read().await;
let current = wpa_supplicant.get_current_network().await?;
drop(wpa_supplicant);
let mut wpa_supplicant = wifi_manager.write().await;
let connected = wpa_supplicant.select_network(ssid).await?;
if !connected {
tracing::info!("Failed to add new WiFi network: '{}'", ssid);
wpa_supplicant.remove_network(ssid).await?;
match current {
None => {}
Some(current) => {
wpa_supplicant.select_network(&current).await?;
}
}
}
}
Ok(())
}
tokio::spawn(async move {
match add_procedure(
&mut ctx.db.handle(),
ctx.wifi_manager.clone(),
&ssid,
&password,
&Ssid(ssid.clone()),
&Psk(password.clone()),
priority,
connect,
)
.await
{
Err(e) => {
tracing::info!("Failed to add new WiFi network '{}': {}", ssid, e);
tracing::debug!("{:?}", e);
}
Ok(_) => {}
}
@@ -101,31 +98,38 @@ pub async fn connect(#[context] ctx: RpcContext, #[arg] ssid: String) -> Result<
));
}
async fn connect_procedure(
mut db: impl DbHandle,
wifi_manager: Arc<RwLock<WpaCli>>,
ssid: &String,
ssid: &Ssid,
) -> Result<(), Error> {
let wpa_supplicant = wifi_manager.read().await;
let current = wpa_supplicant.get_current_network().await?;
drop(wpa_supplicant);
let mut wpa_supplicant = wifi_manager.write().await;
let connected = wpa_supplicant.select_network(&ssid).await?;
let connected = wpa_supplicant.select_network(&mut db, &ssid).await?;
if connected {
tracing::info!("Successfully connected to WiFi: '{}'", ssid);
tracing::info!("Successfully connected to WiFi: '{}'", ssid.0);
} else {
tracing::info!("Failed to connect to WiFi: '{}'", ssid);
tracing::info!("Failed to connect to WiFi: '{}'", ssid.0);
match current {
None => {
tracing::info!("No WiFi to revert to!");
}
Some(current) => {
wpa_supplicant.select_network(&current).await?;
wpa_supplicant.select_network(&mut db, &current).await?;
}
}
}
Ok(())
}
tokio::spawn(async move {
match connect_procedure(ctx.wifi_manager.clone(), &ssid).await {
match connect_procedure(
&mut ctx.db.handle(),
ctx.wifi_manager.clone(),
&Ssid(ssid.clone()),
)
.await
{
Err(e) => {
tracing::info!("Failed to connect to WiFi network '{}': {}", &ssid, e);
}
@@ -148,31 +152,42 @@ pub async fn delete(#[context] ctx: RpcContext, #[arg] ssid: String) -> Result<(
let current = wpa_supplicant.get_current_network().await?;
drop(wpa_supplicant);
let mut wpa_supplicant = ctx.wifi_manager.write().await;
match current {
None => {
wpa_supplicant.remove_network(&ssid).await?;
}
Some(current) => {
if current == ssid {
if interface_connected("eth0").await? {
wpa_supplicant.remove_network(&ssid).await?;
} else {
return Err(Error::new(color_eyre::eyre::eyre!("Forbidden: Deleting this Network would make your Embassy Unreachable. Either connect to ethernet or connect to a different WiFi network to remedy this."), ErrorKind::Wifi));
}
}
}
let ssid = Ssid(ssid);
let is_current_being_removed = matches!(current, Some(current) if current == ssid);
let is_current_removed_and_no_hardwire =
is_current_being_removed && !interface_connected("eth0").await?;
if is_current_removed_and_no_hardwire {
return Err(Error::new(color_eyre::eyre::eyre!("Forbidden: Deleting this Network would make your Embassy Unreachable. Either connect to ethernet or connect to a different WiFi network to remedy this."), ErrorKind::Wifi));
}
wpa_supplicant
.remove_network(&mut ctx.db.handle(), &ssid)
.await?;
Ok(())
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "kebab-case")]
pub struct WiFiInfo {
ssids: Vec<String>,
connected: Option<String>,
ssids: HashMap<Ssid, SignalStrength>,
connected: Option<Ssid>,
country: CountryCode,
ethernet: bool,
signal_strength: Option<usize>,
available_wifi: Vec<WifiListOut>,
}
#[derive(serde::Serialize, serde::Deserialize, Clone)]
#[serde(rename_all = "kebab-case")]
pub struct WifiListInfo {
strength: SignalStrength,
security: Vec<String>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "kebab-case")]
pub struct WifiListOut {
ssid: Ssid,
strength: SignalStrength,
security: Vec<String>,
}
pub type WifiList = HashMap<Ssid, WifiListInfo>;
fn display_wifi_info(info: WiFiInfo, matches: &ArgMatches<'_>) {
use prettytable::*;
@@ -191,34 +206,74 @@ fn display_wifi_info(info: WiFiInfo, matches: &ArgMatches<'_>) {
&info
.connected
.as_ref()
.map_or("[N/A]".to_owned(), |c| format!("{}", c)),
.map_or("[N/A]".to_owned(), |c| format!("{}", c.0)),
&info
.signal_strength
.connected
.as_ref()
.map_or("[N/A]".to_owned(), |ss| format!("{}", ss)),
.and_then(|x| info.ssids.get(x))
.map_or("[N/A]".to_owned(), |ss| format!("{}", ss.0)),
&format!("{}", info.country.alpha2()),
&format!("{}", info.ethernet)
]);
table_global.print_tty(false);
let mut table_ssids = Table::new();
table_ssids.add_row(row![bc => "SSID",]);
for ssid in &info.ssids {
let mut row = row![ssid];
if Some(ssid) == info.connected.as_ref() {
row.iter_mut()
.map(|c| {
c.style(Attr::ForegroundColor(match &info.signal_strength {
Some(100) => color::GREEN,
Some(0) => color::RED,
_ => color::YELLOW,
}))
})
.collect::<()>()
}
table_ssids.add_row(row![bc => "SSID", "STRENGTH"]);
for (ssid, signal_strength) in &info.ssids {
let mut row = row![&ssid.0, format!("{}", signal_strength.0)];
row.iter_mut()
.map(|c| {
c.style(Attr::ForegroundColor(match &signal_strength.0 {
x if x >= &90 => color::GREEN,
x if x == &50 => color::MAGENTA,
x if x == &0 => color::RED,
_ => color::YELLOW,
}))
})
.for_each(drop);
table_ssids.add_row(row);
}
table_ssids.print_tty(false);
let mut table_global = Table::new();
table_global.add_row(row![bc =>
"SSID",
"STRENGTH",
"SECURITY",
]);
for table_info in info.available_wifi {
table_global.add_row(row![
&table_info.ssid.0,
&format!("{}", table_info.strength.0),
&format!("{}", table_info.security.join(" "))
]);
}
table_global.print_tty(false);
}
fn display_wifi_list(info: Vec<WifiListOut>, matches: &ArgMatches<'_>) {
use prettytable::*;
if matches.is_present("format") {
return display_serializable(info, matches);
}
let mut table_global = Table::new();
table_global.add_row(row![bc =>
"SSID",
"STRENGTH",
"SECURITY",
]);
for table_info in info {
table_global.add_row(row![
&table_info.ssid.0,
&format!("{}", table_info.strength.0),
&format!("{}", table_info.security.join(" "))
]);
}
table_global.print_tty(false);
}
#[command(display(display_wifi_info))]
@@ -230,261 +285,327 @@ pub async fn get(
format: Option<IoFormat>,
) -> Result<WiFiInfo, Error> {
let wpa_supplicant = ctx.wifi_manager.read().await;
let ssids_task = async {
Result::<Vec<String>, Error>::Ok(
wpa_supplicant
.list_networks_low()
.await?
.into_keys()
.collect::<Vec<String>>(),
)
};
let current_task = wpa_supplicant.get_current_network();
let country_task = wpa_supplicant.get_country_low();
let ethernet_task = interface_connected("eth0"); // TODO: pull from config
let rssi_task = wpa_supplicant.signal_poll_low();
let (ssids_res, current_res, country_res, ethernet_res, rssi_res) = tokio::join!(
ssids_task,
current_task,
country_task,
ethernet_task,
rssi_task
let (list_networks, current_res, country_res, ethernet_res, signal_strengths) = tokio::join!(
wpa_supplicant.list_networks_low(),
wpa_supplicant.get_current_network(),
wpa_supplicant.get_country_low(),
interface_connected("eth0"), // TODO: pull from config
wpa_supplicant.list_wifi_low()
);
let current = current_res?;
let signal_strength = match rssi_res? {
None => None,
Some(x) if x <= -100 => Some(0 as usize),
Some(x) if x >= -50 => Some(100 as usize),
Some(x) => Some(2 * (x + 100) as usize),
let signal_strengths = signal_strengths?;
let list_networks = list_networks?;
let available_wifi = {
let mut wifi_list: Vec<WifiListOut> = signal_strengths
.clone()
.into_iter()
.filter(|(ssid, _)| !list_networks.contains_key(ssid))
.map(|(ssid, info)| WifiListOut {
ssid,
strength: info.strength,
security: info.security,
})
.collect();
wifi_list.sort_by_key(|x| x.strength);
wifi_list.reverse();
wifi_list
};
let ssids: HashMap<Ssid, SignalStrength> = list_networks
.into_keys()
.map(|x| {
let signal_strength = signal_strengths
.get(&x)
.map(|x| x.strength)
.unwrap_or_default();
(x, signal_strength)
})
.collect();
let current = current_res?;
Ok(WiFiInfo {
ssids: ssids_res?,
connected: current,
ssids,
connected: current.map(|x| x),
country: country_res?,
ethernet: ethernet_res?,
signal_strength,
available_wifi,
})
}
#[command(display(display_none))]
#[command(rename = "get", display(display_wifi_list))]
#[instrument(skip(ctx))]
pub async fn get_available(
#[context] ctx: RpcContext,
#[allow(unused_variables)]
#[arg(long = "format")]
format: Option<IoFormat>,
) -> Result<Vec<WifiListOut>, Error> {
let wpa_supplicant = ctx.wifi_manager.read().await;
let (wifi_list, network_list) = tokio::join!(
wpa_supplicant.list_wifi_low(),
wpa_supplicant.list_networks_low()
);
let network_list = network_list?;
let mut wifi_list: Vec<WifiListOut> = wifi_list?
.into_iter()
.filter(|(ssid, _)| !network_list.contains_key(ssid))
.map(|(ssid, info)| WifiListOut {
ssid,
strength: info.strength,
security: info.security,
})
.collect();
wifi_list.sort_by_key(|x| x.strength);
wifi_list.reverse();
Ok(wifi_list)
}
#[command(rename = "set", display(display_none))]
pub async fn set_country(
#[context] ctx: RpcContext,
#[arg(parse(country_code_parse))] country: CountryCode,
) -> Result<(), Error> {
if !interface_connected("eth0").await? {
return Err(Error::new(
color_eyre::eyre::eyre!("Won't change country without hardwire connection"),
crate::ErrorKind::Wifi,
));
}
let mut wpa_supplicant = ctx.wifi_manager.write().await;
wpa_supplicant.set_country_low(country.alpha2()).await
wpa_supplicant.set_country_low(country.alpha2()).await?;
for (_ssid, network_id) in wpa_supplicant.list_networks_low().await? {
wpa_supplicant.remove_network_low(network_id).await?;
}
wpa_supplicant.remove_all_connections().await?;
wpa_supplicant.save_config(&mut ctx.db.handle()).await?;
Ok(())
}
#[derive(Debug)]
pub struct WpaCli {
datadir: PathBuf,
interface: String,
}
#[derive(Clone)]
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
pub struct NetworkId(String);
pub enum NetworkAttr {
Ssid(String),
Psk(String),
Priority(isize),
ScanSsid(bool),
}
impl NetworkAttr {
fn name(&self) -> &'static str {
use NetworkAttr::*;
match self {
Ssid(_) => "ssid",
Psk(_) => "psk",
Priority(_) => "priority",
ScanSsid(_) => "scan_ssid",
}
}
fn value(&self) -> String {
use NetworkAttr::*;
match self {
Ssid(s) => format!("\"{}\"", s),
Psk(s) => format!("\"{}\"", s),
Priority(n) => format!("{}", n),
ScanSsid(b) => {
if *b {
String::from("1")
} else {
String::from("0")
}
}
/// Ssid are the names of the wifis, usually human readable.
#[derive(
Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, serde::Serialize, serde::Deserialize,
)]
pub struct Ssid(String);
/// So a signal strength is a number between 0-100, I want the null option to be 0 since there is no signal
#[derive(
Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, serde::Serialize, serde::Deserialize,
)]
pub struct SignalStrength(u8);
impl SignalStrength {
fn new(size: Option<u8>) -> Self {
let size = match size {
None => return Self(0),
Some(x) => x,
};
if size >= 100 {
return Self(100);
}
Self(size)
}
}
impl Default for SignalStrength {
fn default() -> Self {
Self(0)
}
}
#[derive(Clone, Debug)]
pub struct Psk(String);
impl WpaCli {
pub fn init(interface: String, datadir: PathBuf) -> Self {
WpaCli { interface, datadir }
pub fn init(interface: String) -> Self {
WpaCli { interface }
}
// Low Level
pub async fn add_network_low(&mut self) -> Result<NetworkId, Error> {
let r = Command::new("wpa_cli")
.arg("-i")
.arg(&self.interface)
.arg("add_network")
#[instrument(skip(self, psk))]
pub async fn set_add_network_low(&mut self, ssid: &Ssid, psk: &Psk) -> Result<(), Error> {
let _ = Command::new("nmcli")
.arg("-a")
.arg("-w")
.arg("30")
.arg("d")
.arg("wifi")
.arg("con")
.arg(&ssid.0)
.arg("password")
.arg(&psk.0)
.invoke(ErrorKind::Wifi)
.await?;
let s = std::str::from_utf8(&r)?;
Ok(NetworkId(s.trim().to_owned()))
Ok(())
}
pub async fn set_network_low(
&mut self,
id: &NetworkId,
attr: &NetworkAttr,
) -> Result<(), Error> {
let _ = Command::new("wpa_cli")
.arg("-i")
#[instrument(skip(self, psk))]
pub async fn add_network_low(&mut self, ssid: &Ssid, psk: &Psk) -> Result<(), Error> {
let _ = Command::new("nmcli")
.arg("con")
.arg("add")
.arg("con-name")
.arg(&ssid.0)
.arg("ifname")
.arg(&self.interface)
.arg("set_network")
.arg(&id.0)
.arg(attr.name())
.arg(attr.value())
.arg("type")
.arg("wifi")
.arg("ssid")
.arg(&ssid.0)
.invoke(ErrorKind::Wifi)
.await?;
let _ = Command::new("nmcli")
.arg("con")
.arg("modify")
.arg(&ssid.0)
.arg("wifi-sec.key-mgmt")
.arg("wpa-psk")
.invoke(ErrorKind::Wifi)
.await?;
let _ = Command::new("nmcli")
.arg("con")
.arg("modify")
.arg(&ssid.0)
.arg("wifi-sec.psk")
.arg(&psk.0)
.invoke(ErrorKind::Wifi)
.await?;
Ok(())
}
pub async fn set_country_low(&mut self, country_code: &str) -> Result<(), Error> {
let _ = Command::new("wpa_cli")
.arg("-i")
.arg(&self.interface)
let _ = Command::new("iw")
.arg("reg")
.arg("set")
.arg("country")
.arg(country_code)
.invoke(ErrorKind::Wifi)
.await?;
Ok(())
}
pub async fn get_country_low(&self) -> Result<CountryCode, Error> {
let r = Command::new("wpa_cli")
.arg("-i")
.arg(&self.interface)
let r = Command::new("iw")
.arg("reg")
.arg("get")
.arg("country")
.invoke(ErrorKind::Wifi)
.await?;
Ok(CountryCode::for_alpha2(&String::from_utf8(r)?).unwrap())
}
pub async fn enable_network_low(&mut self, id: &NetworkId) -> Result<(), Error> {
let _ = Command::new("wpa_cli")
.arg("-i")
.arg(&self.interface)
.arg("enable_network")
.arg(&id.0)
.invoke(ErrorKind::Wifi)
.await?;
Ok(())
}
pub async fn save_config_low(&mut self) -> Result<(), Error> {
let _ = Command::new("wpa_cli")
.arg("-i")
.arg(&self.interface)
.arg("save_config")
.invoke(ErrorKind::Wifi)
.await?;
Ok(())
let r = String::from_utf8(r)?;
lazy_static! {
static ref RE: Regex = Regex::new("country (\\w+):").unwrap();
}
let first_country = r
.lines()
.filter(|s| s.contains("country"))
.next()
.ok_or_else(|| {
Error::new(
color_eyre::eyre::eyre!("Could not find a country config lines"),
ErrorKind::Wifi,
)
})?;
let country = &RE.captures(first_country).ok_or_else(|| {
Error::new(
color_eyre::eyre::eyre!("Could not find a country config with regex"),
ErrorKind::Wifi,
)
})?[1];
Ok(CountryCode::for_alpha2(country).or(Err(Error::new(
color_eyre::eyre::eyre!("Invalid Country Code: {}", country),
ErrorKind::Wifi,
)))?)
}
pub async fn remove_network_low(&mut self, id: NetworkId) -> Result<(), Error> {
let _ = Command::new("wpa_cli")
.arg("-i")
.arg(&self.interface)
.arg("remove_network")
let _ = Command::new("nmcli")
.arg("c")
.arg("del")
.arg(&id.0)
.invoke(ErrorKind::Wifi)
.await?;
Ok(())
}
pub async fn reconfigure_low(&mut self) -> Result<(), Error> {
let _ = Command::new("wpa_cli")
.arg("-i")
.arg(&self.interface)
.arg("reconfigure")
.invoke(ErrorKind::Wifi)
.await?;
Ok(())
}
#[instrument]
pub async fn list_networks_low(&self) -> Result<BTreeMap<String, NetworkId>, Error> {
let r = Command::new("wpa_cli")
.arg("-i")
.arg(&self.interface)
.arg("list_networks")
pub async fn list_networks_low(&self) -> Result<BTreeMap<Ssid, NetworkId>, Error> {
let r = Command::new("nmcli")
.arg("-t")
.arg("c")
.arg("show")
.invoke(ErrorKind::Wifi)
.await?;
Ok(String::from_utf8(r)?
.lines()
.skip(1)
.filter_map(|l| {
let mut cs = l.split("\t");
let nid = NetworkId(cs.next()?.to_owned());
let ssid = cs.next()?.to_owned();
Some((ssid, nid))
let mut cs = l.split(":");
let name = Ssid(cs.next()?.to_owned());
let uuid = NetworkId(cs.next()?.to_owned());
let _connection_type = cs.next()?;
let _device = cs.next()?;
Some((name, uuid))
})
.collect::<BTreeMap<String, NetworkId>>())
}
pub async fn select_network_low(&mut self, id: &NetworkId) -> Result<(), Error> {
let _ = Command::new("wpa_cli")
.arg("-i")
.arg(&self.interface)
.arg("select_network")
.arg(&id.0)
.invoke(ErrorKind::Wifi)
.await?;
Ok(())
}
pub async fn new_password_low(&mut self, id: &NetworkId, pass: &str) -> Result<(), Error> {
let _ = Command::new("wpa_cli")
.arg("-i")
.arg(&self.interface)
.arg("new_password")
.arg(&id.0)
.arg(pass)
.invoke(ErrorKind::Wifi)
.await?;
Ok(())
}
#[instrument]
pub async fn signal_poll_low(&self) -> Result<Option<isize>, Error> {
let r = Command::new("wpa_cli")
.arg("-i")
.arg(&self.interface)
.arg("signal_poll")
.invoke(ErrorKind::Wifi)
.await?;
let e = || {
Error::new(
color_eyre::eyre::eyre!("Invalid output from wpa_cli signal_poll"),
ErrorKind::Wifi,
)
};
let output = String::from_utf8(r)?;
Ok(if output.trim() == "FAIL" {
None
} else {
let l = output.lines().next().ok_or_else(e)?;
let rssi = l.split("=").nth(1).ok_or_else(e)?.parse()?;
Some(rssi)
})
.collect::<BTreeMap<Ssid, NetworkId>>())
}
// High Level
pub async fn save_config(&mut self) -> Result<(), Error> {
self.save_config_low().await?;
tokio::fs::copy(
"/etc/wpa_supplicant.conf",
self.datadir.join("wpa_supplicant.conf"),
)
.await?;
#[instrument]
pub async fn list_wifi_low(&self) -> Result<WifiList, Error> {
let r = Command::new("nmcli")
.arg("-g")
.arg("SSID,SIGNAL,security")
.arg("d")
.arg("wifi")
.arg("list")
.invoke(ErrorKind::Wifi)
.await?;
Ok(String::from_utf8(r)?
.lines()
.filter_map(|l| {
let mut values = l.split(":");
let ssid = Ssid(values.next()?.to_owned());
let signal = SignalStrength::new(std::str::FromStr::from_str(values.next()?).ok());
let security: Vec<String> =
values.next()?.split(" ").map(|x| x.to_owned()).collect();
Some((
ssid,
WifiListInfo {
strength: signal,
security,
},
))
})
.collect::<WifiList>())
}
pub async fn select_network_low(&mut self, id: &NetworkId) -> Result<(), Error> {
let _ = Command::new("nmcli")
.arg("c")
.arg("up")
.arg(&id.0)
.invoke(ErrorKind::Wifi)
.await?;
Ok(())
}
pub async fn check_network(&self, ssid: &str) -> Result<Option<NetworkId>, Error> {
pub async fn remove_all_connections(&mut self) -> Result<(), Error> {
let location_connections = Path::new("/etc/NetworkManager/system-connections");
let mut connections = tokio::fs::read_dir(&location_connections).await?;
while let Some(connection) = connections.next_entry().await? {
let path = connection.path();
if path.is_file() {
let _ = tokio::fs::remove_file(&path).await?;
}
}
Ok(())
}
pub async fn save_config(&mut self, mut db: impl DbHandle) -> Result<(), Error> {
crate::db::DatabaseModel::new()
.server_info()
.last_wifi_region()
.put(&mut db, &Some(self.get_country_low().await?))
.await?;
Ok(())
}
pub async fn check_network(&self, ssid: &Ssid) -> Result<Option<NetworkId>, Error> {
Ok(self.list_networks_low().await?.remove(ssid))
}
#[instrument]
pub async fn select_network(&mut self, ssid: &str) -> Result<bool, Error> {
#[instrument(skip(db))]
pub async fn select_network(&mut self, db: impl DbHandle, ssid: &Ssid) -> Result<bool, Error> {
let m_id = self.check_network(ssid).await?;
match m_id {
None => Err(Error::new(
@@ -493,14 +614,14 @@ impl WpaCli {
)),
Some(x) => {
self.select_network_low(&x).await?;
self.save_config().await?;
self.save_config(db).await?;
let connect = async {
let mut current;
loop {
current = self.get_current_network().await;
match &current {
Ok(Some(ssid)) => {
tracing::debug!("Connected to: {}", ssid);
tracing::debug!("Connected to: {}", ssid.0);
break;
}
_ => {}
@@ -517,13 +638,13 @@ impl WpaCli {
tracing::debug!("{:?}", res);
Ok(match res {
None => false,
Some(net) => net == ssid,
Some(net) => &net == ssid,
})
}
}
}
#[instrument]
pub async fn get_current_network(&self) -> Result<Option<String>, Error> {
pub async fn get_current_network(&self) -> Result<Option<Ssid>, Error> {
let r = Command::new("iwgetid")
.arg(&self.interface)
.arg("--raw")
@@ -535,45 +656,42 @@ impl WpaCli {
if network.is_empty() {
Ok(None)
} else {
Ok(Some(network.to_owned()))
Ok(Some(Ssid(network.to_owned())))
}
}
#[instrument]
pub async fn remove_network(&mut self, ssid: &str) -> Result<bool, Error> {
#[instrument(skip(db))]
pub async fn remove_network(&mut self, db: impl DbHandle, ssid: &Ssid) -> Result<bool, Error> {
match self.check_network(ssid).await? {
None => Ok(false),
Some(x) => {
self.remove_network_low(x).await?;
self.save_config().await?;
self.reconfigure_low().await?;
self.save_config(db).await?;
Ok(true)
}
}
}
#[instrument]
pub async fn add_network(
#[instrument(skip(psk, db))]
pub async fn set_add_network(
&mut self,
ssid: &str,
psk: &str,
db: impl DbHandle,
ssid: &Ssid,
psk: &Psk,
priority: isize,
) -> Result<(), Error> {
use NetworkAttr::*;
let nid = match self.check_network(ssid).await? {
None => {
let nid = self.add_network_low().await?;
self.set_network_low(&nid, &Ssid(ssid.to_owned())).await?;
self.set_network_low(&nid, &Psk(psk.to_owned())).await?;
self.set_network_low(&nid, &Priority(priority)).await?;
self.set_network_low(&nid, &ScanSsid(true)).await?;
Result::<NetworkId, Error>::Ok(nid)
}
Some(nid) => {
self.new_password_low(&nid, psk).await?;
Ok(nid)
}
}?;
self.enable_network_low(&nid).await?;
self.save_config().await?;
self.set_add_network_low(&ssid, &psk).await?;
self.save_config(db).await?;
Ok(())
}
#[instrument(skip(psk, db))]
pub async fn add_network(
&mut self,
db: impl DbHandle,
ssid: &Ssid,
psk: &Psk,
priority: isize,
) -> Result<(), Error> {
self.add_network_low(&ssid, &psk).await?;
self.save_config(db).await?;
Ok(())
}
}
@@ -599,21 +717,26 @@ pub fn country_code_parse(code: &str, _matches: &ArgMatches<'_>) -> Result<Count
}
#[instrument(skip(main_datadir))]
pub async fn synchronize_wpa_supplicant_conf<P: AsRef<Path>>(main_datadir: P) -> Result<(), Error> {
let persistent = main_datadir.as_ref().join("wpa_supplicant.conf");
pub async fn synchronize_wpa_supplicant_conf<P: AsRef<Path>>(
main_datadir: P,
last_country_code: &Option<CountryCode>,
) -> Result<(), Error> {
let persistent = main_datadir.as_ref().join("system-connections");
tracing::debug!("persistent: {:?}", persistent);
let supplicant = Path::new("/etc/wpa_supplicant.conf");
if tokio::fs::metadata(&persistent).await.is_err() {
tokio::fs::write(&persistent, include_str!("wpa_supplicant.conf.base")).await?;
tokio::fs::create_dir_all(&persistent).await?;
}
let volatile = Path::new("/etc/wpa_supplicant.conf");
tracing::debug!("link: {:?}", volatile);
if tokio::fs::metadata(&volatile).await.is_ok() {
tokio::fs::remove_file(&volatile).await?
crate::disk::mount::util::bind(&persistent, "/etc/NetworkManager/system-connections", false)
.await?;
if tokio::fs::metadata(&supplicant).await.is_err() {
tokio::fs::write(&supplicant, include_str!("wpa_supplicant.conf.base")).await?;
}
tokio::fs::copy(&persistent, volatile).await?;
Command::new("systemctl")
.arg("restart")
.arg("wpa_supplicant")
.arg("NetworkManager")
.invoke(ErrorKind::Wifi)
.await?;
Command::new("ifconfig")
@@ -622,5 +745,14 @@ pub async fn synchronize_wpa_supplicant_conf<P: AsRef<Path>>(main_datadir: P) ->
.invoke(ErrorKind::Wifi)
.await?;
Command::new("dhclient").invoke(ErrorKind::Wifi).await?;
if let Some(last_country_code) = last_country_code {
tracing::info!("Setting the region");
let _ = Command::new("iw")
.arg("reg")
.arg("set")
.arg(last_country_code.alpha2())
.invoke(ErrorKind::Wifi)
.await?;
}
Ok(())
}

5
appmgr/src/nginx/main-ui.conf.template
View File

@@ -1,3 +1,5 @@
server {{
listen 443 ssl default_server;
listen [::]:443 ssl default_server;
@@ -19,7 +21,8 @@ server {{
gzip on;
gzip_vary on;
gzip_min_length 1024;
gzip_types text/plain text/css text/xml text/javascript application/x-javascript application/xml;
gzip_types text/plain text/css text/xml text/javascript application/javascript image/svg+xml font/tts font/otf font/eot font/openttype application/x-javascript application/xml;
location /rpc/ {{
proxy_pass http://127.0.0.1:5959/;