Changes to be committed:

modified:   src/client.rs
	modified:   src/main.rs
	modified:   src/server.rs
	modified:   src/tcp_server.rs

src/client.rs

@@ -1,15 +1,17 @@
-use std::process::Command;
+use crossbeam_channel::{unbounded, Receiver};
-use clap::{App, Arg};
+use tokio::{io::AsyncWriteExt, net::UdpSocket, sync::{mpsc, Mutex}};
-use env_logger::Builder;
-use tokio::{net::UdpSocket, sync::{mpsc, Mutex}};
 use tokio::task::JoinSet;
-use std::io::{self, Read, Write};
+use packet::{builder::Builder, icmp, ip, Packet};
-use std::sync::mpsc::Receiver;
+use std::io::{Read, Write};
 use tun2::BoxError;
 use log::{error, info, LevelFilter};
 use std::sync::Arc;
 use std::net::SocketAddr;
 use std::collections::HashMap;
+use std::process::Command;
+use tokio::io::AsyncReadExt;
+
+use crate::{UDPVpnPacket, VpnPacket};
 
 fn configure_routes() {
     let ip_output = Command::new("ip")
@@ -56,7 +58,7 @@ fn configure_routes() {
     }
 }
 
-pub async fn client_mode(remote_addr: String) -> io::Result<()> {
+pub async fn client_mode(remote_addr: String) {
     info!("Starting client...");
 
     let mut config = tun2::Configuration::default();
@@ -71,54 +73,49 @@ pub async fn client_mode(remote_addr: String) -> io::Result<()> {
 		config.packet_information(true);
 	});
 
-    let dev = tun2::create(&config)?;
+    let dev = tun2::create(&config).unwrap();
-    let (mut reader, mut writer) = dev.split();
+    let (mut dev_reader, mut dev_writer) = dev.split();
 
     #[cfg(target_os = "linux")]
     configure_routes();
 
-    let sock = UdpSocket::bind("0.0.0.0:59611").await?;
+    let sock = UdpSocket::bind("0.0.0.0:59611").await.unwrap();
-    sock.connect(&remote_addr).await?;
+    sock.connect(&remote_addr).await.unwrap();
-    let receive_sock = Arc::new(sock);
-    let send_sock = Arc::new(UdpSocket::bind("0.0.0.0:59612").await?);
 
-    let mut set = JoinSet::new();
+    let sock_rec = Arc::new(sock);
+    let sock_snd = sock_rec.clone();
 
-    let srem = Arc::new(remote_addr.clone());
+    let (tx, rx) = unbounded::<Vec<u8>>();
+    let (dx, mx) = unbounded::<Vec<u8>>();
 
-    set.spawn(async move {
+    tokio::spawn(async move {
-        let mut buf = [0; 4096];
+        while let Ok(bytes) = rx.recv() {
-        loop {
+            dev_writer.write_all(&bytes).unwrap();
-            match reader.read(&mut buf) {
-                Ok(size) => {
-                    let pkt = &buf[..size];
-                    use std::io::{Error, ErrorKind::Other};
-                    //tx.send(pkt.to_vec()).await.unwrap();
-                    send_sock.send_to(pkt, srem.parse::<SocketAddr>()
-                    .expect("Unable to parse socket address"));
-                    info!("Wrote to sock");
-                }
-                Err(error) => error!("Error with reading from tun")
-            }
-            ()
         }
     });
 
-    set.spawn(async move {
+    tokio::spawn(async move {
-        let mut buf = [0; 4096];
+        let mut buf = vec![0; 8192];
-        loop {
+        while let Ok(n) = dev_reader.read(&mut buf) {
-            match receive_sock.recv_from(&mut buf).await {
+            dx.send(buf[..n].to_vec()).unwrap();
-                Ok((len, addr)) => {
-                    println!("{:?} bytes received from {:?}", len, addr);
-                    writer.write_all(&buf[..len]);
-                    info!("Wrote to tun");
-                }
-                Err(error) => error!("Error with reading from sock")
-            };
         }
     });
 
-    while let Some(res) = set.join_next().await {}
+    tokio::spawn(async move {
+        let mut buf = vec![0; 4096];
+        loop {
+            if let Ok(l) = sock_rec.recv(&mut buf).await {
+                tx.send((&buf[..l]).to_vec());
+            }
+        }
+    });
 
-    Ok(())
+    loop {
+        if let Ok(bytes) = mx.recv() {
+            let vpn_packet = UDPVpnPacket{ data: bytes };
+            let serialized_data = vpn_packet.serialize();
+            //info!("Writing to sock: {:?}", serialized_data);
+            sock_snd.send(&serialized_data).await.unwrap();
+        }
+    }
 }

src/main.rs

@@ -8,10 +8,10 @@ use tun::platform::Device;
 use serde_derive::Serialize;
 use serde_derive::Deserialize;
 
-//mod client;
-//mod server;
 mod tcp_client;
 mod tcp_server;
+mod server;
+mod client;
 
 struct VpnPacket {
     //start: Vec<u8>
@@ -34,6 +34,28 @@ impl VpnPacket {
     }
 }
 
+
+struct UDPVpnPacket {
+    //start: Vec<u8>
+    data: Vec<u8>
+    //end: Vec<u8>
+}
+
+impl UDPVpnPacket {
+    fn serialize(&self) -> Vec<u8> {
+        let h: &[u8] = &[1];
+        [h, &self.data[..]].concat()
+    }
+}
+
+struct UDPVpnHandshake {}
+
+impl UDPVpnHandshake {
+    fn serialize(&self) -> Vec<u8> {
+        [0, 9, 9, 9, 9, 9, 9].to_vec()
+    }
+}
+
 #[tokio::main]
 async fn main() {
 
@@ -68,7 +90,7 @@ async fn main() {
     if is_server_mode {
         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;
+            server::server_mode(server_address).await;
         } else {
             eprintln!("Error: For server mode, you shall provide the '--bind-to' argument.");
         }

src/server.rs

@@ -1,20 +1,24 @@
-use tokio::{net::UdpSocket, sync::{mpsc, Mutex}};
+use crossbeam_channel::{unbounded, Receiver, Sender};
+use tokio::{io::AsyncWriteExt, net::{TcpListener, TcpSocket, TcpStream, UdpSocket}, sync::{mpsc, Mutex}};
 use tokio::task::JoinSet;
-use packet::{builder::Builder, icmp, ip, Packet};
+use packet::{builder::Builder, icmp, ip, AsPacket, Packet};
 use std::io::{Read, Write};
-use std::sync::mpsc::Receiver;
 use tun2::BoxError;
 use log::{error, info, LevelFilter};
 use std::sync::Arc;
-use std::net::SocketAddr;
+use std::net::{ SocketAddr, Ipv4Addr, IpAddr };
 use std::collections::HashMap;
+use tokio::io::AsyncReadExt;
+use std::process::Command;
 
+use crate::VpnPacket;
 
-pub async fn server_mode() -> Result<(), BoxError> {
+pub async fn server_mode(bind_addr: String) {
     info!("Starting server...");
     
     let mut config = tun2::Configuration::default();
     config.address("10.8.0.1");
+    config.netmask("255.255.255.0");
     config.tun_name("tun0");
     config.up();
 
@@ -23,55 +27,91 @@ pub async fn server_mode() -> Result<(), BoxError> {
 		config.packet_information(true);
 	});
 
-    let dev = tun2::create(&config)?;
+    let dev = tun2::create(&config).unwrap();
-    let (mut reader, mut writer) = dev.split();
+    let (mut dev_reader, mut dev_writer) = dev.split();
 
-    let clients_inserter = Arc::new(Mutex::new(HashMap::<&str, UdpSocket>::new()));
+    let sock = UdpSocket::bind(bind_addr).await.unwrap();
-    let clients_getter = clients_inserter.clone();
+    let sock_rec = Arc::new(sock);
+    let sock_snd = sock_rec.clone();
+    let addresses = Arc::new(Mutex::new(HashMap::<IpAddr, UDPeer>::new()));
 
-    let receiver_sock = Arc::new(match UdpSocket::bind("192.168.0.5:8879".parse::<SocketAddr>().unwrap()).await {
+    let (send2tun, recv2tun) = unbounded::<Vec<u8>>();
-        Ok(s) => s,
-        Err(_error) => panic!("Cannot bind to address")
-    });
 
-    let mut set = JoinSet::new();
+    tokio::spawn(async move {
-
-    set.spawn(async move {
-        let mut buf = [0; 4096];
         loop {
-            let size = reader.read(&mut buf)?;
+            if let Ok(bytes) = recv2tun.recv() {
-            let pkt = &buf[..size];
+                dev_writer.write_all(&bytes).unwrap();
-            use std::io::{Error, ErrorKind::Other};
+            }
-            let m = clients_getter.lock().await;
-            match m.get(&"10.0.8.2") {
-                Some(&ref sock) => { sock.send(&pkt).await.unwrap(); info!("Wrote to sock") },
-                None => { error!("There's no client!") }
-            };
-            drop(m);
-            ()
         }
-        #[allow(unreachable_code)]
-        Ok::<(), std::io::Error>(())
     });
 
-    set.spawn(async move {
+    let addrs_cl = addresses.clone();
-        let mut buf = [0; 4096];
+    tokio::spawn(async move {
+        let mut buf = vec![0; 4096];
+        while let Ok(n) = dev_reader.read(&mut buf) {
+            // 16..=19
+            if n > 19 {
+                let ip = IpAddr::V4(Ipv4Addr::new(buf[16], buf[17], buf[18], buf[19]));
+                let mp = addrs_cl.lock().await;
+                if let Some(peer) = mp.get(&ip) {
+                    sock_snd.send_to(&buf[..n], peer.addr);
+                } else {
+                    mp.values().for_each(| peer | { sock_snd.send_to(&buf[..n], peer.addr); });
+                    error!("UDPeer not found {:?}", ip);
+                }
+                drop(mp);
+            }
+        }
+    });
+    
+    let mut buf = vec![0; 2048];
+    let addrs_lp = addresses.clone();
+    
     loop {
-            if let Ok((len, addr)) = receiver_sock.recv_from(&mut buf).await {
+        if let Ok((len, addr)) = sock_rec.recv_from(&mut buf).await {
-                let mut m = clients_inserter.lock().await;
+            let mut mp = addrs_lp.lock().await;
-                if !m.contains_key(&"10.0.8.2") {
+            match buf.first() {
-                    let cl = UdpSocket::bind("0.0.0.0:59611").await?;
+                Some(h) => {
-                    cl.connect(addr).await?;
+                    match h {
-                    m.insert("10.0.8.2", cl);
+                        0 => {
+                            // (&buf[1..len]).to_vec()
+                            let internal_ip = IpAddr::V4(Ipv4Addr::new(10,8,0,2));
+                            mp.insert(internal_ip, UDPeer { addr });
+                        }, // handshake
+                        1 => {
+                            if mp.values().any(| p | p.addr == addr) {
+                                send2tun.send((&buf[1..len]).to_vec());
                             }
-                drop(m);
+                        }, // payload
-                writer.write_all(&buf[..len])?;
+                        _ => {
-                info!("Wrote to tun");
+                            error!("Unexpected header value.");
+                        }
+                    }
+                },
+                None => error!("There is no header")
+            }
+            drop(mp);
         }
     }
-    });
-
-    while let Some(res) = set.join_next().await {}
-
-    Ok(())
 }
+
+struct UDPeer {
+    addr: SocketAddr
+}
+
+/*struct WrappedUDP {
+    sock_rec: Arc<UdpSocket>,
+    sock_snd: Arc<UdpSocket>,
+    addresses: Arc<Mutex<HashMap<IpAddr, UDPeer>>>
+}
+
+impl WrappedUDP {
+    pub async fn new(addr: &str) -> Self {
+        
+        WrappedUDP { sock_rec, sock_snd, addresses }
+    }
+
+    pub async fn init(&self) {
+        
+    }
+}*/

src/tcp_server.rs

@@ -22,58 +22,6 @@ pub async fn server_mode(bind_addr: String) {
     config.tun_name("tun0");
     config.up();
 
-   /*  let mut route_output = Command::new("route")
-        .arg("add")
-        .arg("0.0.0.0")
-        .arg("mask")
-        .arg("128.0.0.0")
-        .arg("0.0.0.0")
-        .output()
-        .expect("Failed to execute IP ROUTE 1");
-
-    if !route_output.status.success() {
-        error!("Failed to set route: {}", String::from_utf8_lossy(&route_output.stderr));
-    }
-
-    route_output = Command::new("route")
-        .arg("add")
-        .arg("10.8.0.1")
-        .arg("mask")
-        .arg("255.255.255.255")
-        .arg("0.0.0.0")
-        .output()
-        .expect("Failed to execute IP ROUTE 2");
-
-    if !route_output.status.success() {
-        error!("Failed to set route: {}", String::from_utf8_lossy(&route_output.stderr));
-    }
-
-    route_output = Command::new("route")
-        .arg("add")
-        .arg("127.255.255.255")
-        .arg("mask")
-        .arg("255.255.255.255")
-        .arg("0.0.0.0")
-        .output()
-        .expect("Failed to execute IP ROUTE 3");
-
-    if !route_output.status.success() {
-        error!("Failed to set route: {}", String::from_utf8_lossy(&route_output.stderr));
-    }
-
-    route_output = Command::new("route")
-        .arg("add")
-        .arg("128.0.0.0")
-        .arg("mask")
-        .arg("128.0.0.0")
-        .arg("0.0.0.0")
-        .output()
-        .expect("Failed to execute IP ROUTE 4");
-
-    if !route_output.status.success() {
-        error!("Failed to set route: {}", String::from_utf8_lossy(&route_output.stderr));
-    }*/
-
     #[cfg(target_os = "linux")]
 	config.platform_config(|config| {
 		config.packet_information(true);