reorganize file structure, define rpc protocol

src/minecraft/client.rs

@@ -0,0 +1,136 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   client.rs                                          :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tomoron <tomoron@student.42angouleme.fr>   +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2026/05/07 17:23:09 by tomoron           #+#    #+#             */
+/*   Updated: 2026/05/07 17:38:13 by tomoron          ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+use json::object;
+use tokio::net::TcpStream;
+use std::collections::VecDeque;
+use crate::minecraft::handshake::Handshake;
+use crate::minecraft::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(());
+        }
+
+        if self.buffer.len() + data.len() > 65536 {
+            return Err("buffer full".to_string());
+        }
+
+        let _ = self.buffer.extend(data);
+
+        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()) {
+            Err(e) => { eprintln!("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> {
+        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, packet: &mut VecDeque<u8>, packet_id: i32) -> Result<(),String> {
+        let status_response = object! {
+            "version": {
+                "name": "idk",
+                "protocol" : self.handshake.as_ref().unwrap().protocol_version,
+            },
+            "players": {
+                "max": 420,
+                "online": 69
+            },
+            "description": "§c".to_string() + &self.handshake.as_ref().unwrap().server_address.clone() + "§r:§a" + &self.handshake.as_ref().unwrap().server_port.to_string(),
+        };
+        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/minecraft/handshake.rs

@@ -0,0 +1,30 @@
+use std::collections::VecDeque;
+use crate::minecraft::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/minecraft/mod.rs

@@ -0,0 +1,7 @@
+pub mod varint;
+pub mod handshake;
+pub mod client;
+
+mod socket;
+
+pub use socket::process_mc_socket;

src/minecraft/socket.rs

@@ -0,0 +1,33 @@
+use std::io::{self, Error};
+use crate::minecraft::client::Client;
+use tokio::net::TcpStream;
+
+pub async fn process_mc_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 result = client.buffer_append((&buf[..n]).to_vec()).await;
+                if let Err(error) = result {
+                    eprintln!("mc error : {}", error);
+                    break;
+                }
+                if n == 0 {
+                    break;
+                }
+            }
+            Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
+                continue;
+            }
+            Err(e) => {
+                return Err(e.into());
+            }
+        }
+    }
+    Ok(())
+}

src/minecraft/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
+}