conf -> wg_conf

1 files changed, 33 insertions, 33 deletions

diff --git a/src/main.rs b/src/main.rs
index 05b05a2..6bc7e85 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -18,7 +18,7 @@ fn main() {
     let matches = command!()
         .arg(
             arg!(
-                -c --config <CONFIG> "Configuration file name"
+                -w --wg-config <WGCONFIG> "Wireguard configuration file name"
             )
             .required(false)
         )
@@ -80,18 +80,18 @@ fn main() {
         )
         .get_matches();
 
-    let conf_path = match find_config_file(&matches) {
+    let wg_conf_path = match find_wg_config_file(&matches) {
         Ok(s) => s,
         Err(e) => {
-            eprintln!("Configuration file error: {}", e);
+            eprintln!("Wireguard configuration file error: {}", e);
             exit(1);
         }
     };
 
-    let mut conf = match wg::config::WireguardConfig::new(&conf_path) {
+    let mut wg_conf = match wg::config::WireguardConfig::new(&wg_conf_path) {
         Ok(c) => c,
         Err(e) => {
-            eprintln!("Error loading the configuration file '{}'", conf_path);
+            eprintln!("Error loading the Wireguard configuration file '{}'", wg_conf_path);
             eprintln!("{}", e);
             exit(1);
         }
@@ -99,7 +99,7 @@ fn main() {
 
     match matches.subcommand() {
         Some(("ls", _)) => {
-            do_list(&conf);
+            do_list(&wg_conf);
         }
 
         Some(("config", args)) => {
@@ -119,7 +119,7 @@ fn main() {
                         None => false
                     };
 
-                    if let Err(e) = do_config(&conf, peer_name.to_string(), is_full) {
+                    if let Err(e) = do_config(&wg_conf, peer_name.to_string(), is_full) {
                         eprintln!("Error generating configuration for {}: {}", peer_name.to_string(), e);
                         exit(1);
                     }
@@ -130,7 +130,7 @@ fn main() {
 
         Some(("add", args)) => {
             let new_name = args.get_one::<String>("NAME").unwrap().to_string();
-            if let Err(e) = do_add(&mut conf, conf_path, &new_name, args.get_one::<String>("ip")) {
+            if let Err(e) = do_add(&mut wg_conf, wg_conf_path, &new_name, args.get_one::<String>("ip")) {
                 eprintln!("Error adding peer: {}", e);
                 exit(1);
             }
@@ -141,7 +141,7 @@ fn main() {
 
         Some(("rm", args)) => {
             let rm_name = args.get_one::<String>("NAME").unwrap().to_string();
-            if let Err(e) = do_rm(&mut conf, conf_path, &rm_name) {
+            if let Err(e) = do_rm(&mut wg_conf, wg_conf_path, &rm_name) {
                 eprintln!("Error removing peer: {}", e);
                 exit(1);
             }
@@ -150,7 +150,7 @@ fn main() {
         },
 
         Some(("wg", _)) => {
-            if let Err(e) = do_wg(&conf) {
+            if let Err(e) = do_wg(&wg_conf) {
                 eprintln!("{}", e);
                 exit(1);
             }
@@ -163,9 +163,9 @@ fn main() {
 
 }
 
-fn find_config_file(matches: &ArgMatches) -> Result<String> {
+fn find_wg_config_file(matches: &ArgMatches) -> Result<String> {
     // Top priority goes to the command-line argument
-    match matches.get_one::<String>("config") {
+    match matches.get_one::<String>("wg-config") {
         Some(s) => {
             if s.starts_with("/") {
                 return Ok(s.to_string())
@@ -220,39 +220,39 @@ fn find_config_file(matches: &ArgMatches) -> Result<String> {
     }
 }
 
-fn do_list(conf: &wg::config::WireguardConfig) {
+fn do_list(wg_conf: &wg::config::WireguardConfig) {
     let mut max_length = 0;
-    for p in conf.peers.iter() {
+    for p in wg_conf.peers.iter() {
         if p.name.len() > max_length {
             max_length = p.name.len();
         }
     }
 
-    for p in conf.peers.iter() {
+    for p in wg_conf.peers.iter() {
         println!("{:max_length$} | {}", p.name, p.ip);
     }
 }
 
-fn do_config(conf: &wg::config::WireguardConfig, peer_name: String, is_full: bool) -> Result<()> {
-    let peer = match conf.get_peer(peer_name.as_str()) {
+fn do_config(wg_conf: &wg::config::WireguardConfig, peer_name: String, is_full: bool) -> Result<()> {
+    let peer = match wg_conf.get_peer(peer_name.as_str()) {
         Some(p) => p,
         None => {
             return Err(anyhow!("No such peer: {}", peer_name));
         }
     };
 
-    println!("{}", peer.gen_config(conf, is_full)?);
+    println!("{}", peer.gen_config(wg_conf, is_full)?);
 
     Ok(())
 }
 
-fn do_add(conf: &mut WireguardConfig, conf_path: String, peer_name: &String, ip: Option<&String>) -> Result<()> {
+fn do_add(wg_conf: &mut WireguardConfig, wg_conf_path: String, peer_name: &String, ip: Option<&String>) -> Result<()> {
     let ip = match ip {
         Some(s) => {
             Ipv4Addr::from_str(s.as_str())?
         },
         None => {
-            match conf.next_free_ip() {
+            match wg_conf.next_free_ip() {
                 Ok(i) => i,
                 Err(e) => {
                     return Err(e);
@@ -261,26 +261,26 @@ fn do_add(conf: &mut WireguardConfig, conf_path: String, peer_name: &String, ip:
         }
     };
 
-    match conf.get_peer(peer_name.as_str()) {
+    match wg_conf.get_peer(peer_name.as_str()) {
         Some(_) => { return Err(anyhow!("There is already a peer named {}", peer_name)); },
         None => {}
     }
 
     let p = wg::peer::Peer::new(peer_name.clone(), ip)?;
-    conf.peers.push(p);
+    wg_conf.peers.push(p);
 
-    let mut f = File::create(conf_path)?;
-    write!(f, "{}", conf.gen_config()?)?;
+    let mut f = File::create(wg_conf_path)?;
+    write!(f, "{}", wg_conf.gen_config()?)?;
 
     Ok(())
 }
 
-fn do_rm(conf: &mut WireguardConfig, conf_path: String, peer_name: &String) -> Result<()> {
+fn do_rm(wg_conf: &mut WireguardConfig, wg_conf_path: String, peer_name: &String) -> Result<()> {
     let mut del_index = 0;
     let mut found = false;
     let mut pk_path = String::new();
 
-    for (i, peer) in conf.peers.iter().enumerate() {
+    for (i, peer) in wg_conf.peers.iter().enumerate() {
         if &peer.name == peer_name {
             del_index = i;
             found = true;
@@ -293,19 +293,19 @@ fn do_rm(conf: &mut WireguardConfig, conf_path: String, peer_name: &String) -> R
         return Err(anyhow!("No such peer: {}", peer_name));
     }
 
-    conf.peers.remove(del_index);
+    wg_conf.peers.remove(del_index);
 
-    let mut f = File::create(conf_path.clone()).context(format!("error opening configuration file: {}", conf_path))?;
-    let data = conf.gen_config().context("error generating configuration")?;
+    let mut f = File::create(wg_conf_path.clone()).context(format!("error opening configuration file: {}", wg_conf_path))?;
+    let data = wg_conf.gen_config().context("error generating configuration")?;
 
-    f.write_all(data.as_bytes()).context(format!("error writing to file: {}", conf_path))?;
+    f.write_all(data.as_bytes()).context(format!("error writing to file: {}", wg_conf_path))?;
 
-    std::fs::remove_file(pk_path).context(format!("could not remove file: {}", conf_path))?;
+    std::fs::remove_file(pk_path).context(format!("could not remove file: {}", wg_conf_path))?;
     
     Ok(())
 }
 
-fn do_wg(conf: &WireguardConfig) -> Result<()> {
+fn do_wg(wg_conf: &WireguardConfig) -> Result<()> {
     let wg = processCommand::new("wg")
         .env("WG_COLOR_MODE", "always")
         .output()
@@ -318,7 +318,7 @@ fn do_wg(conf: &WireguardConfig) -> Result<()> {
 
     let mut out = String::from_utf8(wg.stdout).context("error parsing stdout")?;
 
-    for peer in conf.peers.iter() {
+    for peer in wg_conf.peers.iter() {
         out = out.replace(peer.public_key.as_str(), peer.name.as_str());
     }