The program get the server address in config file

src/config.rs

@@ -24,13 +24,16 @@ impl Forwarding {
 
 #[derive(Deserialize)]
 pub struct Config {
+    #[serde(rename = "serverAddr")]
+    server_addr: String,
     blacklist: Vec<String>,
     forwarding: Vec<Forwarding>
 }
 
 impl Config {
-    pub fn new(blacklist: Vec<String>, forwarding: Vec<Forwarding>) -> Config {
+    pub fn new(server_addr: String,  blacklist: Vec<String>, forwarding: Vec<Forwarding>) -> Config {
         return Config {
+            server_addr,
             blacklist,
             forwarding
         }
@@ -42,6 +45,7 @@ impl Config {
         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");
         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();
         let forwarding = object_data.get("forwarding").unwrap().as_array().unwrap();
         let str_blacklist = Self::convert_to_vec_string(blacklist);
@@ -54,7 +58,7 @@ impl Config {
             let forwarding_struct = Forwarding::new(from.to_string(), to.to_string(), do_reverse);
             vec_forwarding.push(forwarding_struct);
         }
-        Config::new(str_blacklist, vec_forwarding)
+        Config::new(server_addr, str_blacklist, vec_forwarding)
     }
 
     fn convert_to_vec_string(vec: &Vec<Value>) -> Vec<String> {
@@ -79,4 +83,8 @@ impl Config {
         }
         None
     }
+
+    pub fn get_server_addr(&self) -> String {
+        self.server_addr.to_string()
+    }
 }

src/main.rs

@@ -1,33 +1,26 @@
-mod config;
-
-use std::io::stdin;
 use std::net::UdpSocket;
+
 use colored::Colorize;
+
 use crate::config::Config;
 
+mod config;
+
 fn main() {
     let config = Config::from_json("config.json".to_string());
-    let server_address: String = get_server_address();
-    listen(&server_address, &config);
+    listen(&config);
 }
 
-fn get_server_address() -> String {
-    println!("Enter server address (format xxx.xxx.xxx.xxx:port)");
-    let mut server_address = String::new();
-    stdin().read_line(&mut server_address).expect("Reading the server address from input");
-    return server_address.trim().to_string();
-}
-
-fn listen(server_address: &str, config: &Config) {
+fn listen(config: &Config) {
     let serv_config = config;
-    println!("{}: {}", "listening on".green(), server_address);
-    let socket: UdpSocket = UdpSocket::bind(server_address).expect("Error while binding the socket.");
+    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.");
 
     loop {
         let mut message: String = String::new();
         let mut buf: [u8; 1024] = [0; 1024];
         let (num_bytes, src_addr) = socket.recv_from(&mut buf).expect("Error while receiving message");
-        if !serv_config.addr_is_blacklisted(src_addr.to_string()) {
+        if !serv_config.addr_is_blacklisted(src_addr.to_owned().to_string()) {
             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());