diff --git a/src/minecraft/client.rs b/src/minecraft/client.rs index 6eda7ab..9675a3a 100644 --- a/src/minecraft/client.rs +++ b/src/minecraft/client.rs @@ -6,7 +6,7 @@ /* By: tomoron +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* 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) -> Result<(),String> { - if data.len() == 0 { - return Ok(()); + pub async fn in_read(&mut self) -> Result { + let mut buf = vec![0 as u8; 100]; + + 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 { - self.stream_data(data); - return Ok(()); + pub async fn out_read(&mut self) -> Result { + let mut buf = vec![0 as u8; 1024]; + + 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) -> Result { + 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) { + async fn send_packet(&self, data: Vec) { let mut sent_data: Vec = 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) { - panic!("proxy not implemented") - } - - fn handle_packet(&mut self, mut packet: VecDeque) -> Result<(), String> { + async fn handle_packet(&mut self, mut packet: VecDeque) -> 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, packet_id: i32) -> Result<(),String> { + async fn status_intent_handle(&self, packet: &mut VecDeque, 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, _packet_id: i32) -> Result<(),String> { - panic!("not implemented") + async fn login_intent_handle(&mut self, mut _packet: &mut VecDeque, _packet_id: i32) -> Result<(),String> { + 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()) + } } } diff --git a/src/minecraft/handshake.rs b/src/minecraft/handshake.rs index 905f92a..03343f7 100644 --- a/src/minecraft/handshake.rs +++ b/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) -> Result { + pub fn from_packet(mut packet: &mut VecDeque) -> Result { 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 { + 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 + ) + } } diff --git a/src/minecraft/socket.rs b/src/minecraft/socket.rs index 72370fe..bec5bbe 100644 --- a/src/minecraft/socket.rs +++ b/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<()> { - let mut buf = vec![0 as u8; 1024]; +pub async fn process_mc_socket(stream: TcpStream) -> Result<(), String> { + println!("new client {:?}", stream); 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); + tokio::select! { + Ok(()) = client.in_stream.readable() => { + println!("[{}] in read", client); + let res = client.in_read().await?; + if res == 0 { 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(()) } + diff --git a/src/rpc/actions/mod.rs b/src/rpc/actions/mod.rs index 93fa0d3..c062485 100644 --- a/src/rpc/actions/mod.rs +++ b/src/rpc/actions/mod.rs @@ -1,2 +1,2 @@ mod ping; -pub use ping::ping; +//pub use ping::ping; diff --git a/src/rpc/actions/ping.rs b/src/rpc/actions/ping.rs index 8f02d22..ec48402 100644 --- a/src/rpc/actions/ping.rs +++ b/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 { +// +//}