server list working

src/client.rs

@@ -0,0 +1,121 @@
+use json::object;
+use tokio::net::TcpStream;
+use std::collections::VecDeque;
+use crate::handshake::Handshake;
+use crate::varint::{varint_read, varint_write};
+
+pub struct Client {
+    pub in_stream: TcpStream,
+
+    buffer: Vec<u8>,
+    out_stream: Option<TcpStream>,
+    handshake: Option<Handshake>
+}
+
+impl Client {
+    pub fn create(stream: TcpStream) -> Self {
+        Self {
+            in_stream: stream,
+
+            buffer: vec![],
+            out_stream: None,
+            handshake: None
+        }
+    }
+
+    pub async fn buffer_append(&mut self, data: Vec<u8>) -> Result<(),String> {
+        if data.len() == 0 {
+            return Ok(());
+        }
+
+
+        if let Some(_) = &self.out_stream {
+            self.stream_data(data);
+            return Ok(());
+        }
+
+        let _ = self.buffer.append(&mut (data.clone()));
+
+        if self.buffer[0] == 0 {
+            return Err("invalid packet".to_string());
+        }
+
+        if self.buffer.len() - 1 >= self.buffer[0] as usize {
+            let len = varint_read(&mut self.buffer.clone().into())? as usize;
+            self.handle_packet(self.buffer[1..=len].to_vec().into())?;
+            self.buffer.drain(..len + 1);
+        }
+        Ok(())
+    }
+
+    fn send_packet(&self, data: Vec<u8>) {
+        let mut sent_data: Vec<u8> = varint_write(data.len() as i32);
+
+        sent_data.extend(data);
+        match self.in_stream.try_write(sent_data.as_slice()) {
+            Ok(len) => { println!("sent {} bytes to the client", len); },
+            Err(e) => { println!("error while sending response {:?}", e); }
+        }
+    }
+
+    fn stream_data(&self, _data: Vec<u8>) {
+        panic!("proxy not implemented")
+    }
+
+    fn handle_packet(&mut self, mut packet: VecDeque<u8>) -> Result<(), String> {
+        println!("len : {}" , packet.len());
+        let packet_id = varint_read(&mut packet)?;
+        if self.handshake.is_none() {
+            if packet_id != 0 {
+                return Err("packet 0 expected. invalid packet received".to_string());
+            }
+            self.handshake = Some(Handshake::parse(&mut packet)?);
+            return Ok(());
+        }
+
+        let intent = self.handshake.as_ref().unwrap().intent;
+
+        if intent == 1 {
+            self.status_intent_handle(&mut packet, packet_id)?;
+        } else if intent == 2 {
+            self.login_intent_handle(&mut packet, packet_id)?;
+        }
+        Ok(())
+    }
+
+    fn status_intent_handle(&self, mut packet: &mut VecDeque<u8>, packet_id: i32) -> Result<(),String> {
+        let status_response = object! {
+            "version": {
+                "name": "1.21.6",
+                "protocol" : self.handshake.as_ref().unwrap().protocol_version,
+            },
+            "players": {
+                "max": 420,
+                "online": 69
+            },
+            "description": self.handshake.as_ref().unwrap().server_address.clone(),
+        };
+        if packet_id == 0 {
+            let mut response : Vec<u8> = vec![];
+
+            let response_json = json::stringify(status_response);   
+            let mut response_json_len = varint_write(response_json.len() as i32);
+            let mut response_packet_id = varint_write(0);
+
+            response.append(&mut response_packet_id);
+            response.append(&mut response_json_len);
+            response.append(&mut response_json.as_bytes().into());
+
+            self.send_packet(response);
+        } else if packet_id == 1 {
+            let mut response = varint_write(1);
+            response.extend(packet.drain(..));
+            self.send_packet(response);
+        }
+        Ok(())
+    }
+
+    fn login_intent_handle(&self, mut _packet: &mut VecDeque<u8>, _packet_id: i32) -> Result<(),String> {
+        panic!("not implemented")
+    }
+}

src/handshake.rs

@@ -0,0 +1,30 @@
+use std::collections::VecDeque;
+use crate::varint::varint_read;
+
+pub struct Handshake {
+    pub protocol_version: i32,
+    pub server_address: String,
+    pub server_port: u16,
+    pub intent: i32
+}
+
+impl Handshake {
+    pub fn parse(mut packet: &mut VecDeque<u8>) -> Result<Self, String> {
+        let protocol_version = varint_read(&mut packet)?;
+
+        let str_len = varint_read(&mut packet)? as usize;
+        let server_address : String = String::from_utf8(packet.drain(..str_len).collect::<Vec<u8>>()).expect("Invalid UTF-8");
+
+        let bytes: [u8; 2] = [packet[0], packet[1]];
+        let server_port : u16 = u16::from_be_bytes(bytes);
+        packet.drain(..2);
+
+        let intent : i32 = varint_read(&mut packet)?;
+        Ok(Self {
+            protocol_version,
+            server_address,
+            server_port,
+            intent
+        })
+    }
+}

src/main.rs

@@ -1,3 +1,48 @@
-fn main() {
-    println!("Hello, world!");
+use tokio::net::{TcpListener, TcpStream};
+mod client;
+use client::Client;
+use std::io;
+
+pub mod varint;
+pub mod handshake;
+
+
+async fn process_socket(stream: TcpStream) -> io::Result<()> {
+    let mut buf = vec![0 as u8; 1024];
+
+    let mut client = Client::create(stream);
+
+    loop {
+        client.in_stream.readable().await?;
+
+        match client.in_stream.try_read(&mut buf) {
+            Ok(n) => {
+                let _ = client.buffer_append((&buf[..n]).to_vec()).await;
+                if n == 0 {
+                    break;
+                }
+            }
+            Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
+                continue;
+            }
+            Err(e) => {
+                return Err(e.into());
+            }
+        }
+    }
+    Ok(())
+}
+
+#[tokio::main(flavor = "current_thread")]
+async fn main() -> io::Result<()> {
+    let listener = TcpListener::bind("0.0.0.0:25565").await?;
+
+    loop {
+        let (socket, _) = listener.accept().await?;
+        tokio::spawn(async move {
+            if let Err(e) = process_socket(socket).await {
+                eprintln!("error: {:?}", e);
+            }
+        });
+    }
 }

src/varint.rs

@@ -0,0 +1,47 @@
+use std::collections::VecDeque;
+
+const SEGMENT_BITS : i32 = 0x7F;
+const CONTINUE_BIT : i32 = 0x80;
+
+pub fn varint_read(buffer: &mut VecDeque<u8>) -> Result<i32, String> {
+    let mut value : i32 = 0;
+    let mut position: i32 = 0;
+
+    loop {
+        if buffer.len() == 0 {
+            return Err("invalid VarInt".to_string());
+        }
+
+        let current = buffer.pop_front().unwrap() as i32;
+        value |= (current & SEGMENT_BITS) << position;
+
+        if (current & CONTINUE_BIT) == 0 {
+            break;
+        }
+
+        position += 7;
+
+        if position >= 32 {
+            return Err("Varint too big".to_string());
+        }
+    }
+    Ok(value)
+}
+
+
+
+pub fn varint_write(mut value: i32) -> Vec<u8> {
+    let mut result : Vec<u8> = vec![];
+
+    loop {
+        if (value & !SEGMENT_BITS) == 0 {
+            result.push(value as u8);
+            break;
+        }
+
+        result.push(((value & SEGMENT_BITS) | CONTINUE_BIT) as u8);
+
+        value  = ((value as u32) >> 7) as i32;
+    }
+    result
+}