add server configuration

src/client/HandShake.rs

@@ -1,30 +0,0 @@
-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

@@ -3,26 +3,26 @@ use std::io::prelude::*;
 use std::thread;
 use std::sync::{Arc, Mutex, RwLock};
 
-mod HandShake;
+use crate::protocol;
 
 pub struct Client<'a>{
     client: Arc<Mutex<TcpStream>>,
     server:Arc<Mutex<TcpStream>>,
     //client: &'static TcpStream,
     //server: &'static TcpStream,
-    hs: HandShake::HandShake<'a>,
+    hs: protocol::HandShake<'a>,
     run : Arc<RwLock<bool>>,
     //run: &'static bool
 }
 
 impl<'a> Client<'a> {
-    pub fn new(client: TcpStream, server: TcpStream, handshake: &[u8]) -> Client{
+    pub fn new(client: TcpStream, server: TcpStream, handshake: protocol::HandShake) -> Client{
         Client {
             client: Arc::new(Mutex::new(client)),
             server: Arc::new(Mutex::new(server)),
             //client: client,
             //server: server,
-            hs: HandShake::HandShake::new(handshake),
+            hs: handshake,
             run: Arc::new(RwLock::new(true)),
             //run: &true,
         }

src/conf/mod.rs

@@ -0,0 +1,62 @@
+use yaml_rust::yaml;
+use std::fs::File;
+use std::str::FromStr;
+use std::io::prelude::*;
+use std::collections::HashMap;
+
+static file: &str = "mrprox.conf";
+
+pub struct Servers{
+    l_servers : HashMap<String, String>,
+}
+
+impl Servers {
+    pub fn new() -> Servers {
+        Servers{
+            l_servers: Self::get_servers(),
+        }
+    }
+
+    fn get_servers() -> HashMap<String, String> {
+        let mut f = File::open(&file).unwrap();
+        let mut s = String::new();
+        let mut ret = HashMap::new();
+        f.read_to_string(&mut s).unwrap();
+        let docs = yaml::YamlLoader::load_from_str(&s).unwrap();
+        let docs2;
+        match &docs[0]["servers"] {
+            yaml::Yaml::Hash(ref h) => docs2 = h,
+            _ => return ret,
+        }
+
+
+        for (k, v) in docs2{
+            //println!("{}",String::from(doc.as_str().unwrap()));
+            ret.insert(String::from(k.as_str().unwrap()),
+                    String::from(v.as_str().unwrap()));
+        }
+        ret
+    }
+
+    fn get_host(&self, host: &String) -> Option<(&String, &String)>{
+        self.l_servers.get_key_value(host)
+    }
+
+    pub fn get_server(&self, host: &String) -> Option<(String, u16)>{
+        let raw: Vec<&str>;
+        match self.get_host(host){
+            Some(h) => raw=h.1.split(":").collect(),
+            None => return None,
+        }
+
+        if raw.len() == 2 {
+
+            match FromStr::from_str(raw[1]) {
+                Ok(p) => return Some((String::from(raw[0]),p)),
+                Err(_e) => return None,
+            }
+        } else {
+            return None;
+        }
+    }
+}

src/main.rs

@@ -1,10 +1,14 @@
 use std::net::{TcpListener, TcpStream};
 use std::io::prelude::*;
 mod client;
+mod conf;
+mod protocol;
 
 fn main() {
     let listener = TcpListener::bind("127.0.0.1:25567").unwrap();
     let mut buf: [u8; 256] = [1; 256];
+    let servers = conf::Servers::new();
+
     for stream in listener.incoming() {
         //stream.unwrap().write(buf);
         match stream {
@@ -15,20 +19,28 @@ fn main() {
                 stream.flush();*/
                 println!("Go!");
                 let leng = stream.read(&mut buf).unwrap();
-                println!("{}", buf[6]);
-                if buf[0] < 200 {
+                let mut hs = protocol::HandShake::new(&mut buf[.. leng]);
+                if hs.get_raw()[0] < 200 {
                     let mut sstream;
                     
-                    if buf[6]==49 {
-                        buf[(buf[0]-1) as usize] -= 2;
+                    if hs.get_raw()[6]==49 {
+                        //buf[(buf[0]-1) as usize] -= 2;
+                        println!("p0:{}",hs.get_port());
+                        hs.replace_port(servers.get_server(&hs.getHostName()).unwrap().1);
+                        println!("p1:{}",hs.get_port());
                         sstream = TcpStream::connect("127.0.0.1:25565").unwrap();
                     } else {
-                        buf[(buf[0]-1) as usize] -= 1;
+                        println!("p0:{}",hs.get_port());
+                        match servers.get_server(&hs.getHostName()) {
+                            Some(s) => hs.replace_port(s.1),
+                            None => hs.replace_port(25565),
+                        }
+                        println!("p1:{}",hs.get_port());
                         sstream = TcpStream::connect("127.0.0.1:25566").unwrap();
                     }
                     //let mut sstream = TcpStream::connect("127.0.0.1:25565").unwrap();
-                    sstream.write(&buf[.. leng]);
-                    let c1 = client::Client::new(stream,sstream, &buf);
+                    sstream.write(hs.get_raw());
+                    let c1 = client::Client::new(stream,sstream, hs);
                     c1.to_string();
                     c1.start_proxy();
                 }

src/meson.build

@@ -2,7 +2,8 @@ minecraft_proxy_sources = [
   cargo_sources,
   'main.rs',
   'client/mod.rs',
-  'client/HandShake.rs',
+  'protocol/mod.rs',
+  'conf/mod.rs',
 ]
 
 minecraft_proxy_deps = [

src/protocol/mod.rs

@@ -0,0 +1,48 @@
+use std::string;
+
+pub struct HandShake<'a> {
+    len_pack: u8,
+    len_dom: u8,
+    port_pos: usize,
+    datagram: &'a mut [u8],
+    //host: &'a [u8],
+    //port: &'a mut [u8],
+}
+
+impl<'a> HandShake<'a>{
+    pub fn new(data: &'a mut[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,
+            port_pos: (len_pack - 2) as usize,
+            //host: (&mut data[5 .. ((len_dom + 5) as usize)]),
+            //port: (&mut data[((len_pack - 2) as usize) .. ((len_pack - 1) as usize)]),
+        }
+    }
+
+    pub fn getHostName(&self) -> String {
+        String::from_utf8(self.datagram[5 .. ((self.len_dom+5) as usize)].to_vec()).unwrap()
+    }
+
+    pub fn get_port(&self) -> u16 {
+        u16::from_be_bytes([(self.datagram[(self.len_pack - 2) as usize]),
+         (self.datagram[(self.len_pack - 1) as usize])])
+    }
+
+    pub fn replace_port(&mut self, n_port: u16){
+        let s_port = n_port.to_ne_bytes();
+        self.datagram[self.port_pos]=s_port[0];
+        self.datagram[self.port_pos+1]=s_port[1];
+    }
+
+
+    pub fn get_raw(&self) -> &[u8]{
+        self.datagram
+    }
+}
+