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")
+    }
+}