diff --git a/modules/nixos/desktop/packages.nix b/modules/nixos/desktop/packages.nix index b9d8ef0..61ff91c 100644 --- a/modules/nixos/desktop/packages.nix +++ b/modules/nixos/desktop/packages.nix @@ -4,15 +4,27 @@ let in { config = lib.mkIf cfg.enable { + # Chrome + programs.chromium = { + enable = true; + enablePlasmaBrowserIntegration = true; + extensions = [ + "nngceckbapebfimnlniiiahkandclblb" # bitwarden + "gcbommkclmclpchllfjekcdonpmejbdp" # https everywhere + "cjpalhdlnbpafiamejdnhcphjbkeiagm" # ublock origin + ]; + }; # Flatpak services.flatpak.enable = true; services.flatpak.packages = [ - "org.chromium.Chromium" + # "org.chromium.Chromium" "io.github.kolunmi.Bazaar" "com.spotify.Client" "org.pipewire.Helvum" ]; environment.systemPackages = (with pkgs; [ + # Browser + chromium # General utils busybox gcc diff --git a/modules/openwrt/generator/src/config.rs b/modules/openwrt/generator/src/config.rs new file mode 100644 index 0000000..324a527 --- /dev/null +++ b/modules/openwrt/generator/src/config.rs @@ -0,0 +1,85 @@ +use serde::Deserialize; +use std::collections::BTreeMap; + +#[derive(Deserialize)] +pub struct Config { + #[serde(rename = "generalMappings")] + pub general_mappings: Vec, + pub networks: BTreeMap>, + #[serde(default, rename = "dnsResolvers")] + pub dns_resolvers: Vec, +} + +#[derive(Deserialize)] +pub struct GeneralMapping { + pub ip: String, + pub domains: Vec, +} + +#[derive(Deserialize)] +pub struct DnsResolver { + pub ip: String, + #[serde(default)] + pub port: Option, + #[serde(default)] + pub name: Option, +} + +#[derive(Deserialize)] +pub struct Device { + pub mac: String, + pub name: String, + #[serde(default)] + pub id: Option, + #[serde(default)] + pub domains: Option>, + #[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())); + } +} diff --git a/modules/openwrt/generator/src/generators/dnsmasq.rs b/modules/openwrt/generator/src/generators/dnsmasq.rs new file mode 100644 index 0000000..42d4332 --- /dev/null +++ b/modules/openwrt/generator/src/generators/dnsmasq.rs @@ -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>) -> 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()); + } +} diff --git a/modules/openwrt/generator/src/generators/ethers.rs b/modules/openwrt/generator/src/generators/ethers.rs new file mode 100644 index 0000000..1db0102 --- /dev/null +++ b/modules/openwrt/generator/src/generators/ethers.rs @@ -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::() + 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()); + } +} diff --git a/modules/openwrt/generator/src/generators/mod.rs b/modules/openwrt/generator/src/generators/mod.rs new file mode 100644 index 0000000..a55aa0e --- /dev/null +++ b/modules/openwrt/generator/src/generators/mod.rs @@ -0,0 +1,2 @@ +pub mod dnsmasq; +pub mod ethers; diff --git a/modules/openwrt/generator/src/main.rs b/modules/openwrt/generator/src/main.rs index 2d26a67..6f0a9ce 100644 --- a/modules/openwrt/generator/src/main.rs +++ b/modules/openwrt/generator/src/main.rs @@ -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, - networks: BTreeMap>, -} - -#[derive(Deserialize)] -struct GeneralMapping { - ip: String, - domains: Vec, -} - -#[derive(Deserialize)] -struct Device { - mac: String, - name: String, - #[serde(default)] - id: Option, - #[serde(default)] - domains: Option>, - #[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> { - let prefix = prefix_for(network); - let just_mac_default = JUST_MAC_NETWORKS.contains(&network); - let mut suffix: u32 = 0; - let mut seen: Vec = 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::() + 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 "); std::process::exit(1); diff --git a/modules/openwrt/generator/src/network.rs b/modules/openwrt/generator/src/network.rs new file mode 100644 index 0000000..fcfe9bc --- /dev/null +++ b/modules/openwrt/generator/src/network.rs @@ -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> { + let prefix = prefix_for(network); + let just_mac_default = JUST_MAC_NETWORKS.contains(&network); + let mut suffix: u32 = 0; + let mut seen: Vec = 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, 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); + } +}