use std::net::{IpAddr, Ipv6Addr};
use std::sync::Arc;
use serde_json::{Value, json};
use crate::envelope::Envelope;
use crate::error::Error;
use crate::links::warn_uncharacterised_write;
use crate::routes;
use crate::transport::{RequestBody, Transport};
pub const MAX_DNS_SERVERS_PER_FAMILY: usize = 2;
#[derive(Debug)]
pub struct DnsApi {
transport: Arc<Transport>,
}
impl DnsApi {
#[must_use]
pub fn new(transport: Arc<Transport>) -> Self {
Self { transport }
}
pub async fn get_dns_settings(&self, network_id: &str) -> Result<Envelope, Error> {
self.transport
.resource(
&routes::dns::GET_DNS_SETTINGS,
network_id,
None,
&[],
RequestBody::None,
)
.await
}
pub async fn set_dns_caching(
&self,
network_id: &str,
enabled: bool,
parent: Option<&Value>,
) -> Result<Envelope, Error> {
self.put_settings(network_id, json!({ "dns": { "caching": enabled } }), parent)
.await
}
pub async fn set_custom_dns(
&self,
network_id: &str,
dns_servers: &[&str],
parent: Option<&Value>,
) -> Result<Envelope, Error> {
let (ipv4, ipv6) = split_by_family(dns_servers, "dns_servers")?;
if ipv4.is_empty() && ipv6.is_empty() {
return Err(Error::validation(
"dns_servers",
"no servers supplied; use clear_custom_dns() to switch to automatic DNS",
));
}
let mut payload = serde_json::Map::new();
if !ipv4.is_empty() {
payload.insert(
"dns".to_owned(),
json!({ "mode": DNS_MODE_CUSTOM, "custom": { "ips": ipv4 } }),
);
}
if !ipv6.is_empty() {
payload.insert(
"ipv6".to_owned(),
json!({ "name_servers": { "mode": DNS_MODE_CUSTOM, "custom": ipv6 } }),
);
}
self.put_settings(network_id, Value::Object(payload), parent)
.await
}
pub async fn set_custom_dns_ipv4(
&self,
network_id: &str,
dns_servers: &[&str],
parent: Option<&Value>,
) -> Result<Envelope, Error> {
let servers = validate_family_servers(dns_servers, 4, "dns_servers")?;
if servers.is_empty() {
return Err(Error::validation(
"dns_servers",
"no servers supplied; use clear_custom_dns(family='ipv4') to switch to automatic",
));
}
self.put_settings(
network_id,
json!({ "dns": { "mode": DNS_MODE_CUSTOM, "custom": { "ips": servers } } }),
parent,
)
.await
}
pub async fn set_custom_dns_ipv6(
&self,
network_id: &str,
dns_servers: &[&str],
parent: Option<&Value>,
) -> Result<Envelope, Error> {
let servers = validate_family_servers(dns_servers, 6, "dns_servers")?;
if servers.is_empty() {
return Err(Error::validation(
"dns_servers",
"no servers supplied; use clear_custom_dns(family='ipv6') to switch to automatic",
));
}
self.put_settings(
network_id,
json!({ "ipv6": { "name_servers": { "mode": DNS_MODE_CUSTOM, "custom": servers } } }),
parent,
)
.await
}
pub async fn clear_custom_dns(
&self,
network_id: &str,
family: Option<&str>,
parent: Option<&Value>,
) -> Result<Envelope, Error> {
if !matches!(family, None | Some("ipv4" | "ipv6")) {
return Err(Error::validation(
"family",
"must be 'ipv4', 'ipv6', or None",
));
}
let mut payload = serde_json::Map::new();
if matches!(family, None | Some("ipv4")) {
payload.insert("dns".to_owned(), json!({ "mode": DNS_MODE_AUTOMATIC }));
}
if matches!(family, None | Some("ipv6")) {
payload.insert(
"ipv6".to_owned(),
json!({ "name_servers": { "mode": DNS_MODE_AUTOMATIC } }),
);
}
self.put_settings(network_id, Value::Object(payload), parent)
.await
}
pub async fn set_dns_mode(
&self,
network_id: &str,
mode: &str,
custom_servers: Option<&[&str]>,
parent: Option<&Value>,
) -> Result<Envelope, Error> {
let normalized = mode.trim().to_lowercase();
match normalized.as_str() {
"auto" | DNS_MODE_AUTOMATIC => self.clear_custom_dns(network_id, None, parent).await,
DNS_MODE_CUSTOM => match custom_servers {
Some(servers) if !servers.is_empty() => {
self.set_custom_dns(network_id, servers, parent).await
}
_ => {
self.put_settings(
network_id,
json!({
"dns": { "mode": DNS_MODE_CUSTOM },
"ipv6": { "name_servers": { "mode": DNS_MODE_CUSTOM } },
}),
parent,
)
.await
}
},
_ => Err(Error::validation(
"mode",
format!(
"{} is not a valid DNS mode; expected 'auto' or 'custom'. Provider \
presets are available from the API at data.dns.default_test_servers — pass \
those addresses as custom_servers",
crate::params::py_quote(mode)
),
)),
}
}
async fn put_settings(
&self,
network_id: &str,
payload: Value,
parent: Option<&Value>,
) -> Result<Envelope, Error> {
warn_uncharacterised_write("write DNS settings for network — reboots every eero");
self.transport
.resource(
&routes::dns::DNS_PUT_SETTINGS,
network_id,
parent,
&[],
RequestBody::Json(payload),
)
.await
}
}
const DNS_MODE_CUSTOM: &str = "custom";
const DNS_MODE_AUTOMATIC: &str = "automatic";
fn split_by_family(servers: &[&str], field: &str) -> Result<(Vec<String>, Vec<String>), Error> {
let mut ipv4_raw = Vec::new();
let mut ipv6_raw = Vec::new();
for &entry in servers {
let family = family_for_split(entry, field)?;
match family {
4 => ipv4_raw.push(entry),
_ => ipv6_raw.push(entry),
}
}
let ipv4 = validate_family_servers(&ipv4_raw, 4, field)?;
let ipv6 = validate_family_servers(&ipv6_raw, 6, field)?;
Ok((ipv4, ipv6))
}
fn family_for_split(entry: &str, field: &str) -> Result<u8, Error> {
let candidate = entry.trim();
if candidate.contains('%') {
return Err(Error::validation(
field,
format!(
"{} has a zone identifier, which is not valid for a DNS server",
crate::params::py_quote(entry)
),
));
}
let address: IpAddr = candidate.parse().map_err(|_| {
Error::validation(
field,
format!(
"{} is not a valid IP address",
crate::params::py_quote(entry)
),
)
})?;
Ok(if address.is_ipv4() { 4 } else { 6 })
}
fn validate_family_servers(
servers: &[&str],
family: u8,
field: &str,
) -> Result<Vec<String>, Error> {
if servers.len() > MAX_DNS_SERVERS_PER_FAMILY {
return Err(Error::validation(
field,
format!(
"at most {MAX_DNS_SERVERS_PER_FAMILY} IPv{family} servers are supported (got {}); \
this matches the eero app's primary/secondary slots",
servers.len()
),
));
}
let mut normalized = Vec::with_capacity(servers.len());
for &entry in servers {
let (got_family, address) = parse_one_server(entry, field)?;
if got_family != family {
return Err(Error::validation(
field,
format!(
"{} is an IPv{got_family} address, expected IPv{family}",
crate::params::py_quote(entry)
),
));
}
normalized.push(address);
}
Ok(normalized)
}
fn parse_one_server(entry: &str, field: &str) -> Result<(u8, String), Error> {
let candidate = entry.trim();
if candidate.is_empty() {
return Err(Error::validation(field, "IP address must not be empty"));
}
if candidate.contains('%') {
return Err(Error::validation(
field,
format!(
"{} has a zone identifier, which is not valid for a DNS server",
crate::params::py_quote(entry)
),
));
}
let address: IpAddr = candidate.parse().map_err(|_| {
Error::validation(
field,
format!(
"{} is not a valid IP address",
crate::params::py_quote(entry)
),
)
})?;
match address {
IpAddr::V4(v4) => Ok((4, v4.to_string())),
IpAddr::V6(v6) => Ok((6, format_ipv6(v6))),
}
}
fn format_ipv6(address: Ipv6Addr) -> String {
let segments = address.segments();
let is_ipv4_mapped = segments[..5] == [0, 0, 0, 0, 0] && segments[5] == 0xffff;
if is_ipv4_mapped {
format!("::ffff:{:x}:{:x}", segments[6], segments[7])
} else {
address.to_string()
}
}