use reqwest::blocking::get; use serde_derive::{Deserialize, Serialize}; use std::{fs, process::exit, thread::{sleep}}; use chrono::{Utc, Duration, Date}; mod cloudflare; fn default_key() -> String { return "".to_string(); } struct ChangeTracker { created: u16, updated: u16, unchanged: u16, error: u16 } impl ChangeTracker { fn new() -> ChangeTracker { ChangeTracker { created: 0, updated: 0, unchanged: 0, error: 0 } } fn print(&self, f: &str) { match f { "" => { self.print("simple"); } "simple" => { println!("{} created", self.created); println!("{} updated", self.updated); println!("{} unchanged", self.unchanged); println!("{} errors", self.error); } &_ => { println!("unknown format pattern '{}', defaulting to 'simple'", f); self.print("simple"); } } } } #[derive(Serialize, Deserialize)] struct DnsEntry { name: String, type4: bool, type6: bool, interface: Option, } #[derive(Serialize, Deserialize)] struct DnsZone { email: String, name: String, id: String, dns_entries: Vec, } #[derive(Serialize, Deserialize)] struct DnsConfig { ipv6_interface: String, #[serde(default = "default_key")] api_key: String, zones: Vec, } impl DnsConfig { fn new() -> DnsConfig { DnsConfig { ipv6_interface: "".to_string(), api_key: "".to_string(), zones: Vec::new(), } } fn load(&mut self) { let file_contents = match fs::read_to_string("config.json") { Ok(data) => data, Err(e) => panic!("{:#?}", e), }; let config_parse: DnsConfig = match serde_json::from_str(&file_contents) { Ok(data) => data, Err(e) => panic!("{:#?}", e), }; let key_file_contents = match fs::read_to_string("api-key.json") { Ok(data) => data, Err(e) => panic!("{:#?}", e), }; let api_key_parse: serde_json::Value = match serde_json::from_str(&key_file_contents) { Ok(data) => data, Err(e) => panic!("{:#?}", e), }; *self = config_parse; self.api_key = api_key_parse["api_key"].as_str().unwrap().to_owned(); } } struct Ips { ipv4: String, ipv6base: String, } impl Ips { fn new() -> Ips { Ips { ipv4: "0.0.0.0".to_string(), ipv6base: ":".to_string(), } } fn get(&mut self, ipv6_interface: &str) { let ipv4uri = "https://am.i.mullvad.net/ip"; let ipv6uri = "https://ipv6.am.i.mullvad.net/ip"; let response = get(ipv4uri); match response { Ok(data) => self.ipv4 = data.text().expect("0.0.0.0").trim_end().to_owned(), Err(e) => { println!("Could not fetch IPv4, quitting"); exit(75); } } let response = get(ipv6uri); match response { Ok(data) => { let ipv6 = match data.text() { Ok(ip) => {ip}, Err(_) => {panic!("Expected IP, found none")}, }; let stripped = match ipv6.trim_end().strip_suffix(ipv6_interface) { Some(string) => string.to_string(), None => ":".to_string(), }; self.ipv6base = stripped; } Err(e) => { println!("Could not fetch IPv6, quitting"); exit(75); } } } } fn update_dns() { let mut config = DnsConfig::new(); config.load(); /* while (true) {} */ let mut ips = Ips::new(); ips.get(&config.ipv6_interface); let mut change4 = ChangeTracker::new(); let mut change6 = ChangeTracker::new(); for zone in config.zones { let mut agent = cloudflare::Instance::new(&config.api_key); agent.load_entries(&zone.email, &zone.id); for entry in zone.dns_entries { let mut found4 = false; let mut found6 = false; for cloudflare_entry in &agent.dns_entries { if cloudflare_entry.is_equal(&entry.name) { if cloudflare_entry.r#type == cloudflare::CloudflareDnsType::A && entry.type4 { found4 = true; if cloudflare_entry.is_ip_new(&ips.ipv4) { let success = agent.update_entry(cloudflare_entry, &ips.ipv4); if success { change4.updated += 1 } else { change4.error += 1 } } else { change4.unchanged += 1; } } if cloudflare_entry.r#type == cloudflare::CloudflareDnsType::AAAA && entry.type6 { found6 = true; let ipv6 = ips.ipv6base.clone() + entry.interface.as_ref().unwrap(); if cloudflare_entry.is_ip_new(&ipv6) { let success = agent.update_entry(cloudflare_entry, &ipv6); if success { change6.updated += 1 } else { change6.error += 1 } } else { change6.unchanged += 1; } } } //println!("{:#?}", entry.subdomain); // DEBUG } if !found4 && entry.type4 { let success = agent.create_entry(&zone.id, "A", &entry.name, &ips.ipv4); if success { change4.created += 1 }; } if !found6 && entry.type6 { let ipv6 = ips.ipv6base.clone() + entry.interface.as_ref().unwrap(); let success = agent.create_entry(&zone.id, "AAAA", &entry.name, &ipv6); if success { change6.created += 1 }; } } //println!("{:#?}", zone.domain); // DEBUG } println!("++++A Records+++"); change4.print("simple"); println!("++AAAA Records++"); change6.print("simple") } fn main() { let mut now = Utc::now() - Duration::seconds(59); let mut current = now; println!("Initial Time is {} {}", now.format("%H:%M:%S"), now.timezone()); loop { now = Utc::now(); if now >= current + Duration::seconds(60) { current = now; println!("Starting DNS Update at {} {}", now.format("%H:%M:%S"), now.timezone()); update_dns(); } else { sleep(std::time::Duration::from_millis(500)); } } }