Neshura
293f0af30a
All checks were successful
Run Tests on Code / run-tests (push) Successful in 15s
311 lines
12 KiB
Rust
311 lines
12 KiB
Rust
/*use cloudflare_old::{Instance, CloudflareDnsType};*/
|
|
use reqwest::blocking::get;
|
|
use std::{thread::{sleep}};
|
|
use std::error::Error;
|
|
use std::net::{Ipv4Addr, Ipv6Addr};
|
|
use std::str::FromStr;
|
|
use chrono::{Utc, Duration};
|
|
use dotenv::dotenv;
|
|
use log::{info, warn, error, LevelFilter};
|
|
use reqwest::StatusCode;
|
|
use systemd_journal_logger::{connected_to_journal, JournalLog};
|
|
use crate::cloudflare::{CloudflareZone, DnsRecordType};
|
|
|
|
mod config;
|
|
mod cloudflare;
|
|
|
|
struct Addresses {
|
|
ipv4_uri: String,
|
|
ipv6_uri: String,
|
|
ipv4: Ipv4Addr,
|
|
ipv6: Ipv6Addr,
|
|
}
|
|
|
|
impl Addresses {
|
|
fn new() -> Result<Self, Box<dyn Error>> {
|
|
let mut ret = Self {
|
|
ipv4_uri: "https://am.i.mullvad.net/ip".to_owned(),
|
|
ipv6_uri: "https://ipv6.am.i.mullvad.net/ip".to_owned(),
|
|
ipv4: Ipv4Addr::new(0, 0, 0, 0),
|
|
ipv6: Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0)
|
|
};
|
|
|
|
match ret.get_v4() {
|
|
Ok(ip) => ret.ipv4 = ip,
|
|
Err(_) => {
|
|
let err_msg = format!("Unable to fetch IPv4 from '{}' during init. Aborting!", ret.ipv4_uri);
|
|
match connected_to_journal() {
|
|
true => error!("[ERROR] {err_msg}"),
|
|
false => eprintln!("[ERROR] {err_msg}"),
|
|
}
|
|
panic!("{}", err_msg);
|
|
}
|
|
}
|
|
|
|
match ret.get_v6() {
|
|
Ok(ip) => ret.ipv6 = ip,
|
|
Err(_) => {
|
|
let err_msg = format!("Unable to fetch IPv6 from '{}' during init. Aborting!", ret.ipv6_uri);
|
|
match connected_to_journal() {
|
|
true => error!("[ERROR] {err_msg}"),
|
|
false => eprintln!("[ERROR] {err_msg}"),
|
|
}
|
|
panic!("{}", err_msg);
|
|
}
|
|
}
|
|
|
|
Ok(ret)
|
|
}
|
|
|
|
fn check_new(&mut self, update: bool) -> bool {
|
|
let mut new = false;
|
|
|
|
match self.get_v4() {
|
|
Ok(ip) => {
|
|
if ip != self.ipv4 {
|
|
let info_msg = format!("IPv4 changed from '{}' to '{}'", self.ipv4, ip);
|
|
match connected_to_journal() {
|
|
true => info!("[INFO] {info_msg}"),
|
|
false => println!("[INFO] {info_msg}"),
|
|
}
|
|
new = true;
|
|
if update { self.ipv4 = ip }
|
|
}
|
|
}
|
|
Err(e) => {
|
|
let warn_msg = format!("Unable to fetch IPv4 from '{}'. Error: {}", self.ipv4_uri, e);
|
|
match connected_to_journal() {
|
|
true => warn!("[WARN] {warn_msg}"),
|
|
false => println!("[WARN] {warn_msg}"),
|
|
}
|
|
}
|
|
}
|
|
|
|
match self.get_v6() {
|
|
Ok(ip) => {
|
|
if ip != self.ipv6 {
|
|
let info_msg = format!("IPv6 changed from '{}' to '{}'", self.ipv6, ip);
|
|
match connected_to_journal() {
|
|
true => info!("[INFO] {info_msg}"),
|
|
false => println!("[INFO] {info_msg}"),
|
|
}
|
|
new = true;
|
|
if update { self.ipv6 = ip }
|
|
}
|
|
}
|
|
Err(e) => {
|
|
let warn_msg = format!("Unable to fetch IPv6 from '{}'. Error: {}", self.ipv6_uri, e);
|
|
match connected_to_journal() {
|
|
true => warn!("[WARN] {warn_msg}"),
|
|
false => println!("[WARN] {warn_msg}"),
|
|
}
|
|
}
|
|
}
|
|
|
|
new
|
|
}
|
|
|
|
fn get_v4(&self) -> Result<Ipv4Addr, reqwest::Error> {
|
|
match get(&self.ipv4_uri) {
|
|
Ok(res) => {
|
|
match res.status() {
|
|
StatusCode::OK => {
|
|
let ip_string = res.text().expect("Returned data should always contain text").trim_end().to_owned();
|
|
Ok(Ipv4Addr::from_str(ip_string.as_str()).expect("Returned IP should always be parseable"))
|
|
},
|
|
_ => {
|
|
let warn_msg = format!("Unexpected HTTP status {}", res.status());
|
|
match connected_to_journal() {
|
|
true => warn!("[WARN] {warn_msg}"),
|
|
false => println!("[WARN] {warn_msg}"),
|
|
}
|
|
Ok(Ipv4Addr::new(0, 0, 0, 0))
|
|
}
|
|
}
|
|
}
|
|
Err(e) => Err(e),
|
|
}
|
|
|
|
}
|
|
|
|
fn get_v6(&self) -> Result<Ipv6Addr, reqwest::Error> {
|
|
match get(&self.ipv6_uri) {
|
|
Ok(res) => {
|
|
match res.status() {
|
|
StatusCode::OK => {
|
|
let ip_string = res.text().expect("Returned data should always contain text").trim_end().to_owned();
|
|
Ok(Ipv6Addr::from_str(ip_string.as_str()).expect("Returned IP should always be parseable"))
|
|
},
|
|
_ => {
|
|
let warn_msg = format!("Unexpected HTTP status {}", res.status());
|
|
match connected_to_journal() {
|
|
true => warn!("[WARN] {warn_msg}"),
|
|
false => println!("[WARN] {warn_msg}"),
|
|
}
|
|
Ok(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0))
|
|
}
|
|
}
|
|
},
|
|
Err(e) => Err(e),
|
|
}
|
|
}
|
|
}
|
|
|
|
fn main() {
|
|
dotenv().ok();
|
|
JournalLog::new().expect("Systemd-Logger crate error").install().expect("Systemd-Logger crate error");
|
|
log::set_max_level(LevelFilter::Info);
|
|
|
|
let mut ifaces = config::InterfaceConfig::load().unwrap();
|
|
let mut zone_cfgs= config::ZoneConfig::load().unwrap();
|
|
|
|
let mut now = Utc::now() - Duration::seconds(59);
|
|
let mut start = now;
|
|
|
|
let mut ips = match Addresses::new() {
|
|
Ok(ips) => ips,
|
|
Err(e) => panic!("{}", e)
|
|
};
|
|
|
|
loop {
|
|
now = Utc::now();
|
|
if now >= start + Duration::seconds(60) {
|
|
start = now;
|
|
|
|
match config::InterfaceConfig::load() {
|
|
Ok(new) => ifaces = new,
|
|
Err(e) => {
|
|
let err_msg = format!("Unable to load ínterfaces.toml with error: {}", e);
|
|
match connected_to_journal() {
|
|
true => error!("[ERROR] {err_msg}"),
|
|
false => eprintln!("[ERROR] {err_msg}"),
|
|
}
|
|
}
|
|
}
|
|
|
|
match config::ZoneConfig::load() {
|
|
Ok(new) => zone_cfgs = new,
|
|
Err(e) => {
|
|
let err_msg = format!("Unable to load from zones.d with error: {}", e);
|
|
match connected_to_journal() {
|
|
true => error!("[ERROR] {err_msg}"),
|
|
false => eprintln!("[ERROR] {err_msg}"),
|
|
}
|
|
}
|
|
}
|
|
|
|
if ips.check_new(false) {
|
|
let mut error = false;
|
|
for zone in &zone_cfgs {
|
|
let cf_zone = match CloudflareZone::new(zone) {
|
|
Ok(data) => data,
|
|
Err(e) => {
|
|
let err_msg = format!("Cloudflare Token likely not set. Error: {}", e);
|
|
match connected_to_journal() {
|
|
true => error!("[ERROR] {err_msg}"),
|
|
false => eprintln!("[ERROR] {err_msg}"),
|
|
}
|
|
error = true;
|
|
continue
|
|
}
|
|
};
|
|
|
|
let cf_entries = match cf_zone.get_entries() {
|
|
Ok(entries) => entries,
|
|
Err(_) => {
|
|
error = true;
|
|
continue
|
|
}
|
|
};
|
|
|
|
for entry in &zone.entries {
|
|
let ipv6;
|
|
let ipv4;
|
|
match entry.r#type[..] {
|
|
[DnsRecordType::AAAA, DnsRecordType::A] => {
|
|
ipv6 = match ifaces.full_v6(&entry.interface, ips.ipv6) {
|
|
Ok(ip) => Some(ip),
|
|
Err(_) => {
|
|
error = true;
|
|
continue
|
|
}
|
|
};
|
|
ipv4 = Some(ips.ipv4);
|
|
},
|
|
[DnsRecordType::A, DnsRecordType::AAAA] => {
|
|
ipv6 = match ifaces.full_v6(&entry.interface, ips.ipv6) {
|
|
Ok(ip) => Some(ip),
|
|
Err(_) => {
|
|
error = true;
|
|
continue
|
|
}
|
|
};
|
|
ipv4 = Some(ips.ipv4);
|
|
},
|
|
[DnsRecordType::AAAA] => {
|
|
ipv6 = match ifaces.full_v6(&entry.interface, ips.ipv6) {
|
|
Ok(ip) => Some(ip),
|
|
Err(_) => {
|
|
error = true;
|
|
continue
|
|
}
|
|
};
|
|
ipv4 = None;
|
|
},
|
|
[DnsRecordType::A] => {
|
|
ipv6 = None;
|
|
ipv4 = Some(ips.ipv4);
|
|
},
|
|
_ => {
|
|
let warn_msg = "Config contains unsupported type identifier";
|
|
match connected_to_journal() {
|
|
true => warn!("[WARN] {warn_msg}"),
|
|
false => println!("[WARN] {warn_msg}"),
|
|
}
|
|
continue
|
|
}
|
|
}
|
|
|
|
for r#type in &entry.r#type {
|
|
let cf_entry = cf_entries.iter().find(|cf_entry| {
|
|
cf_entry.name == entry.name && &cf_entry.r#type == r#type
|
|
});
|
|
|
|
if let Some(cf_entry) = cf_entry {
|
|
match cf_zone.update(entry, r#type, &cf_entry.id, ipv6, ipv4) {
|
|
Ok(_) => {
|
|
let info_msg = format!("Updated DNS Record(s) for entry '{}' in zone '{}'", entry.name, zone.name);
|
|
match connected_to_journal() {
|
|
true => warn!("[INFO] {info_msg}"),
|
|
false => println!("[INFO] {info_msg}"),
|
|
}
|
|
},
|
|
Err(_) => error = true,
|
|
};
|
|
}
|
|
else {
|
|
match cf_zone.create(entry, r#type, ipv6, ipv4) {
|
|
Ok(_) => {
|
|
let info_msg = format!("Created DNS Record(s) for entry '{}' in zone '{}'", entry.name, zone.name);
|
|
match connected_to_journal() {
|
|
true => info!("[INFO] {info_msg}"),
|
|
false => println!("[INFO] {info_msg}"),
|
|
}
|
|
},
|
|
Err(_) => error = true,
|
|
};
|
|
}
|
|
}
|
|
|
|
// handle return values
|
|
}
|
|
}
|
|
if !error { ips.check_new(true); }
|
|
}
|
|
}
|
|
else {
|
|
sleep(std::time::Duration::from_millis(200));
|
|
}
|
|
}
|
|
}
|