Do not display api_key in the log.
[gandi_dns_update.git] / src / main.rs
1 /*
2 * API Reference: https://api.gandi.net/docs/livedns/
3 * Some similar implementations:
4 * - https://github.com/rmarchant/gandi-ddns/blob/master/gandi_ddns.py
5 * - https://github.com/brianhp2/gandi-automatic-dns
6 *
7 * TODO:
8 * - Log to stdout with (at least) timestamps.
9 * - Renew function.
10 */
11
12 #![cfg_attr(debug_assertions, allow(unused_variables, unused_imports, dead_code))]
13
14 use std::{ fmt::format, fs::File, net::{ IpAddr, Ipv4Addr }, thread, time };
15 use ron::{ de::from_reader, ser::to_writer };
16 use serde::{ Deserialize, Serialize };
17 use serde_json::{ Value, json };
18
19 // A generic result of type 'T'.
20 type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
21
22 #[derive(Debug)]
23 struct Error {
24 message: String
25 }
26
27 impl std::fmt::Display for Error {
28 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
29 write!(f, "Error: {}", &self.message)
30 }
31 }
32
33 impl std::error::Error for Error { }
34
35 #[derive(Debug, Clone, Deserialize, Serialize)]
36 struct Config {
37 delay_between_check: time::Duration,
38 api_key: String,
39 fqdn: String,
40 domains: Vec<String>,
41 ttl: i32
42 }
43
44 impl Config {
45 fn default() -> Self {
46 Config { delay_between_check: time::Duration::from_secs(120), api_key: String::from(""), fqdn: String::from(""), domains: Vec::new(), ttl: 300 }
47 }
48
49 fn read(file_path: &str) -> Result<Config> {
50 match File::open(file_path) {
51 Ok(file) => from_reader(file).map_err(|e| e.into()),
52 // The file doesn't exit -> create it with default values.
53 Err(_) => {
54 let file = File::create(file_path)?;
55 let default_config = Config::default();
56 to_writer(file, &default_config)?;
57 Ok(default_config)
58 }
59 }
60 }
61 }
62
63 const FILE_CONF: &str = "config.ron";
64
65 fn main() -> Result<()> {
66
67 println!("GANDI DynDNS");
68
69 let config = Config::read(FILE_CONF)?;
70
71 println!("Configuration: {:?}", Config { api_key: String::from("*****"), ..config.clone() });
72
73 loop {
74 let time_beginning_loop = time::Instant::now();
75
76 if let Err(err) = check_and_update_dns(&config.api_key, &config.fqdn, &config.domains, config.ttl) {
77 println!("!! Error: {}", err);
78 }
79
80 let elapsed = time::Instant::now() - time_beginning_loop;
81
82 if elapsed < config.delay_between_check {
83 let to_wait = config.delay_between_check - elapsed;
84 thread::sleep(to_wait);
85 }
86 }
87 }
88
89 fn check_and_update_dns(api_key: &str, fqdn: &str, domains: &Vec<String>, ttl: i32) -> Result<()> {
90 let real_ip = get_real_ip()?;
91 dbg!(&real_ip);
92
93 for domain in domains {
94 let current_ip = get_current_record_ip(api_key, domain, fqdn)?;
95 dbg!(domain, current_ip);
96
97 if real_ip != current_ip {
98 println!("IP addresses don't match for domain {}: real = {}, dns = {}. Renewing DNS...", domain, real_ip, current_ip);
99 update_record_ip(api_key, domain, fqdn, real_ip, ttl)?;
100 println!("Renewing of {} successfully", domain);
101 }
102 }
103
104 Ok(())
105 }
106
107 fn get_real_ip() -> Result<Ipv4Addr> {
108
109 let url = "https://api.ipify.org";
110 let client = reqwest::blocking::Client::new();
111
112 match client.get(url).send() {
113 Ok(resp) =>
114 if resp.status().is_success() {
115 let content = resp.text().unwrap();
116 match content.parse::<IpAddr>() {
117 Ok(IpAddr::V4(ip_v4)) => Ok(ip_v4),
118 _ => Err(Box::new(Error { message: String::from("Can't parse IPv4 from ipify") }))
119 }
120 } else {
121 Err(Box::new(Error { message: format!("Request unsuccessful: {:#?}", resp) }))
122 },
123
124 Err(error) => {
125 Err(Box::new(Error { message: format!("Error during request: {:?}", error) }))
126 }
127 }
128 }
129
130 enum Method {
131 Put(String),
132 Get
133 }
134
135 fn request_livedns_gandi(api_key: &str, url_fragment: &str, method: Method) -> Result<Value> {
136 let url = format!("https://api.gandi.net/v5/livedns/{}", url_fragment);
137 let client = reqwest::blocking::Client::new();
138
139 let request_builder =
140 match method {
141 Method::Put(body) => client.put(url).body(body),
142 Method::Get => client.get(url)
143 };
144
145 match request_builder.header("Authorization", format!("Apikey {}", api_key)).send() {
146 Ok(resp) =>
147 if resp.status().is_success() {
148 let content = resp.text().unwrap();
149 Ok(serde_json::from_str(&content).unwrap())
150 } else {
151 Err(Box::new(Error { message: format!("Request unsuccessful: {:#?}", resp) }))
152 },
153 Err(error) =>
154 Err(Box::new(Error { message: format!("Error during request: {:?}", error) }))
155 }
156 }
157
158 fn get_current_record_ip(api_key: &str, name: &str, fqdn: &str) -> Result<Ipv4Addr> {
159 let json_value = request_livedns_gandi(api_key, &format!("domains/{}/records/{}/A", fqdn, name), Method::Get)?;
160
161 match &json_value["rrset_values"][0] {
162 Value::String(ip_str) =>
163 Ok(ip_str.parse()?),
164 _ =>
165 Result::Err(Box::new(Error { message: format!("Unable to extract the IP from the JSON answer: {}", json_value) }))
166 }
167 }
168
169 fn update_record_ip(api_key: &str, name: &str, fqdn: &str, ip: Ipv4Addr, ttl: i32) -> Result<()> {
170 let json_body =
171 json!(
172 {
173 "rrset_values": [ format!("{}", ip) ],
174 "rrset_ttl": ttl
175 }
176 );
177
178 let json_value = request_livedns_gandi(api_key, &format!("domains/{}/records/{}/A", fqdn, name), Method::Put(json_body.to_string()))?;
179
180 dbg!(json_value);
181
182 Ok(())
183 }