compile but not works propertly

src/client/HandShake.rs

@@ -0,0 +1,31 @@
+use std::string;
+
+
+
+pub struct HandShake<'a> {
+    len_pack: u8,
+    len_dom: u8,
+    datagram: &'a[u8],
+    host: &'a[u8],
+    port: &'a[u8],
+}
+
+impl<'a> HandShake<'a>{
+    pub fn new(data: &[u8]) -> HandShake {
+        let len_pack = data[0];
+        println!("{}", len_pack);
+        let len_dom = data[4];
+        println!("{}", len_dom);
+        HandShake {
+            len_pack: len_pack,
+            len_dom: len_dom,
+            datagram: data.clone(),
+            host: (&data[5 .. ((len_dom + 5) as usize)]).clone(),
+            port: (&data[((len_pack - 2) as usize) .. ((len_pack - 1) as usize)]).clone(),
+        }
+    }
+
+    pub fn getHostName(&self) -> String {
+        String::from_utf8(self.datagram[5 .. ((self.len_dom+5) as usize)].to_vec()).unwrap()
+    }
+}

src/client/mod.rs

@@ -0,0 +1,90 @@
+use std::net::TcpStream;
+use std::io::prelude::*;
+use std::thread;
+use std::sync::{Arc, Mutex};
+
+mod HandShake;
+
+pub struct Client<'a>{
+    client: Arc<Mutex<TcpStream>>,
+    server:Arc<Mutex<TcpStream>>,
+    //client: &'static TcpStream,
+    //server: &'static TcpStream,
+    hs: HandShake::HandShake<'a>,
+    run : Arc<Mutex<bool>>,
+    //run: &'static bool
+}
+
+impl<'a> Client<'a> {
+    pub fn new(client: TcpStream, server: TcpStream, handshake: &[u8]) -> Client{
+        Client {
+            client: Arc::new(Mutex::new(client)),
+            server: Arc::new(Mutex::new(server)),
+            //client: client,
+            //server: server,
+            hs: HandShake::HandShake::new(handshake),
+            run: Arc::new(Mutex::new(true)),
+            //run: &true,
+        }
+    }
+
+    pub fn to_string(&self){
+        println!("len_pack {}", self.hs.getHostName());
+    }
+
+    fn join_conexions_mutex(c1: Arc<Mutex<TcpStream>>,
+            c2: Arc<Mutex<TcpStream>>,
+            run: Arc<Mutex<bool>>,
+            id: i32){
+        let mut buf: [u8; 1000000] = [0; 1000000];
+        while *run.lock().unwrap() {
+            println!("read{}",id);
+            let res=c1.lock().unwrap().read(&mut buf);
+            match res {
+                Ok(leng) => {
+                    println!("rx {}",leng);
+                    println!("tx {}",c2.lock().unwrap().write(&buf [.. leng]).unwrap());
+                },
+                //Ok(leng) => {c2.lock().unwrap().write(&buf);},
+                Err(_e) => {*run.lock().unwrap()=false;},
+            }
+            println!("write{}",id);
+
+        }
+    }
+
+    pub fn start_proxy(&self) -> (thread::JoinHandle<()>, thread::JoinHandle<()>) {
+
+        //let c = client.client;
+        let c1 = self.client.clone();
+        let s1 = self.server.clone();
+        let r1 = self.run.clone();
+        let handler1 = thread::spawn( || {
+            Self::join_conexions_mutex(s1,
+                c1,
+                r1,1)}
+        );
+
+        let c2 = self.client.clone();
+        let s2 = self.server.clone();
+        let r2 = self.run.clone();
+        let handler2 = thread::spawn( || {
+            Self::join_conexions_mutex(c2,
+                s2,
+                r2,2)}
+        );
+
+        return (handler1, handler2);
+        /*let handler = thread::spawn( || {
+            Self::join_conexions(&mut client.client,
+                &mut client.server,
+                &mut client.run)}
+        );
+
+        let handler2 = thread::spawn( || {
+            Self::join_conexions(&mut client.client,
+                &mut client.server,
+                &mut client.run)}
+        );*/
+    }
+}

src/main.rs

@@ -0,0 +1,31 @@
+use std::net::{TcpListener, TcpStream};
+use std::io::prelude::*;
+mod client;
+
+fn main() {
+    let listener = TcpListener::bind("127.0.0.1:25567").unwrap();
+    let mut buf: [u8; 128] = [1; 128];
+    for stream in listener.incoming() {
+        //stream.unwrap().write(buf);
+        match stream {
+            Ok(mut stream) => {
+                /*println!("Go!");
+                stream.write("test succes/n".as_bytes());
+                stream.read(&mut buf);
+                stream.flush();*/
+                println!("Go!");
+                let leng = stream.read(&mut buf).unwrap();
+                buf[(buf[0]-1) as usize] += 2;
+                let mut sstream = TcpStream::connect("127.0.0.1:25565").unwrap();
+                sstream.write(&buf[.. leng]);
+                let c1 = client::Client::new(stream,sstream, &buf);
+                c1.to_string();
+                c1.start_proxy().0.join();
+                c1.start_proxy().1.join();
+                },
+
+            Err(_e) => println!("{}",_e),
+        }
+    }
+}
+

src/meson.build

@@ -0,0 +1,28 @@
+minecraft_proxy_sources = [
+  cargo_sources,
+  'main.rs',
+  'client/mod.rs',
+  'client/HandShake.rs',
+]
+
+minecraft_proxy_deps = [
+]
+
+cargo_script = find_program(join_paths(meson.project_source_root(), 'build-aux/cargo.sh'))
+cargo_release = custom_target(
+  'cargo-build',
+  build_by_default: true,
+  input: minecraft_proxy_sources,
+  output: meson.project_name(),
+  console: true,
+  install: true,
+  install_dir: get_option('bindir'),
+  command: [
+    cargo_script,
+    meson.project_build_root(),
+    meson.project_source_root(),
+    '@OUTPUT@',
+    get_option('buildtype'),
+    meson.project_name(),
+  ]
+)