use std::sync::Arc;
use serde_json::{Map, Value, json};
use crate::envelope::Envelope;
use crate::error::Error;
use crate::links::warn_uncharacterised_write;
use crate::params::{py_list, py_quote, resolve_network_url};
use crate::routes;
use crate::routes::ApiVersion;
use crate::transport::{RequestBody, Transport};
pub const MLO_MODES: &[&str] = &["disabled", "multi", "single"];
#[derive(Debug)]
pub struct SecurityApi {
transport: Arc<Transport>,
}
impl SecurityApi {
#[must_use]
pub fn new(transport: Arc<Transport>) -> Self {
Self { transport }
}
pub async fn get_security_settings(
&self,
network_id: &str,
parent: Option<&Value>,
) -> Result<Envelope, Error> {
let url = resolve_network_url(
self.transport.api_host(),
network_id,
parent,
ApiVersion::V2_2,
)?;
self.transport
.request(reqwest::Method::GET, url, &[], RequestBody::None)
.await
}
pub async fn set_wpa3(
&self,
network_id: &str,
enabled: bool,
parent: Option<&Value>,
) -> Result<Envelope, Error> {
self.put_settings_class(
network_id,
json!({ "wpa3": enabled }),
parent,
"set WPA3 for network",
)
.await
}
pub async fn set_band_steering(
&self,
network_id: &str,
enabled: bool,
parent: Option<&Value>,
) -> Result<Envelope, Error> {
self.put_settings_class(
network_id,
json!({ "band_steering": enabled }),
parent,
"set band steering for network",
)
.await
}
pub async fn set_upnp(
&self,
network_id: &str,
enabled: bool,
parent: Option<&Value>,
) -> Result<Envelope, Error> {
self.put_settings_class(
network_id,
json!({ "upnp": enabled }),
parent,
"set UPnP for network",
)
.await
}
pub async fn set_ipv6(
&self,
network_id: &str,
enabled: bool,
parent: Option<&Value>,
) -> Result<Envelope, Error> {
self.put_settings_class(
network_id,
json!({ "ipv6_upstream": enabled, "ipv6_downstream": enabled }),
parent,
"set IPv6 for network",
)
.await
}
pub async fn set_ipv6_upstream(
&self,
network_id: &str,
enabled: bool,
parent: Option<&Value>,
) -> Result<Envelope, Error> {
self.put_settings_class(
network_id,
json!({ "ipv6_upstream": enabled }),
parent,
"set IPv6 upstream for network",
)
.await
}
#[allow(clippy::too_many_arguments)]
pub async fn configure_security(
&self,
network_id: &str,
wpa3: Option<bool>,
band_steering: Option<bool>,
upnp: Option<bool>,
ipv6: Option<bool>,
parent: Option<&Value>,
) -> Result<Envelope, Error> {
let mut payload = Map::new();
if let Some(wpa3) = wpa3 {
payload.insert("wpa3".to_owned(), Value::Bool(wpa3));
}
if let Some(band_steering) = band_steering {
payload.insert("band_steering".to_owned(), Value::Bool(band_steering));
}
if let Some(upnp) = upnp {
payload.insert("upnp".to_owned(), Value::Bool(upnp));
}
if let Some(ipv6) = ipv6 {
payload.insert("ipv6_upstream".to_owned(), Value::Bool(ipv6));
payload.insert("ipv6_downstream".to_owned(), Value::Bool(ipv6));
}
if payload.is_empty() {
return Err(Error::validation(
"settings",
"at least one of wpa3, band_steering, upnp, ipv6 must be supplied",
));
}
self.put_settings_class(
network_id,
Value::Object(payload),
parent,
"configure security settings for network",
)
.await
}
pub async fn set_mlo_mode(
&self,
network_id: &str,
mode: &str,
parent: Option<&Value>,
) -> Result<Envelope, Error> {
if !MLO_MODES.contains(&mode) {
return Err(Error::validation(
"mode",
format!(
"must be one of {}, got {}",
py_list(MLO_MODES),
py_quote(mode)
),
));
}
let url = routes::security::SET_MLO_MODE.resolve(
self.transport.api_host(),
network_id,
parent,
)?;
warn_uncharacterised_write(
"set MLO mode for network -- may reboot every eero, like the confirmed DNS write path",
);
self.transport
.request(
routes::security::SET_MLO_MODE.method.clone(),
url,
&[],
RequestBody::Json(json!({ "mlo_mode": mode })),
)
.await
}
pub async fn get_fast_transition(
&self,
network_id: &str,
parent: Option<&Value>,
) -> Result<Envelope, Error> {
self.transport
.resource(
&routes::security::GET_FAST_TRANSITION,
network_id,
parent,
&[],
RequestBody::None,
)
.await
}
pub async fn set_fast_transition(
&self,
network_id: &str,
enabled: bool,
parent: Option<&Value>,
) -> Result<Envelope, Error> {
let url = routes::security::SET_FAST_TRANSITION.resolve(
self.transport.api_host(),
network_id,
parent,
)?;
warn_uncharacterised_write("set fast transition for network");
self.transport
.request(
routes::security::SET_FAST_TRANSITION.method.clone(),
url,
&[],
RequestBody::Json(json!({ "fast_transition": enabled })),
)
.await
}
pub async fn set_passpoint_enabled(
&self,
network_id: &str,
enabled: bool,
parent: Option<&Value>,
) -> Result<Envelope, Error> {
let url = routes::security::SET_PASSPOINT_ENABLED.resolve(
self.transport.api_host(),
network_id,
parent,
)?;
warn_uncharacterised_write("set Passpoint enabled for network");
self.transport
.request(
routes::security::SET_PASSPOINT_ENABLED.method.clone(),
url,
&[],
RequestBody::Json(json!({ "enabled": enabled })),
)
.await
}
pub async fn set_proxied_nodes(
&self,
network_id: &str,
enabled: bool,
parent: Option<&Value>,
) -> Result<Envelope, Error> {
let url = routes::security::SET_PROXIED_NODES.resolve(
self.transport.api_host(),
network_id,
parent,
)?;
warn_uncharacterised_write("set proxied nodes for network");
self.transport
.request(
routes::security::SET_PROXIED_NODES.method.clone(),
url,
&[],
RequestBody::Json(json!({ "enabled": enabled })),
)
.await
}
async fn put_settings_class(
&self,
network_id: &str,
payload: Value,
parent: Option<&Value>,
operation: &str,
) -> Result<Envelope, Error> {
let url = routes::security::SECURITY_PUT_SETTINGS.resolve(
self.transport.api_host(),
network_id,
parent,
)?;
warn_uncharacterised_write(&format!(
"{operation} -- may reboot every eero, like the confirmed DNS write path"
));
self.transport
.request(
routes::security::SECURITY_PUT_SETTINGS.method.clone(),
url,
&[],
RequestBody::Json(payload),
)
.await
}
}