Changes to be committed:

modified:   src/main.rs
	modified:   src/tcp_client.rs
	modified:   src/tcp_server.rs

src/main.rs

@@ -52,12 +52,23 @@ async fn main() {
             .value_name("IP")
             .help("The IP address of the VPN server to connect to (client mode only)")
             .takes_value(true))
+        .arg(Arg::with_name("bind-to")
+            .long("bind-to")
+            .value_name("IP")
+            .help("The IP address of the VPN server to bind to (server mode only)")
+            .takes_value(true))
         .get_matches();
 
     let is_server_mode = matches.value_of("mode").unwrap() == "server";
     // "192.168.0.4:8879"
     if is_server_mode {
-        tcp_server::server_mode().await; 
+        if let Some(vpn_server_ip) = matches.value_of("bind-to") {
+            let server_address = format!("{}:8879", vpn_server_ip);
+            tcp_server::server_mode(server_address).await;
+        } else {
+            eprintln!("Error: For server mode, you shall provide the '--bind-to' argument.");
+        }
+         
     } else { 
         if let Some(vpn_server_ip) = matches.value_of("vpn-server") {
             let server_address = format!("{}:8879", vpn_server_ip);

src/tcp_client.rs

@@ -103,9 +103,11 @@ pub async fn client_mode(remote_addr: String) {
         loop {
             if let Ok(n) = sock_reader.read(&mut buf).await {
                 //info!("Catch from socket: {:?}", &buf[..n]);
-                let vpn_packet: VpnPacket = bincode::deserialize(&buf[..n]).unwrap();
+                match bincode::deserialize::<VpnPacket>(&buf[..n]) {
+                    Ok(vpn_packet) => tx.send(vpn_packet.data).unwrap(),
+                    Err(error) => error!("Deserialization error {:?}", error),
+                };
                 //if vpn_packet.start != &HEADER || vpn_packet.end != &TAIL { error!("Bad packet"); continue; }
-                tx.send(vpn_packet.data).unwrap();
             }
         }
     });

src/tcp_server.rs

@@ -12,7 +12,7 @@ use tokio::io::AsyncReadExt;
 
 use crate::{VpnPacket, HEADER, TAIL};
 
-pub async fn server_mode() {
+pub async fn server_mode(bind_addr: String) {
     info!("Starting server...");
     
     let mut config = tun2::Configuration::default();
@@ -44,7 +44,7 @@ pub async fn server_mode() {
         }
     });
 
-    let listener = TcpListener::bind("192.168.0.5:8879".parse::<SocketAddr>().unwrap()).await.unwrap();
+    let listener = TcpListener::bind(&bind_addr).await.unwrap();
 
     loop {
         let (mut socket, _) = listener.accept().await.unwrap();
@@ -58,7 +58,7 @@ pub async fn server_mode() {
                     let vpn_packet = VpnPacket::init(bytes);
                     let serialized_data = bincode::serialize(&vpn_packet).unwrap();
                     sock_writer.write_all(&serialized_data).await.unwrap();
-                    info!("Wrote to sock: {:?}", serialized_data);
+                    //info!("Wrote to sock: {:?}", serialized_data);
                 }
             }
         });
@@ -67,10 +67,12 @@ pub async fn server_mode() {
             let mut buf = vec![0; 4096];
             loop {
                 if let Ok(n) = sock_reader.read(&mut buf).await {
-                    info!("Catched from sock: {:?}", &buf[..n]);
+                    //info!("Catched from sock: {:?}", &buf[..n]);
-                    let vpn_packet: VpnPacket = bincode::deserialize(&buf[..n]).unwrap();
+                    match bincode::deserialize::<VpnPacket>(&buf[..n]) {
+                        Ok(vpn_packet) => thread_tx.send(vpn_packet.data).unwrap(),
+                        Err(error) => error!("Deserializing error {:?}", error),
+                    };
                     //if vpn_packet.start != &HEADER || vpn_packet.end != &TAIL { error!("Bad packet"); continue; }
-                    thread_tx.send(vpn_packet.data).unwrap();
                 }
             }
         });