Global refactor of the code

src/config.rs

@@ -1,8 +1,8 @@
-use std::fs::File;
+use crate::vec_to_string::convert_to_vec_string;
-use std::io::Read;
-
 use serde::Deserialize;
 use serde_json::Value;
+use std::fs::File;
+use std::io::Read;
 
 #[derive(Deserialize, Debug)]
 pub struct Forwarding {
@@ -14,12 +14,34 @@ pub struct Forwarding {
 
 impl Forwarding {
     pub fn new(from: String, to: String, do_reverse: bool) -> Forwarding {
-        return Forwarding{
+        Forwarding{
             from,
             to,
             do_reverse
         }
     }
+
+    pub fn from_json(json: &Value) -> Forwarding {
+        let object_forwarding = json.as_object()
+            .expect("Error parsing forwarding");
+
+        let from = object_forwarding.get("from")
+            .unwrap()
+            .as_str()
+            .expect("Error parsing from field");
+
+        let to = object_forwarding.get("to")
+            .unwrap()
+            .as_str()
+            .expect("Error parsing to field");
+
+        let do_reverse = object_forwarding.get("doReverse")
+            .unwrap()
+            .as_bool()
+            .expect("Error parsing doReverse field");
+
+        Forwarding::new(from.to_string(), to.to_string(), do_reverse)
+    }
 }
 
 #[derive(Deserialize)]
@@ -32,45 +54,68 @@ pub struct Config {
 
 impl Config {
     pub fn new(server_addr: String, blacklist: Vec<String>, forwarding: Vec<Forwarding>) -> Config {
-        return Config {
+        Config {
             server_addr,
             blacklist,
             forwarding
         }
     }
 
-    pub fn from_json(file_name: String) -> Config {
+    fn read_config_file(file_name: String) -> String {
         let mut file = File::open(file_name).expect("Error opening config.json file. Go to the readme file and paste the example.");
         let mut buf = String::new();
         file.read_to_string(&mut buf).expect("Error reading config file content.");
-        let json: Value = serde_json::from_str(&buf).expect("Error parsing config file");
+        buf
-        let object_data = json.as_object().unwrap();
+    }
-        let server_addr = object_data.get("serverAddr").unwrap().as_str().unwrap().to_string();
+
-        let blacklist = object_data.get("blacklist").unwrap().as_array().unwrap();
+    fn parse_buffer(buf: &String) -> serde_json::Map<String, Value> {
-        let forwarding = object_data.get("forwarding").unwrap().as_array().unwrap();
+        let json: Value = serde_json::from_str(&buf)
-        let str_blacklist = Self::convert_to_vec_string(blacklist);
+            .expect("Error parsing config file");
+
+        let object_data = json.as_object()
+            .expect("Error parsing config file.");
+
+        object_data.clone()
+    }
+
+    fn parse_forwarding(str_forwarding: &Vec<Value>) -> Vec<Forwarding> {
         let mut vec_forwarding = Vec::new();
-        for json_forwarding in forwarding {
+
-            let object_forwarding = json_forwarding.as_object().unwrap();
+        for json_forwarding in str_forwarding {
-            let from = object_forwarding.get("from").unwrap().as_str().unwrap();
+            vec_forwarding.push(Forwarding::from_json(json_forwarding));
-            let to = object_forwarding.get("to").unwrap().as_str().unwrap();
-            let do_reverse = object_forwarding.get("doReverse").unwrap().as_bool().unwrap();
-            let forwarding_struct = Forwarding::new(from.to_string(), to.to_string(), do_reverse);
-            vec_forwarding.push(forwarding_struct);
-        }
-        Config::new(server_addr, str_blacklist, vec_forwarding)
         }
 
-    fn convert_to_vec_string(vec: &Vec<Value>) -> Vec<String> {
+        vec_forwarding
-        let mut str_vec = Vec::new();
-        for value in vec {
-            str_vec.push(value.as_str().unwrap().to_string());
-        }
-        str_vec
     }
 
-    pub fn addr_is_blacklisted(&self, addr: String) -> bool {
+    pub fn from_json(file_name: String) -> Config {
-        self.blacklist.contains(&addr)
+        let buf = Config::read_config_file(file_name);
+        let object_data = Self::parse_buffer(&buf);
+
+
+        let server_addr = object_data.get("serverAddr")
+            .unwrap()
+            .as_str()
+            .unwrap()
+            .to_string();
+
+        let blacklist = object_data.get("blacklist")
+            .unwrap()
+            .as_array()
+            .unwrap();
+        let str_blacklist = convert_to_vec_string(blacklist);
+
+        let raw_forwarding = object_data.get("forwarding")
+            .unwrap()
+            .as_array()
+            .expect("Error parsing forwarding.");
+        let forwardings = Self::parse_forwarding(raw_forwarding);
+
+        Config::new(server_addr, str_blacklist, forwardings)
+    }
+
+    pub fn addr_is_blacklisted(&self, addr: &String) -> bool {
+        self.blacklist.contains(addr)
     }
 
     pub fn is_forwarded(&self, addr: String) -> Option<String> {

src/main.rs

@@ -5,6 +5,7 @@ use colored::Colorize;
 use crate::config::Config;
 
 mod config;
+mod vec_to_string;
 
 fn main() {
     let config = Config::from_json("config.json".to_string());
@@ -13,20 +14,34 @@ fn main() {
 
 fn listen(config: &Config) {
     let serv_config = config;
+    let addr = config.get_server_addr();
+
     println!("{}: {}", "listening on".green(), serv_config.get_server_addr());
-    let socket: UdpSocket = UdpSocket::bind(serv_config.get_server_addr()).expect("Error while binding the socket.");
+
+    let socket: UdpSocket = UdpSocket::bind(serv_config.get_server_addr())
+        .expect("Error while binding the socket.");
+
+    const BUF_SIZE: usize = 1024;
 
     loop {
         let mut message: String = String::new();
-        let mut buf: [u8; 1024] = [0; 1024];
+        let mut buf: [u8; BUF_SIZE] = [0; BUF_SIZE];
-        let (num_bytes, src_addr) = socket.recv_from(&mut buf).expect("Error while receiving message");
+        let (num_bytes, src_addr) = socket.recv_from(&mut buf)
-        if !serv_config.addr_is_blacklisted(src_addr.to_owned().to_string()) {
+            .expect("Error while receiving message");
-            message.push_str(std::str::from_utf8(&buf[..num_bytes]).expect("Invalid UTF-8 data"));
+
+        if !serv_config.addr_is_blacklisted(&addr) {
+
+            message.push_str(std::str::from_utf8(&buf[..num_bytes])
+                .expect("Invalid UTF-8 data"));
 
             let forwarding_addr_opt = serv_config.is_forwarded(src_addr.to_string());
+
             if forwarding_addr_opt.is_some() {
-                let forwarding_addr = forwarding_addr_opt.unwrap();
+                let forwarding_addr = forwarding_addr_opt
-                socket.send_to(message.as_bytes(), forwarding_addr).expect("Error forwarding message to another ip.");
+                    .unwrap();
+
+                socket.send_to(message.as_bytes(), forwarding_addr)
+                    .expect("Error forwarding message to another ip.");
             }
             println!("{}: {}", src_addr.to_string().green(), message);
         }

src/vec_to_string.rs

@@ -0,0 +1,9 @@
+use serde_json::Value;
+
+pub fn convert_to_vec_string(vec: &Vec<Value>) -> Vec<String> {
+    let mut str_vec = Vec::new();
+    for value in vec {
+        str_vec.push(value.as_str().unwrap().to_string());
+    }
+    str_vec
+}