openwrt refactor + chromium

This commit is contained in:
ari committed 2026-05-24 17:34:38 -04:00
1 parent a5a18e846e
commit 6b0e974e77
7 files changed
+399 -138

No files matched your search

+85
View File
@@ -0,0 +1,85 @@
use serde::Deserialize;
use std::collections::BTreeMap;
#[derive(Deserialize)]
pub struct Config {
#[serde(rename = "generalMappings")]
pub general_mappings: Vec<GeneralMapping>,
pub networks: BTreeMap<String, Vec<Device>>,
#[serde(default, rename = "dnsResolvers")]
pub dns_resolvers: Vec<DnsResolver>,
}
#[derive(Deserialize)]
pub struct GeneralMapping {
pub ip: String,
pub domains: Vec<String>,
}
#[derive(Deserialize)]
pub struct DnsResolver {
pub ip: String,
#[serde(default)]
pub port: Option<u16>,
#[serde(default)]
pub name: Option<String>,
}
#[derive(Deserialize)]
pub struct Device {
pub mac: String,
pub name: String,
#[serde(default)]
pub id: Option<u32>,
#[serde(default)]
pub domains: Option<Vec<String>>,
#[serde(rename = "justMac", default)]
pub just_mac: bool,
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_minimal_config() {
let json = r#"{"generalMappings": [], "networks": {}}"#;
let config: Config = serde_json::from_str(json).unwrap();
assert!(config.general_mappings.is_empty());
assert!(config.networks.is_empty());
assert!(config.dns_resolvers.is_empty());
}
#[test]
fn test_device_parsing() {
let json = r#"{
"generalMappings": [],
"networks": {
"lab": [{"mac": "aa:bb:cc:dd:ee:ff", "name": "server1", "id": 42, "justMac": true}]
}
}"#;
let config: Config = serde_json::from_str(json).unwrap();
let device = &config.networks["lab"][0];
assert_eq!(device.mac, "aa:bb:cc:dd:ee:ff");
assert_eq!(device.id, Some(42));
assert!(device.just_mac);
}
#[test]
fn test_general_mapping_parsing() {
let json = r#"{"generalMappings": [{"ip": "192.168.1.1", "domains": ["test.local"]}], "networks": {}}"#;
let config: Config = serde_json::from_str(json).unwrap();
assert_eq!(config.general_mappings[0].ip, "192.168.1.1");
assert_eq!(config.general_mappings[0].domains, vec!["test.local"]);
}
#[test]
fn test_dns_resolver_parsing() {
let json = r#"{"generalMappings": [], "networks": {}, "dnsResolvers": [{"ip": "1.1.1.1", "port": 853, "name": "CF"}]}"#;
let config: Config = serde_json::from_str(json).unwrap();
let resolver = &config.dns_resolvers[0];
assert_eq!(resolver.ip, "1.1.1.1");
assert_eq!(resolver.port, Some(853));
assert_eq!(resolver.name, Some("CF".to_string()));
}
}
@@ -0,0 +1,112 @@
use crate::config::Config;
use crate::network::process_network;
pub fn generate(config: &Config) -> String {
let mut out = String::new();
// Add DNS resolver configuration
for resolver in &config.dns_resolvers {
if let Some(port) = resolver.port {
out.push_str(&format!("server={}#{}", resolver.ip, port));
} else {
out.push_str(&format!("server={}", resolver.ip));
}
if let Some(name) = &resolver.name {
out.push_str(&format!(" # {}", name));
}
out.push('\n');
}
if !config.dns_resolvers.is_empty() {
out.push('\n');
}
for (network, devices) in &config.networks {
for pd in process_network(network, devices) {
if pd.just_mac {
continue;
}
if let Some(domains) = &pd.device.domains {
for domain in domains {
out.push_str(&format!("address=/{}/{}\n", domain, pd.ip));
out.push_str(&format!("address=/.{}/{}\n", domain, pd.ip));
}
}
}
}
for gm in &config.general_mappings {
for domain in &gm.domains {
out.push_str(&format!("address=/{}/{}\n", domain, gm.ip));
out.push_str(&format!("address=/.{}/{}\n", domain, gm.ip));
}
}
out
}
#[cfg(test)]
mod tests {
use super::*;
use crate::config::{Config, Device, DnsResolver, GeneralMapping};
use std::collections::BTreeMap;
fn config_with_device(domains: Option<Vec<String>>) -> Config {
let mut networks = BTreeMap::new();
networks.insert("lab".to_string(), vec![Device {
mac: "aa:bb:cc:dd:ee:ff".to_string(),
name: "server".to_string(),
id: None,
domains,
just_mac: false,
}]);
Config { general_mappings: vec![], networks, dns_resolvers: vec![] }
}
#[test]
fn test_device_with_domains() {
let config = config_with_device(Some(vec!["example.com".to_string()]));
let result = generate(&config);
assert!(result.contains("address=/example.com/10.0.10.1\n"));
assert!(result.contains("address=/.example.com/10.0.10.1\n"));
}
#[test]
fn test_general_mappings() {
let config = Config {
general_mappings: vec![GeneralMapping {
ip: "192.168.1.1".to_string(),
domains: vec!["gw.local".to_string()],
}],
networks: BTreeMap::new(),
dns_resolvers: vec![],
};
let result = generate(&config);
assert!(result.contains("address=/gw.local/192.168.1.1\n"));
}
#[test]
fn test_dns_resolvers() {
let config = Config {
general_mappings: vec![],
networks: BTreeMap::new(),
dns_resolvers: vec![DnsResolver {
ip: "1.1.1.1".to_string(),
port: Some(853),
name: Some("CF".to_string()),
}],
};
let result = generate(&config);
assert!(result.contains("server=1.1.1.1#853 # CF\n"));
}
#[test]
fn test_empty_config() {
let config = Config {
general_mappings: vec![],
networks: BTreeMap::new(),
dns_resolvers: vec![],
};
assert!(generate(&config).is_empty());
}
}
@@ -0,0 +1,75 @@
use crate::config::Config;
use crate::network::process_network;
pub fn generate(config: &Config) -> String {
let mut out = String::new();
for (network, devices) in &config.networks {
let cap = |s: &str| {
let mut c = s.chars();
match c.next() {
None => String::new(),
Some(f) => f.to_uppercase().collect::<String>() + c.as_str(),
}
};
out.push_str(&format!("#{}\n", cap(network)));
for pd in process_network(network, devices) {
if !pd.just_mac {
out.push_str(&format!("{} {}\n", pd.device.mac, pd.ip));
}
out.push_str(&format!("{} {}\n", pd.device.mac, pd.host));
}
}
out
}
#[cfg(test)]
mod tests {
use super::*;
use crate::config::{Config, Device};
use std::collections::BTreeMap;
fn config_with_device(just_mac: bool) -> Config {
let mut networks = BTreeMap::new();
networks.insert("lab".to_string(), vec![Device {
mac: "aa:bb:cc:dd:ee:ff".to_string(),
name: "server".to_string(),
id: None,
domains: None,
just_mac,
}]);
Config { general_mappings: vec![], networks, dns_resolvers: vec![] }
}
#[test]
fn test_generates_ip_and_hostname() {
let result = generate(&config_with_device(false));
assert!(result.contains("aa:bb:cc:dd:ee:ff 10.0.10.1\n"));
assert!(result.contains("aa:bb:cc:dd:ee:ff server.lab.internal\n"));
}
#[test]
fn test_just_mac_omits_ip_line() {
let result = generate(&config_with_device(true));
assert!(!result.contains("10.0.10.1"));
assert!(result.contains("aa:bb:cc:dd:ee:ff server.lab.internal\n"));
}
#[test]
fn test_network_header_capitalized() {
let result = generate(&config_with_device(false));
assert!(result.contains("#Lab\n"));
}
#[test]
fn test_empty_config() {
let config = Config {
general_mappings: vec![],
networks: BTreeMap::new(),
dns_resolvers: vec![],
};
assert!(generate(&config).is_empty());
}
}
@@ -0,0 +1,2 @@
pub mod dnsmasq;
pub mod ethers;
+10 -137
View File
@@ -1,150 +1,23 @@
use serde::Deserialize;
use std::collections::BTreeMap;
mod config;
mod generators;
mod network;
use config::Config;
use std::io::{self, Read};
const ROOT_DOMAIN: &str = "internal";
static IP_PREFIXES: &[(&str, &str)] = &[
("lab", "10.0.10."),
("k3s", "10.0.11."),
("hub", "10.0.12."),
("cam", "10.0.13."),
("iot", "10.0.14."),
("apl", "10.0.15."),
("router", "10.0.16."),
("devices", "10.0.0."),
];
// Networks where justMac defaults to true
static JUST_MAC_NETWORKS: &[&str] = &["devices"];
#[derive(Deserialize)]
struct Config {
#[serde(rename = "generalMappings")]
general_mappings: Vec<GeneralMapping>,
networks: BTreeMap<String, Vec<Device>>,
}
#[derive(Deserialize)]
struct GeneralMapping {
ip: String,
domains: Vec<String>,
}
#[derive(Deserialize)]
struct Device {
mac: String,
name: String,
#[serde(default)]
id: Option<u32>,
#[serde(default)]
domains: Option<Vec<String>>,
#[serde(rename = "justMac", default)]
just_mac: bool,
}
struct ProcessedDevice<'a> {
device: &'a Device,
ip: String,
host: String,
just_mac: bool,
}
fn prefix_for(network: &str) -> &'static str {
IP_PREFIXES
.iter()
.find(|(n, _)| *n == network)
.map(|(_, p)| *p)
.unwrap_or("10.0.0.")
}
fn process_network<'a>(network: &str, devices: &'a [Device]) -> Vec<ProcessedDevice<'a>> {
let prefix = prefix_for(network);
let just_mac_default = JUST_MAC_NETWORKS.contains(&network);
let mut suffix: u32 = 0;
let mut seen: Vec<u32> = Vec::new();
let mut result = Vec::new();
for device in devices {
let base = device.id.unwrap_or(suffix + 1);
// Skip any already-used suffixes
let next = (base..).find(|s| !seen.contains(s)).unwrap();
suffix = next;
seen.push(next);
result.push(ProcessedDevice {
device,
ip: format!("{}{}", prefix, next),
host: format!("{}.{}.{}", device.name, network, ROOT_DOMAIN),
just_mac: device.just_mac || just_mac_default,
});
}
result
}
fn gen_dnsmasq(config: &Config) -> String {
let mut out = String::new();
for (network, devices) in &config.networks {
for pd in process_network(network, devices) {
if pd.just_mac {
continue;
}
if let Some(domains) = &pd.device.domains {
for domain in domains {
out.push_str(&format!("address=/{}/{}\n", domain, pd.ip));
out.push_str(&format!("address=/.{}/{}\n", domain, pd.ip));
}
}
}
}
for gm in &config.general_mappings {
for domain in &gm.domains {
out.push_str(&format!("address=/{}/{}\n", domain, gm.ip));
out.push_str(&format!("address=/.{}/{}\n", domain, gm.ip));
}
}
out
}
fn gen_ethers(config: &Config) -> String {
let mut out = String::new();
for (network, devices) in &config.networks {
let cap = |s: &str| {
let mut c = s.chars();
match c.next() {
None => String::new(),
Some(f) => f.to_uppercase().collect::<String>() + c.as_str(),
}
};
out.push_str(&format!("#{}\n", cap(network)));
for pd in process_network(network, devices) {
if !pd.just_mac {
out.push_str(&format!("{} {}\n", pd.device.mac, pd.ip));
}
out.push_str(&format!("{} {}\n", pd.device.mac, pd.host));
}
}
out
}
fn main() {
let cmd = std::env::args().nth(1).unwrap_or_default();
let mut input = String::new();
io::stdin().read_to_string(&mut input).expect("failed to read stdin");
io::stdin()
.read_to_string(&mut input)
.expect("failed to read stdin");
let config: Config = serde_json::from_str(&input).expect("invalid config JSON");
let output = match cmd.as_str() {
"dnsmasq" => gen_dnsmasq(&config),
"ethers" => gen_ethers(&config),
"dnsmasq" => generators::dnsmasq::generate(&config),
"ethers" => generators::ethers::generate(&config),
_ => {
eprintln!("usage: openwrt-gen <dnsmasq|ethers>");
std::process::exit(1);
+102
View File
@@ -0,0 +1,102 @@
use crate::config::Device;
pub const ROOT_DOMAIN: &str = "internal";
pub static IP_PREFIXES: &[(&str, &str)] = &[
("lab", "10.0.10."),
("k3s", "10.0.11."),
("hub", "10.0.12."),
("cam", "10.0.13."),
("iot", "10.0.14."),
("apl", "10.0.15."),
("router", "10.0.16."),
("devices", "10.0.0."),
];
// Networks where justMac defaults to true
pub static JUST_MAC_NETWORKS: &[&str] = &["devices"];
pub struct ProcessedDevice<'a> {
pub device: &'a Device,
pub ip: String,
pub host: String,
pub just_mac: bool,
}
pub fn prefix_for(network: &str) -> &'static str {
IP_PREFIXES
.iter()
.find(|(n, _)| *n == network)
.map(|(_, p)| *p)
.unwrap_or("10.0.0.")
}
pub fn process_network<'a>(network: &str, devices: &'a [Device]) -> Vec<ProcessedDevice<'a>> {
let prefix = prefix_for(network);
let just_mac_default = JUST_MAC_NETWORKS.contains(&network);
let mut suffix: u32 = 0;
let mut seen: Vec<u32> = Vec::new();
let mut result = Vec::new();
for device in devices {
let base = device.id.unwrap_or(suffix + 1);
// Skip any already-used suffixes
let next = (base..).find(|s| !seen.contains(s)).unwrap();
suffix = next;
seen.push(next);
result.push(ProcessedDevice {
device,
ip: format!("{}{}", prefix, next),
host: format!("{}.{}.{}", device.name, network, ROOT_DOMAIN),
just_mac: device.just_mac || just_mac_default,
});
}
result
}
#[cfg(test)]
mod tests {
use super::*;
fn device(name: &str, id: Option<u32>, just_mac: bool) -> Device {
Device {
mac: "aa:bb:cc:dd:ee:ff".to_string(),
name: name.to_string(),
id,
domains: None,
just_mac,
}
}
#[test]
fn test_prefix_for_known_and_unknown() {
assert_eq!(prefix_for("lab"), "10.0.10.");
assert_eq!(prefix_for("devices"), "10.0.0.");
assert_eq!(prefix_for("unknown"), "10.0.0.");
}
#[test]
fn test_process_network_generates_ip_and_host() {
let devices = vec![device("server1", None, false)];
let result = process_network("lab", &devices);
assert_eq!(result[0].ip, "10.0.10.1");
assert_eq!(result[0].host, "server1.lab.internal");
}
#[test]
fn test_process_network_auto_increments_ids() {
let devices = vec![device("a", None, false), device("b", None, false)];
let result = process_network("lab", &devices);
assert_eq!(result[0].ip, "10.0.10.1");
assert_eq!(result[1].ip, "10.0.10.2");
}
#[test]
fn test_devices_network_defaults_to_just_mac() {
let devices = vec![device("phone", None, false)];
let result = process_network("devices", &devices);
assert!(result[0].just_mac);
}
}