Merge branch 'master' of gburri.org:gandi_dns_update

[gandi_dns_update.git] / src / main.rs

diff --git a/src/main.rs b/src/main.rs
index 1509a25..6665155 100644 (file)
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,19 +1,172 @@
-// API Reference: https://api.gandi.net/docs/livedns/
-// Some inspiration: https://github.com/rmarchant/gandi-ddns/blob/master/gandi_ddns.py
+/*
+ * API Reference: https://api.gandi.net/docs/livedns/
+ *
+ * Some similar implementations:
+ * - https://github.com/rmarchant/gandi-ddns/blob/master/gandi_ddns.py
+ * - https://github.com/brianhp2/gandi-automatic-dns
+ *
+ */
 
+#![cfg_attr(debug_assertions, allow(unused_variables, unused_imports, dead_code))]
 
-fn main() {
-    println!("Hello, world!");
+use std::{
+    net::{IpAddr, Ipv4Addr},
+    thread, time,
+};
+
+use serde_json::{json, Value};
+
+use crate::{
+    config::Config,
+    error::{Error, Result},
+};
+
+mod config;
+mod error;
+
+const FILE_CONF: &str = "config.ron";
+
+fn main() -> Result<()> {
+    println!("GANDI LiveDNS updater");
+
+    let config = Config::read(FILE_CONF)?;
+
+    println!(
+        "Configuration: {:?}",
+        Config {
+            api_key: String::from("*****"),
+            ..config.clone()
+        }
+    );
+
+    loop {
+        let time_beginning_loop = time::Instant::now();
+
+        if let Err(err) = check_and_update_dns(&config.api_key, &config.domains, config.ttl) {
+            println!("!! {}", err);
+        }
+
+        let elapsed = time::Instant::now() - time_beginning_loop;
+
+        if elapsed < config.delay_between_check {
+            let to_wait = config.delay_between_check - elapsed;
+            thread::sleep(to_wait);
+        }
+    }
+}
+
+fn check_and_update_dns(api_key: &str, domains: &Vec<(String, String)>, ttl: i32) -> Result<()> {
+    let real_ip = get_real_ip()?;
+
+    for (hostname, domain) in domains {
+        let current_ip = get_current_record_ip(api_key, hostname, domain)?;
+
+        if real_ip != current_ip {
+            println!(
+                "IP addresses don't match for domain {}: real = {}, dns = {}. Renewing DNS...",
+                domain, real_ip, current_ip
+            );
+            update_record_ip(api_key, hostname, domain, real_ip, ttl)?;
+            println!("Renewing of {}.{} successfully", hostname, domain);
+        }
+    }
+
+    Ok(())
+}
+
+fn get_real_ip() -> Result<Ipv4Addr> {
+    let url = "https://api.ipify.org";
+    let client = reqwest::blocking::Client::new();
+
+    match client.get(url).send() {
+        Ok(resp) => {
+            if resp.status().is_success() {
+                let content = resp.text().unwrap();
+                match content.parse() {
+                    Ok(IpAddr::V4(ip_v4)) => Ok(ip_v4),
+                    _ => Err(Box::new(Error {
+                        message: String::from("Can't parse IPv4 from ipify"),
+                    })),
+                }
+            } else {
+                Err(Box::new(Error {
+                    message: format!("Request unsuccessful to {}: {:#?}", url, resp),
+                }))
+            }
+        }
+        Err(error) => Err(Box::new(Error {
+            message: format!("Error during request to {}: {:?}", url, error),
+        })),
+    }
 }
 
-fn get_real_ip() {
+fn get_current_record_ip(api_key: &str, name: &str, fqdn: &str) -> Result<Ipv4Addr> {
+    let json_value = request_livedns_gandi(
+        api_key,
+        &format!("domains/{}/records/{}/A", fqdn, name),
+        Method::Get,
+    )?;
 
+    match &json_value["rrset_values"][0] {
+        Value::String(ip_str) => Ok(ip_str.parse()?),
+        _ => Result::Err(Box::new(Error {
+            message: format!(
+                "Unable to extract the IP from the JSON answer: {}",
+                json_value
+            ),
+        })),
+    }
 }
 
-fn get_current_record_ip() {
+fn update_record_ip(api_key: &str, name: &str, fqdn: &str, ip: Ipv4Addr, ttl: i32) -> Result<()> {
+    let json_body = json!(
+        {
+            "rrset_values": [ format!("{}", ip) ],
+            "rrset_ttl": ttl
+        }
+    );
+
+    let json_value = request_livedns_gandi(
+        api_key,
+        &format!("domains/{}/records/{}/A", fqdn, name),
+        Method::Put(json_body.to_string()),
+    )?;
+
+    println!("Update response: {}", json_value);
 
+    Ok(())
 }
 
-fn update_record_ip() {
+enum Method {
+    Put(String),
+    Get,
+}
+
+fn request_livedns_gandi(api_key: &str, url_fragment: &str, method: Method) -> Result<Value> {
+    let url = format!("https://api.gandi.net/v5/livedns/{}", url_fragment);
+    let client = reqwest::blocking::Client::new();
+
+    let request_builder = match method {
+        Method::Put(body) => client.put(&url).body(body),
+        Method::Get => client.get(&url),
+    };
 
+    match request_builder
+        .header("Authorization", format!("Apikey {}", api_key))
+        .send()
+    {
+        Ok(resp) => {
+            if resp.status().is_success() {
+                let content = resp.text().unwrap();
+                Ok(serde_json::from_str(&content).unwrap())
+            } else {
+                Err(Box::new(Error {
+                    message: format!("Request unsuccessful to {}: {:#?}", &url, resp),
+                }))
+            }
+        }
+        Err(error) => Err(Box::new(Error {
+            message: format!("Error during request to {}: {:?}", &url, error),
+        })),
+    }
 }