.rustfmt.toml

@@ -1,2 +0,0 @@
-hard_tabs = false
-tab_spaces = 2

src/acme_actor.rs

@@ -1,72 +0,0 @@
-use anyhow::Result;
-use log::*;
-use tokio::{
-  select,
-  sync::watch,
-  time::{self, Duration},
-};
-
-use crate::config::RuntimeConfigAcme;
-use crate::messages;
-
-pub struct AcmeActor {
-  email: String,
-  //last_ports: messages::PublicExposedPorts,
-  refresh: Duration,
-
-  rx_ports: watch::Receiver<messages::PublicExposedPorts>,
-}
-
-impl AcmeActor {
-  pub async fn new(
-    config: Option<RuntimeConfigAcme>,
-    rxp: &watch::Receiver<messages::PublicExposedPorts>,
-  ) -> Result<Option<Self>> {
-    if config.is_none() {
-      return Ok(None);
-    }
-    let config = config.unwrap();
-
-    let ctx = Self {
-      email: config.email,
-      //last_ports: messages::PublicExposedPorts::new(),
-      refresh: config.refresh_time,
-      rx_ports: rxp.clone(),
-    };
-
-    Ok(Some(ctx))
-  }
-
-  pub async fn listen(&mut self) -> Result<()> {
-    let mut interval = time::interval(self.refresh);
-    loop {
-      select! {
-        Some(ports) = self.rx_ports.recv() => {
-          match self.do_acme(ports).await {
-            Ok(()) => debug!("Successfully updated ACME"),
-            Err(e) => error!("An error occured while updating ACME. {}", e),
-          }
-        },
-        _ = interval.tick() => continue,
-        else => break // Sender dropped, terminate loop.
-      }
-    }
-
-    Ok(())
-  }
-
-  pub async fn do_acme(&self, ports: messages::PublicExposedPorts) -> Result<()> {
-    if ports.acme.is_empty() {
-      return Ok(());
-    }
-
-    let primary_url = &ports.acme[0];
-    let secondary_urls = &ports.acme[1..];
-
-    println!("Doing ACME!!!");
-    println!("Primary URL: {:?}", primary_url);
-    println!("Secondary URLs: {:?}", secondary_urls);
-
-    Ok(())
-  }
-}

src/config/mod.rs

@@ -3,12 +3,8 @@ mod options;
 mod options_test;
 mod runtime;
 
-pub use options::{
+pub use options::{ConfigOpts, ConfigOptsConsul, ConfigOptsAcme, ConfigOptsFirewall, ConfigOptsIgd};
-  ConfigOpts, ConfigOptsAcme, ConfigOptsConsul, ConfigOptsFirewall, ConfigOptsIgd,
+pub use runtime::{RuntimeConfig, RuntimeConfigAcme, RuntimeConfigConsul, RuntimeConfigFirewall, RuntimeConfigIgd};
-};
-pub use runtime::{
-  RuntimeConfig, RuntimeConfigAcme, RuntimeConfigConsul, RuntimeConfigFirewall, RuntimeConfigIgd,
-};
 
 pub const EXPIRATION_TIME: u16 = 300;
 pub const REFRESH_TIME: u16 = 60;

src/config/options.rs

@@ -15,6 +15,7 @@ use crate::config::RuntimeConfig;
 // Only in runtime.rs would these options find their proper location in each 
 // module's struct.
 
+
 /// Consul configuration options
 #[derive(Clone, Default, Deserialize)]
 pub struct ConfigOptsConsul {
@@ -33,8 +34,6 @@ pub struct ConfigOptsAcme {
 
 	/// The default domain holder's e-mail [default: None]
 	pub email: Option<String>,
-  /// Refresh time for firewall rules [default: 300]
-  pub refresh_time: Option<u16>,
 }
 
 /// Firewall configuration options
@@ -89,13 +88,10 @@ impl ConfigOpts {
 	// Currently only used in tests
 	#[allow(dead_code)]
 	pub fn from_iter<Iter: Clone>(iter: Iter) -> Result<RuntimeConfig>
-  where
+	where Iter: IntoIterator<Item = (String, String)> {
-    Iter: IntoIterator<Item = (String, String)>,
-  {
 		let consul: ConfigOptsConsul = envy::prefixed("DIPLONAT_CONSUL_").from_iter(iter.clone())?;
 		let acme: ConfigOptsAcme = envy::prefixed("DIPLONAT_ACME_").from_iter(iter.clone())?;
-    let firewall: ConfigOptsFirewall =
+		let firewall: ConfigOptsFirewall = envy::prefixed("DIPLONAT_FIREWALL_").from_iter(iter.clone())?;
-      envy::prefixed("DIPLONAT_FIREWALL_").from_iter(iter.clone())?;
 		let igd: ConfigOptsIgd = envy::prefixed("DIPLONAT_IGD_").from_iter(iter.clone())?;
 
 		RuntimeConfig::new(Self {

src/config/options_test.rs

@@ -11,34 +11,19 @@ use crate::config::*;
 
 fn minimal_valid_options() -> HashMap<String, String> {
 	let mut opts = HashMap::new();
-  opts.insert(
+    opts.insert("DIPLONAT_CONSUL_NODE_NAME".to_string(), "consul_node".to_string());
-    "DIPLONAT_CONSUL_NODE_NAME".to_string(),
-    "consul_node".to_string(),
-  );
     opts
 }
 
 fn all_valid_options() -> HashMap<String, String> {
 	let mut opts = minimal_valid_options();
-  opts.insert(
+    opts.insert("DIPLONAT_CONSUL_URL".to_string(), "http://127.0.0.1:9999".to_string());
-    "DIPLONAT_CONSUL_URL".to_string(),
-    "http://127.0.0.1:9999".to_string(),
-  );
 	opts.insert("DIPLONAT_ACME_ENABLE".to_string(), "true".to_string());
-  opts.insert(
+	opts.insert("DIPLONAT_ACME_EMAIL".to_string(), "bozo@bozo.net".to_string());
-    "DIPLONAT_ACME_EMAIL".to_string(),
-    "bozo@bozo.net".to_string(),
-  );
 	opts.insert("DIPLONAT_FIREWALL_ENABLE".to_string(), "true".to_string());
-  opts.insert(
+	opts.insert("DIPLONAT_FIREWALL_REFRESH_TIME".to_string(), "20".to_string());
-    "DIPLONAT_FIREWALL_REFRESH_TIME".to_string(),
-    "20".to_string(),
-  );
 	opts.insert("DIPLONAT_IGD_ENABLE".to_string(), "true".to_string());
-  opts.insert(
+	opts.insert("DIPLONAT_IGD_PRIVATE_IP".to_string(), "172.123.43.555".to_string());
-    "DIPLONAT_IGD_PRIVATE_IP".to_string(),
-    "172.123.43.555".to_string(),
-  );
 	opts.insert("DIPLONAT_IGD_EXPIRATION_TIME".to_string(), "60".to_string());
 	opts.insert("DIPLONAT_IGD_REFRESH_TIME".to_string(), "10".to_string());
     opts
@@ -68,7 +53,10 @@ fn ok_minimal_valid_options() {
 		&rt_config.consul.node_name, 
 		opts.get(&"DIPLONAT_CONSUL_NODE_NAME".to_string()).unwrap()
 	);
-  assert_eq!(rt_config.consul.url, CONSUL_URL.to_string());
+	assert_eq!(
+		rt_config.consul.url, 
+		CONSUL_URL.to_string()
+	);
 	assert!(rt_config.acme.is_none());
 	assert!(rt_config.firewall.is_none());
 	assert!(rt_config.igd.is_none());
@@ -106,29 +94,17 @@ fn ok_all_valid_options() {
 	let rt_config = ConfigOpts::from_iter(opts.clone()).unwrap();
 
 	let firewall_refresh_time = Duration::from_secs(
-    opts
+		opts.get(&"DIPLONAT_FIREWALL_REFRESH_TIME".to_string()).unwrap()
-      .get(&"DIPLONAT_FIREWALL_REFRESH_TIME".to_string())
+			.parse::<u64>().unwrap()
-      .unwrap()
+			.into());
-      .parse::<u64>()
-      .unwrap()
-      .into(),
-  );
 	let igd_expiration_time = Duration::from_secs(
-    opts
+		opts.get(&"DIPLONAT_IGD_EXPIRATION_TIME".to_string()).unwrap()
-      .get(&"DIPLONAT_IGD_EXPIRATION_TIME".to_string())
+			.parse::<u64>().unwrap()
-      .unwrap()
+			.into());
-      .parse::<u64>()
-      .unwrap()
-      .into(),
-  );
 	let igd_refresh_time = Duration::from_secs(
-    opts
+		opts.get(&"DIPLONAT_IGD_REFRESH_TIME".to_string()).unwrap()
-      .get(&"DIPLONAT_IGD_REFRESH_TIME".to_string())
+			.parse::<u64>().unwrap()
-      .unwrap()
+			.into());
-      .parse::<u64>()
-      .unwrap()
-      .into(),
-  );
 
 	assert_eq!(
 		&rt_config.consul.node_name, 
@@ -143,12 +119,14 @@ fn ok_all_valid_options() {
 	let acme = rt_config.acme.unwrap();
 	assert_eq!(
 		&acme.email,
-    opts.get(&"DIPLONAT_ACME_EMAIL".to_string()).unwrap()
+		opts.get(&"DIPLONAT_ACME_EMAIL".to_string()).unwrap());
-  );
 
 	assert!(rt_config.firewall.is_some());
 	let firewall = rt_config.firewall.unwrap();
-  assert_eq!(firewall.refresh_time, firewall_refresh_time);
+	assert_eq!(
+		firewall.refresh_time,
+		firewall_refresh_time
+	);
 
 	assert!(rt_config.igd.is_some());
 	let igd = rt_config.igd.unwrap();
@@ -156,6 +134,12 @@ fn ok_all_valid_options() {
 		&igd.private_ip,
 		opts.get(&"DIPLONAT_IGD_PRIVATE_IP".to_string()).unwrap()
 	);
-  assert_eq!(igd.expiration_time, igd_expiration_time);
+	assert_eq!(
-  assert_eq!(igd.refresh_time, igd_refresh_time);
+		igd.expiration_time,
+		igd_expiration_time
+	);
+	assert_eq!(
+		igd.refresh_time,
+		igd_refresh_time
+	);
 }

src/config/runtime.rs

@@ -1,10 +1,8 @@
 use std::time::Duration;
 
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 
-use crate::config::{
+use crate::config::{ConfigOpts, ConfigOptsConsul, ConfigOptsAcme, ConfigOptsFirewall, ConfigOptsIgd};
-  ConfigOpts, ConfigOptsAcme, ConfigOptsConsul, ConfigOptsFirewall, ConfigOptsIgd,
-};
 
 // This code is inspired by the Trunk crate (https://github.com/thedodd/trunk)
 
@@ -22,7 +20,6 @@ pub struct RuntimeConfigConsul {
 #[derive(Debug)]
 pub struct RuntimeConfigAcme {
 	pub email: String,
-  pub refresh_time: Duration,
 }
 
 #[derive(Debug)]
@@ -63,12 +60,14 @@ impl RuntimeConfig {
 
 impl RuntimeConfigConsul {
 	pub(super) fn new(opts: ConfigOptsConsul) -> Result<Self> {
-    let node_name = opts
+		let node_name = opts.node_name.expect(
-      .node_name
+			"'DIPLONAT_CONSUL_NODE_NAME' is required");
-      .expect("'DIPLONAT_CONSUL_NODE_NAME' is required");
 		let url = opts.url.unwrap_or(super::CONSUL_URL.to_string());
 
-    Ok(Self { node_name, url })
+		Ok(Self {
+			node_name,
+			url,
+		})
 	}
 }
 
@@ -78,14 +77,11 @@ impl RuntimeConfigAcme {
 			return Ok(None);
 		}
 
-    let email = opts
+		let email = opts.email.expect(
-      .email
+			"'DIPLONAT_ACME_EMAIL' is required if ACME is enabled");
-      .expect("'DIPLONAT_ACME_EMAIL' is required if ACME is enabled");
-    let refresh_time = Duration::from_secs(opts.refresh_time.unwrap_or(super::REFRESH_TIME).into());
 
 		Ok(Some(Self {
 			email,
-      refresh_time,
 		}))
 	}
 }
@@ -96,9 +92,12 @@ impl RuntimeConfigFirewall {
 			return Ok(None);
 		}
 
-    let refresh_time = Duration::from_secs(opts.refresh_time.unwrap_or(super::REFRESH_TIME).into());
+		let refresh_time = Duration::from_secs(
+				opts.refresh_time.unwrap_or(super::REFRESH_TIME).into());
 
-    Ok(Some(Self { refresh_time }))
+		Ok(Some(Self {
+			refresh_time,
+		}))
 	}
 }
 
@@ -108,16 +107,12 @@ impl RuntimeConfigIgd {
 			return Ok(None);
 		}
 
-    let private_ip = opts
+		let private_ip = opts.private_ip.expect(
-      .private_ip
+			"'DIPLONAT_IGD_PRIVATE_IP' is required if IGD is enabled");
-      .expect("'DIPLONAT_IGD_PRIVATE_IP' is required if IGD is enabled");
 		let expiration_time = Duration::from_secs(
-      opts
+				opts.expiration_time.unwrap_or(super::EXPIRATION_TIME).into());
-        .expiration_time
+		let refresh_time = Duration::from_secs(
-        .unwrap_or(super::EXPIRATION_TIME)
+				opts.refresh_time.unwrap_or(super::REFRESH_TIME).into());
-        .into(),
-    );
-    let refresh_time = Duration::from_secs(opts.refresh_time.unwrap_or(super::REFRESH_TIME).into());
 
 		if refresh_time.as_secs() * 2 > expiration_time.as_secs() {
 	      return Err(anyhow!(

src/consul.rs

@@ -1,22 +1,22 @@
 use std::collections::HashMap;
 
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
-use serde::{Deserialize, Serialize};
+use serde::{Serialize, Deserialize};
 
 #[derive(Serialize, Deserialize, Debug)]
 pub struct ServiceEntry {
-  pub Tags: Vec<String>,
+  pub Tags: Vec<String>
 }
 
 #[derive(Serialize, Deserialize, Debug)]
 pub struct CatalogNode {
-  pub Services: HashMap<String, ServiceEntry>,
+  pub Services: HashMap<String, ServiceEntry>
 }
 
 pub struct Consul {
   client: reqwest::Client,
   url: String,
-  idx: Option<u64>,
+  idx: Option<u64>
 }
 
 impl Consul {
@@ -24,7 +24,7 @@ impl Consul {
     return Self {
       client: reqwest::Client::new(),
       url: url.to_string(),
-      idx: None,
+      idx: None
     };
   }
 
@@ -35,16 +35,16 @@ impl Consul {
   pub async fn watch_node(&mut self, host: &str) -> Result<CatalogNode> {
     let url = match self.idx {
       Some(i) => format!("{}/v1/catalog/node/{}?index={}", self.url, host, i),
-      None => format!("{}/v1/catalog/node/{}", self.url, host),
+      None => format!("{}/v1/catalog/node/{}", self.url, host)
     };
 
     let http = self.client.get(&url).send().await?;
     self.idx = match http.headers().get("X-Consul-Index") {
       Some(v) => Some(v.to_str()?.parse::<u64>()?),
-      None => return Err(anyhow!("X-Consul-Index header not found")),
+      None => return Err(anyhow!("X-Consul-Index header not found"))
     };
 
     let resp: CatalogNode = http.json().await?;
-    return Ok(resp);
+    return Ok(resp)
   }
 }

src/consul_actor.rs

@@ -4,8 +4,8 @@ use std::time::Duration;
 
 use anyhow::Result;
 use log::*;
-use serde::{Deserialize, Serialize};
+use serde::{Serialize, Deserialize};
-use serde_lexpr::{error, from_str};
+use serde_lexpr::{from_str,error};
 use tokio::sync::watch;
 use tokio::time::delay_for;
 
@@ -14,16 +14,14 @@ use crate::consul;
 use crate::messages;
 
 #[derive(Serialize, Deserialize, Debug)]
-#[serde(rename_all = "snake_case")]
 pub enum DiplonatParameter {
-  TcpPort(HashSet<u16>),
+  tcp_port(HashSet<u16>),
-  UdpPort(HashSet<u16>),
+  udp_port(HashSet<u16>)
-  Acme(Vec<String>),
 }
 
 #[derive(Serialize, Deserialize, Debug)]
 pub enum DiplonatConsul {
-  diplonat(Vec<DiplonatParameter>),
+  diplonat(Vec<DiplonatParameter>)
 }
 
 pub struct ConsulActor {
@@ -33,16 +31,13 @@ pub struct ConsulActor {
   node: String,
   retries: u32,
 
-  tx_open_ports: watch::Sender<messages::PublicExposedPorts>,
+  tx_open_ports: watch::Sender<messages::PublicExposedPorts>
 }
 
 fn retry_to_time(retries: u32, max_time: Duration) -> Duration {
   // 1.2^x seems to be a good value to exponentially increase time at a good pace
   // eg. 1.2^32 = 341 seconds ~= 5 minutes - ie. after 32 retries we wait 5 minutes
-  return Duration::from_secs(cmp::min(
+  return Duration::from_secs(cmp::min(max_time.as_secs(), 1.2f64.powf(retries as f64) as u64))
-    max_time.as_secs(),
-    1.2f64.powf(retries as f64) as u64,
-  ));
 }
 
 fn to_parameters(catalog: &consul::CatalogNode) -> Vec<DiplonatConsul> {
@@ -62,15 +57,17 @@ fn to_parameters(catalog: &consul::CatalogNode) -> Vec<DiplonatConsul> {
 }
 
 fn to_open_ports(params: &Vec<DiplonatConsul>) -> messages::PublicExposedPorts {
-  let mut op = messages::PublicExposedPorts::new();
+  let mut op = messages::PublicExposedPorts { 
+    tcp_ports: HashSet::new(),
+    udp_ports: HashSet::new()
+  };
 
   for conf in params {
     let DiplonatConsul::diplonat(c) = conf;
     for parameter in c {
       match parameter {
-        DiplonatParameter::TcpPort(p) => op.tcp_ports.extend(p),
+        DiplonatParameter::tcp_port(p) => op.tcp_ports.extend(p),
-        DiplonatParameter::UdpPort(p) => op.udp_ports.extend(p),
+        DiplonatParameter::udp_port(p) => op.udp_ports.extend(p),
-        DiplonatParameter::Acme(urls) => op.acme.extend_from_slice(urls.as_slice()),
       };
     }
   }
@@ -80,7 +77,10 @@ fn to_open_ports(params: &Vec<DiplonatConsul>) -> messages::PublicExposedPorts {
 
 impl ConsulActor {
   pub fn new(config: RuntimeConfigConsul) -> Self {
-    let (tx, rx) = watch::channel(messages::PublicExposedPorts::new());
+    let (tx, rx) = watch::channel(messages::PublicExposedPorts{
+      tcp_ports: HashSet::new(),
+      udp_ports: HashSet::new()
+    });
 
     return Self {
       consul: consul::Consul::new(&config.url),
@@ -99,18 +99,14 @@ impl ConsulActor {
           self.consul.watch_node_reset();
           self.retries = cmp::min(std::u32::MAX - 1, self.retries) + 1;
           let will_retry_in = retry_to_time(self.retries, Duration::from_secs(600));
-          error!(
+          error!("Failed to query consul. Will retry in {}s. {}", will_retry_in.as_secs(), e);
-            "Failed to query consul. Will retry in {}s. {}",
-            will_retry_in.as_secs(),
-            e
-          );
           delay_for(will_retry_in).await;
           continue;
         }
       };
       self.retries = 0;
       let msg = to_open_ports(&to_parameters(&catalog));
-      debug!("Extracted configuration:\n{:#?}", msg);
+      debug!("Extracted configuration: {:#?}", msg);
 
       self.tx_open_ports.broadcast(msg)?;
     }

src/consul_kv.rs

@@ -1,41 +0,0 @@
-use anyhow::{anyhow, Result};
-
-pub struct ConsulKV {
-  client: reqwest::Client,
-  url: String,
-}
-
-impl ConsulKV {
-  pub fn new(url: &str) -> Self {
-    Self {
-      client: reqwest::Client::new(),
-      url: url.to_string(),
-    }
-  }
-
-  pub async fn get_string(&self, key: &str) -> Result<String> {
-    let url = format!("{}/v1/kv/{}?raw", self.url, key);
-
-    let resp = self.client.get(&url).send().await?;
-
-    if resp.status() != reqwest::StatusCode::OK {
-      return Err(anyhow!("{} returned {}", url, resp.status()));
-    }
-
-    match resp.text().await {
-      Ok(s) => Ok(s),
-      Err(e) => Err(anyhow!("{}", e)),
-    }
-  }
-
-  pub async fn put_string(&self, key: &str, value: String) -> Result<()> {
-    let url = format!("{}/v1/kv/{}", self.url, key);
-
-    let resp = self.client.put(&url).body(value).send().await?;
-
-    match resp.status() {
-      reqwest::StatusCode::OK => Ok(()),
-      s => Err(anyhow!("{} returned {}", url, s)),
-    }
-  }
-}

src/diplonat.rs

@@ -1,8 +1,6 @@
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
-use log::debug;
 use tokio::try_join;
 
-use crate::acme_actor::AcmeActor;
 use crate::config::ConfigOpts;
 use crate::consul_actor::ConsulActor;
 use crate::fw_actor::FirewallActor;
@@ -11,7 +9,6 @@ use crate::igd_actor::IgdActor;
 pub struct Diplonat {
   consul: ConsulActor,
 
-  acme: Option<AcmeActor>,
   firewall: Option<FirewallActor>,
   igd: Option<IgdActor>,
 }
@@ -19,25 +16,27 @@ pub struct Diplonat {
 impl Diplonat {
   pub async fn new() -> Result<Self> {
     let config = ConfigOpts::from_env()?;
-    debug!("{:#?}", config);
+    println!("{:#?}", config);
     
     let consul_actor = ConsulActor::new(config.consul);
 
-    let acme_actor = AcmeActor::new(config.acme, &consul_actor.rx_open_ports).await?;
+    let firewall_actor = FirewallActor::new(
+        config.firewall,
+        &consul_actor.rx_open_ports
+    ).await?;
     
-    let firewall_actor = FirewallActor::new(config.firewall, &consul_actor.rx_open_ports).await?;
+    let igd_actor = IgdActor::new(
+      config.igd,
+      &consul_actor.rx_open_ports
+    ).await?;
 
-    let igd_actor = IgdActor::new(config.igd, &consul_actor.rx_open_ports).await?;
+    if firewall_actor.is_none() && igd_actor.is_none() {
-
-    if acme_actor.is_none() && firewall_actor.is_none() && igd_actor.is_none() {
       return Err(anyhow!(
-        "At least enable *one* module, otherwise it's boring!"
+        "At least enable *one* module, otherwise it's boring!"));
-      ));
     }
 
     let ctx = Self {
       consul: consul_actor,
-      acme: acme_actor,
       firewall: firewall_actor,
       igd: igd_actor,
     };
@@ -46,28 +45,21 @@ impl Diplonat {
   }
 
   pub async fn listen(&mut self) -> Result<()> {
-    let acme = &mut self.acme;
     let firewall = &mut self.firewall;
     let igd = &mut self.igd;
 
     try_join!(
       self.consul.listen(),
-      async {
-        match acme {
-          Some(x) => x.listen().await,
-          None => Ok(()),
-        }
-      },
       async {
         match firewall {
           Some(x) => x.listen().await,
-          None => Ok(()),
+          None => Ok(())
         }
       },
       async {
         match igd {
           Some(x) => x.listen().await,
-          None => Ok(()),
+          None => Ok(())
         }
       },
     )?;

src/fw.rs

@@ -1,6 +1,6 @@
-// use std::collections::HashSet;
+use std::collections::HashSet;
 
-use anyhow::{Context, Result};
+use anyhow::{Result,Context};
 use iptables;
 use log::*;
 use regex::Regex;
@@ -8,58 +8,43 @@ use regex::Regex;
 use crate::messages;
 
 pub fn setup(ipt: &iptables::IPTables) -> Result<()> {
+
     // ensure we start from a clean state without any rule already set
     cleanup(ipt)?;
     
-  ipt
+    ipt.new_chain("filter", "DIPLONAT").context("Failed to create new chain")?;
-    .new_chain("filter", "DIPLONAT")
+    ipt.insert_unique("filter", "INPUT", "-j DIPLONAT", 1).context("Failed to insert jump rule")?;
-    .context("Failed to create new chain")?;
-  ipt
-    .insert_unique("filter", "INPUT", "-j DIPLONAT", 1)
-    .context("Failed to insert jump rule")?;
 
     Ok(())
 }
 
 pub fn open_ports(ipt: &iptables::IPTables, ports: messages::PublicExposedPorts) -> Result<()> {
     for p in ports.tcp_ports {
-    ipt
+        ipt.append("filter", "DIPLONAT", &format!("-p tcp --dport {} -j ACCEPT", p)).context("Failed to insert port rule")?;
-      .append(
-        "filter",
-        "DIPLONAT",
-        &format!("-p tcp --dport {} -j ACCEPT", p),
-      )
-      .context("Failed to insert port rule")?;
     }
 
     for p in ports.udp_ports {
-    ipt
+        ipt.append("filter", "DIPLONAT", &format!("-p udp --dport {} -j ACCEPT", p)).context("Failed to insert port rule")?;
-      .append(
-        "filter",
-        "DIPLONAT",
-        &format!("-p udp --dport {} -j ACCEPT", p),
-      )
-      .context("Failed to insert port rule")?;
     }
 
     Ok(())
 }
 
 pub fn get_opened_ports(ipt: &iptables::IPTables) -> Result<messages::PublicExposedPorts> {
-  let mut ports = messages::PublicExposedPorts::new();
+    let mut ports = messages::PublicExposedPorts {
-  // let mut ports = messages::PublicExposedPorts {
+        tcp_ports: HashSet::new(),
-  //     tcp_ports: HashSet::new(),
+        udp_ports: HashSet::new()
-  //     udp_ports: HashSet::new()
+    };
-  // };
 
     let list = ipt.list("filter", "DIPLONAT")?;
-  let re = Regex::new(r"\-A.*? \-p (\w+).*\-\-dport (\d+).*?\-j ACCEPT")
+    let re = Regex::new(r"\-A.*? \-p (\w+).*\-\-dport (\d+).*?\-j ACCEPT").context("Regex matching open ports encountered an unexpected rule")?;
-    .context("Regex matching open ports encountered an unexpected rule")?;
     for i in list {
         let caps = re.captures(&i);
         match caps {
             Some(c) => {
+           
                 if let (Some(raw_proto), Some(raw_port)) = (c.get(1), c.get(2)) {
+
                     let proto = String::from(raw_proto.as_str());
                     let number = String::from(raw_port.as_str()).parse::<u16>()?;
 
@@ -68,10 +53,12 @@ pub fn get_opened_ports(ipt: &iptables::IPTables) -> Result<messages::PublicExpo
                     } else {
                         ports.udp_ports.insert(number);
                     }
+
                 } else {
                     error!("Unexpected rule found in DIPLONAT chain")
                 }
-      }
+
+            },
             _ => {}
         }
     }
@@ -80,21 +67,17 @@ pub fn get_opened_ports(ipt: &iptables::IPTables) -> Result<messages::PublicExpo
 }
 
 pub fn cleanup(ipt: &iptables::IPTables) -> Result<()> {
+    
     if ipt.chain_exists("filter", "DIPLONAT")? {
-    ipt
+        ipt.flush_chain("filter", "DIPLONAT").context("Failed to flush the DIPLONAT chain")?;
-      .flush_chain("filter", "DIPLONAT")
-      .context("Failed to flush the DIPLONAT chain")?;
     
         if ipt.exists("filter", "INPUT", "-j DIPLONAT")? {
-      ipt
+            ipt.delete("filter", "INPUT", "-j DIPLONAT").context("Failed to delete jump rule")?;
-        .delete("filter", "INPUT", "-j DIPLONAT")
-        .context("Failed to delete jump rule")?;
         }
     
-    ipt
+        ipt.delete_chain("filter", "DIPLONAT").context("Failed to delete chain")?;
-      .delete_chain("filter", "DIPLONAT")
-      .context("Failed to delete chain")?;
     }
 
     Ok(())
 }
+

src/fw_actor.rs

@@ -6,13 +6,16 @@ use log::*;
 use tokio::{
   select, 
   sync::watch, 
-  time::{self, Duration},
+  time::{
-};
+    Duration,
+    self, 
+}};
 
 use crate::config::RuntimeConfigFirewall;
 use crate::fw;
 use crate::messages;
 
+
 pub struct FirewallActor {
   pub ipt: iptables::IPTables,
 
@@ -23,10 +26,7 @@ pub struct FirewallActor {
 }
 
 impl FirewallActor {
-  pub async fn new(
+  pub async fn new(config: Option<RuntimeConfigFirewall>, rxp: &watch::Receiver<messages::PublicExposedPorts>) -> Result<Option<Self>> {
-    config: Option<RuntimeConfigFirewall>,
-    rxp: &watch::Receiver<messages::PublicExposedPorts>,
-  ) -> Result<Option<Self>> {
     if config.is_none() {
       return Ok(None);
     }
@@ -55,9 +55,7 @@ impl FirewallActor {
       };
 
       // 2. Update last ports if needed
-      if let Some(p) = new_ports {
+      if let Some(p) = new_ports { self.last_ports = p; }
-        self.last_ports = p;
-      }
 
       // 3. Update firewall rules
       match self.do_fw_update().await {
@@ -70,27 +68,18 @@ impl FirewallActor {
   pub async fn do_fw_update(&self) -> Result<()> {
     let curr_opened_ports = fw::get_opened_ports(&self.ipt)?;
 
-    let diff_tcp = self
+    let diff_tcp = self.last_ports.tcp_ports.difference(&curr_opened_ports.tcp_ports).copied().collect::<HashSet<u16>>();
-      .last_ports
+    let diff_udp = self.last_ports.udp_ports.difference(&curr_opened_ports.udp_ports).copied().collect::<HashSet<u16>>();
-      .tcp_ports
-      .difference(&curr_opened_ports.tcp_ports)
-      .copied()
-      .collect::<HashSet<u16>>();
-    let diff_udp = self
-      .last_ports
-      .udp_ports
-      .difference(&curr_opened_ports.udp_ports)
-      .copied()
-      .collect::<HashSet<u16>>();
 
     let ports_to_open = messages::PublicExposedPorts {
         tcp_ports: diff_tcp,
-      udp_ports: diff_udp,
+        udp_ports: diff_udp
-      acme: Vec::new(),
     };
 
     fw::open_ports(&self.ipt, ports_to_open)?;
 
     return Ok(());
   }
+
 }
+

src/igd_actor.rs

@@ -1,14 +1,16 @@
 use std::net::SocketAddrV4;
 
-use anyhow::{Context, Result};
+use anyhow::{Result, Context};
 use igd::aio::*;
 use igd::PortMappingProtocol;
 use log::*;
 use tokio::{
   select, 
   sync::watch, 
-  time::{self, Duration},
+  time::{
-};
+    Duration,
+    self, 
+}};
 
 use crate::config::RuntimeConfigIgd;
 use crate::messages;
@@ -24,10 +26,7 @@ pub struct IgdActor {
 }
 
 impl IgdActor {
-  pub async fn new(
+  pub async fn new(config: Option<RuntimeConfigIgd>, rxp: &watch::Receiver<messages::PublicExposedPorts>) -> Result<Option<Self>> {
-    config: Option<RuntimeConfigIgd>,
-    rxp: &watch::Receiver<messages::PublicExposedPorts>,
-  ) -> Result<Option<Self>> {
     if config.is_none() {
       return Ok(None);
     }
@@ -61,9 +60,7 @@ impl IgdActor {
       };
 
       // 2. Update last ports if needed
-      if let Some(p) = new_ports {
+      if let Some(p) = new_ports { self.last_ports = p; }
-        self.last_ports = p;
-      }
 
       // 3. Flush IGD requests
       match self.do_igd().await {
@@ -76,25 +73,14 @@ impl IgdActor {
   pub async fn do_igd(&self) -> Result<()> {
     let actions = [
       (PortMappingProtocol::TCP, &self.last_ports.tcp_ports), 
-      (PortMappingProtocol::UDP, &self.last_ports.udp_ports),
+      (PortMappingProtocol::UDP, &self.last_ports.udp_ports)
     ];
 
     for (proto, list) in actions.iter() {
       for port in *list {
         let service_str = format!("{}:{}", self.private_ip, port);
-        let service = service_str
+        let service  = service_str.parse::<SocketAddrV4>().context("Invalid socket address")?;
-          .parse::<SocketAddrV4>()
+        self.gateway.add_port(*proto, *port, service, self.expire.as_secs() as u32, "diplonat").await?;
-          .context("Invalid socket address")?;
-        self
-          .gateway
-          .add_port(
-            *proto,
-            *port,
-            service,
-            self.expire.as_secs() as u32,
-            "diplonat",
-          )
-          .await?;
         debug!("IGD request successful for {:#?} {}", proto, service);
       }
     }

src/main.rs

@@ -1,16 +1,14 @@
-mod acme_actor;
 mod config;
 mod consul;
 mod consul_actor;
-mod consul_kv;
 mod diplonat;
 mod fw;
 mod fw_actor;
 mod igd_actor;
 mod messages;
 
-use diplonat::Diplonat;
 use log::*;
+use diplonat::Diplonat;
 
 #[tokio::main]
 async fn main() {

src/messages.rs

@@ -3,16 +3,14 @@ use std::collections::HashSet;
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct PublicExposedPorts {
   pub tcp_ports: HashSet<u16>,
-  pub udp_ports: HashSet<u16>,
+  pub udp_ports: HashSet<u16>
-  pub acme: Vec<String>,
 }
 
 impl PublicExposedPorts {
   pub fn new() -> Self {
     return Self {
       tcp_ports: HashSet::new(),
-      udp_ports: HashSet::new(),
+      udp_ports: HashSet::new()
-      acme: Vec::new(),
+    }
-    };
   }
 }