WIP, borked

src/minecraft/client.rs

@@ -6,7 +6,7 @@
 /*   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       */
+/*   Updated: 2026/05/19 18:57:29 by tomoron          ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -15,6 +15,7 @@ use tokio::net::TcpStream;
 use std::collections::VecDeque;
 use crate::minecraft::handshake::Handshake;
 use crate::minecraft::varint::{varint_read, varint_write};
+use std::{fmt, io};
 
 pub struct Client {
     pub in_stream: TcpStream,
@@ -35,15 +36,76 @@ impl Client {
         }
     }
 
-    pub async fn buffer_append(&mut self, data: Vec<u8>) -> Result<(),String> {
+    pub async fn in_read(&mut self) -> Result<u8, String> {
-        if data.len() == 0 {
+        let mut buf = vec![0 as u8; 100];
-            return Ok(());
+
+        loop
+        {
+            match self.in_stream.try_read(&mut buf) {
+                Ok(n) => {
+                    println!("[{}] read {} bytes",self, n);
+                    println!("[{}] {:?}", self, &buf[..n]);
+                    self.buffer_append((&buf[..n]).to_vec()).await?;
+                    if n == 0 {
+                        return Ok(0)
+                    }
+                }
+                Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
+                    return Ok(1);
+                }
+                Err(_e) => {
+                    println!("[{}] error", self);
+                    return Err("read failed".to_string())
+                }
+            }
         }
+    }
 
+    pub async fn out_readable(&self) {
+        if let Some(stream) = &self.out_stream {
+            stream.readable().await.expect("readable call failed");
+        } else {
+            std::future::pending::<()>().await;
+        };
+    }
 
-        if let Some(_) = &self.out_stream {
+    pub async fn out_read(&mut self) -> Result<i32, String> {
-            self.stream_data(data);
+        let mut buf = vec![0 as u8; 1024];
-            return Ok(());
+
+        if let None = self.out_stream {
+            return Ok(1);
+        }
+        
+
+        match self.out_stream.as_mut().unwrap().try_read(&mut buf) {
+            Ok(n) => {
+                let _ = self.in_stream.writable().await;
+                let _ = self.in_stream.try_write(&buf[..n]);
+                if n == 0 { Ok(0) } else { Ok(1) }
+            }
+            Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
+                Ok(1)
+            }
+
+            Err(_e) => {
+                println!("try_read returned an error");
+                Err("Failed to read".to_string())
+            }
+        }
+    }
+
+    pub async fn buffer_append(&mut self, data: Vec<u8>) -> Result<u8,String> {
+        if data.len() == 0 {
+            return Ok(0);
+        }
+        
+        println!("[{}] buffer handling", self);
+
+        if let Some(out_stream) = &self.out_stream {
+            println!("[{}] out stream present passing buffer", self);
+            let _ = out_stream.writable().await;
+            let _ = out_stream.try_write(&data);
+            return Ok(0);
         }
 
         if self.buffer.len() + data.len() > 65536 {
@@ -57,48 +119,53 @@ impl Client {
         }
 
         if self.buffer.len() - 1 >= self.buffer[0] as usize {
+            println!("[{}] valid packet received", self);
             let len = varint_read(&mut self.buffer.clone().into())? as usize;
-            self.handle_packet(self.buffer[1..=len].to_vec().into())?;
+            self.handle_packet(self.buffer[1..=len].to_vec().into()).await?;
             self.buffer.drain(..len + 1);
+            return Ok(1);
         }
-        Ok(())
+        Ok(0)
     }
 
-    fn send_packet(&self, data: Vec<u8>) {
+    async fn send_packet(&self, data: Vec<u8>) {
         let mut sent_data: Vec<u8> = varint_write(data.len() as i32);
 
         sent_data.extend(data);
+        let _ = self.in_stream.writable().await;
         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>) {
+    async fn handle_packet(&mut self, mut packet: VecDeque<u8>) -> Result<(), String> {
-        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)?);
+            self.handshake = Some(Handshake::from_packet(&mut packet)?);
+            use std::os::unix::io::AsRawFd;
+            let fd = self.in_stream.as_raw_fd();
+            println!("{} => {}", fd, self);
+            println!("[{}] got {}",self, self.handshake.as_ref().unwrap());
             return Ok(());
         }
 
         let intent = self.handshake.as_ref().unwrap().intent;
 
         if intent == 1 {
-            self.status_intent_handle(&mut packet, packet_id)?;
+            self.status_intent_handle(&mut packet, packet_id).await?;
         } else if intent == 2 {
-            self.login_intent_handle(&mut packet, packet_id)?;
+            self.login_intent_handle(&mut packet, packet_id).await?;
         }
         Ok(())
     }
 
-    fn status_intent_handle(&self, packet: &mut VecDeque<u8>, packet_id: i32) -> Result<(),String> {
+    async fn status_intent_handle(&self, packet: &mut VecDeque<u8>, packet_id: i32) -> Result<(),String> {
         let status_response = object! {
             "version": {
                 "name": "idk",
@@ -120,17 +187,46 @@ impl Client {
             response.append(&mut response_packet_id);
             response.append(&mut response_json_len);
             response.append(&mut response_json.as_bytes().into());
+            println!("[{}] sent status response to client", self);
 
-            self.send_packet(response);
+            self.send_packet(response).await;
         } else if packet_id == 1 {
             let mut response = varint_write(1);
             response.extend(packet.drain(..));
-            self.send_packet(response);
+            self.send_packet(response).await;
+            println!("[{}] sent ping response to client", self);
         }
         Ok(())
     }
 
-    fn login_intent_handle(&self, mut _packet: &mut VecDeque<u8>, _packet_id: i32) -> Result<(),String> {
+    async fn login_intent_handle(&mut self, mut _packet: &mut VecDeque<u8>, _packet_id: i32) -> Result<(),String> {
-        panic!("not implemented")
+        let stream = TcpStream::connect("localhost:25566").await.map_err(|_| "failed to connect to remote host".to_string())?;
+        let mut new_handshake = self.handshake.as_ref().unwrap().clone();
+        new_handshake.server_address = "localhost".to_string();
+        new_handshake.server_port = 25566;
+
+        println!("{}", new_handshake);
+        let handshake_packet = new_handshake.to_packet();
+        let mut packet = Vec::new();
+        packet.extend(varint_write(handshake_packet.len() as i32));
+        packet.extend(handshake_packet);
+
+        self.out_stream = Some(stream);
+        let _ = self.out_stream.as_ref().unwrap().writable().await;
+
+        let _ = self.out_stream.as_ref().unwrap().try_write(packet.as_slice());
+        println!("[{}] sent handshake to server", self);
+        Ok(())
+    }
+}
+
+impl fmt::Display for Client {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if let Some(handshake) = &self.handshake {
+            write!(f, "{}", handshake.server_address)
+        } else {
+            use std::os::unix::io::AsRawFd;
+            write!(f, "{}", self.in_stream.as_raw_fd())
+        }
     }
 }

src/minecraft/handshake.rs

@@ -1,6 +1,8 @@
 use std::collections::VecDeque;
-use crate::minecraft::varint::varint_read;
+use std::fmt;
+use crate::minecraft::varint::{varint_read, varint_write};
 
+#[derive(Clone)]
 pub struct Handshake {
     pub protocol_version: i32,
     pub server_address: String,
@@ -9,7 +11,7 @@ pub struct Handshake {
 }
 
 impl Handshake {
-    pub fn parse(mut packet: &mut VecDeque<u8>) -> Result<Self, String> {
+    pub fn from_packet(mut packet: &mut VecDeque<u8>) -> Result<Self, String> {
         let protocol_version = varint_read(&mut packet)?;
 
         let str_len = varint_read(&mut packet)? as usize;
@@ -27,4 +29,33 @@ impl Handshake {
             intent
         })
     }
+
+
+    pub fn to_packet(&self) -> Vec<u8> {
+        let mut packet = Vec::new();
+        packet.extend(varint_write(0));
+        packet.extend(varint_write(self.protocol_version));
+        let address_bytes = self.server_address.as_bytes();
+        packet.extend(varint_write(address_bytes.len() as i32));
+        packet.extend(address_bytes);
+        packet.extend(self.server_port.to_be_bytes());
+        packet.extend(varint_write(self.intent));
+        packet
+    }
+}
+
+impl fmt::Display for Handshake {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let intent_str = match self.intent {
+            1 => "status",
+            2 => "login",
+            3 => "Transfer",
+            _ => "unknown",
+        };
+        write!(
+            f,
+            "Handshake {{ protocol_version: {}, server_address: \"{}\", server_port: {}, intent: {} ({}) }}",
+            self.protocol_version, self.server_address, self.server_port, self.intent, intent_str
+        )
+    }
 }

src/minecraft/socket.rs

@@ -1,33 +1,30 @@
-use std::io::{self, Error};
 use crate::minecraft::client::Client;
 use tokio::net::TcpStream;
 
-pub async fn process_mc_socket(stream: TcpStream) -> io::Result<()> {
+pub async fn process_mc_socket(stream: TcpStream) -> Result<(), String> {
-    let mut buf = vec![0 as u8; 1024];
+    println!("new client {:?}", stream);
 
     let mut client = Client::create(stream);
 
     loop {
-        client.in_stream.readable().await?;
+        tokio::select! {
-
+            Ok(()) = client.in_stream.readable() => {
-        match client.in_stream.try_read(&mut buf) {
+                println!("[{}] in read", client);
-            Ok(n) => {
+                let res = client.in_read().await?;
-                let result = client.buffer_append((&buf[..n]).to_vec()).await;
+                if res == 0 {
-                if let Err(error) = result {
-                    eprintln!("mc error : {}", error);
                     break;
                 }
-                if n == 0 {
+                println!("[{}] continue listening", client);
+            }
+            _ = client.out_readable() => {
+                println!("[{}] out read", client); 
+                let res = client.out_read().await?;
+                if res == 0 {
                     break;
                 }
             }
-            Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
-                continue;
-            }
-            Err(e) => {
-                return Err(e.into());
-            }
         }
     }
     Ok(())
 }
+

src/rpc/actions/mod.rs

@@ -1,2 +1,2 @@
 mod ping;
-pub use ping::ping;
+//pub use ping::ping;

src/rpc/actions/ping.rs

@@ -1,5 +1,5 @@
 use json::object;
 
-pub fn ping(data: json::object) -> json::object {
+//pub fn ping(data: json::object) -> json::object {
-    
+//    
-}
+//}