tom/dockermcmgr
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

login proxy works

Browse Source
This commit is contained in:
tomoron
2026-05-20 21:37:15 +02:00
parent 21d448a90f
commit 87a0cdfdad
2 changed files with 30 additions and 36 deletions
Download Patch File Download Diff File Expand all files Collapse all files

63
src/minecraft/client.rs
View File

@ -6,7 +6,7 @@
/* By: tomoron <tomoron@student.42angouleme.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2026/05/07 17:23:09 by tomoron #+# #+# */
/* Updated: 2026/05/19 21:19:53 by tomoron ### ########.fr */
/* Updated: 2026/05/20 17:54:32 by tomoron ### ########.fr */
/* */
/* ************************************************************************** */
@ -22,6 +22,7 @@ use std::{fmt, io};
pub struct Client {
pub in_stream: TcpStream,
read_buf: Vec<u8>,
buffer: Vec<u8>,
out_stream: Option<TcpStream>,
handshake: Option<Handshake>
@ -32,6 +33,7 @@ impl Client {
Self {
in_stream: stream,
read_buf: vec![0u8; 1024 * 8],
buffer: vec![],
out_stream: None,
handshake: None
@ -39,15 +41,16 @@ impl Client {
}
pub async fn in_read(&mut self) -> Result<u8, String> {
let mut buf = vec![0 as u8; 1024];
loop
{
match self.in_stream.try_read(&mut buf) {
match self.in_stream.try_read(&mut self.read_buf) {
Ok(n) => {
println!("[{}] read {} bytes",self, n);
println!("[{}] {:?}", self, &buf[..n]);
self.buffer_append((&buf[..n]).to_vec()).await?;
if let Some(out_stream) = &self.out_stream {
let _ = out_stream.writable().await;
let _ = out_stream.try_write(&self.read_buf[..n]);
} else {
self.buffer_append((&self.read_buf[..n]).to_vec()).await?;
}
if n == 0 {
return Ok(0)
}
@ -56,7 +59,6 @@ impl Client {
return Ok(1);
}
Err(_e) => {
println!("[{}] error", self);
return Err("read failed".to_string())
}
}
@ -72,17 +74,15 @@ impl Client {
}
pub async fn out_read(&mut self) -> Result<i32, String> {
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) {
match self.out_stream.as_mut().unwrap().try_read(&mut self.read_buf) {
Ok(n) => {
let _ = self.in_stream.writable().await;
let _ = self.in_stream.try_write(&buf[..n]);
let _ = self.in_stream.try_write(&self.read_buf[..n]);
if n == 0 { Ok(0) } else { Ok(1) }
}
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
@ -90,7 +90,6 @@ impl Client {
}
Err(_e) => {
println!("try_read returned an error");
Err("Failed to read".to_string())
}
}
@ -101,14 +100,6 @@ impl Client {
return Ok(());
}
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(());
}
if self.buffer.len() + data.len() > 65536 {
return Err("buffer full".to_string());
@ -120,10 +111,19 @@ impl Client {
if self.buffer[0] == 0 {
return Err("invalid packet".to_string());
}
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()).await?;
self.buffer.drain(..len + 1);
if let Some(out_stream) = &self.out_stream {
if self.buffer.len() != 0 {
let _ = out_stream.writable().await;
let _ = out_stream.try_write(self.buffer.as_slice());
self.buffer.drain(..);
}
}
}
Ok(())
}
@ -133,7 +133,6 @@ impl Client {
sent_data.extend(data);
let _ = self.in_stream.writable().await;
println!("[{}] sending {:?}",self, sent_data);
match self.in_stream.try_write(sent_data.as_slice()) {
Err(e) => { eprintln!("error while sending response {:?}", e); },
_ => { }
@ -149,10 +148,11 @@ impl Client {
return Err("packet 0 expected. invalid packet received".to_string());
}
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());
if self.handshake.as_ref().unwrap().intent == 2 {
self.login_intent_handle(&mut packet, packet_id).await?;
}
return Ok(());
}
@ -160,8 +160,6 @@ impl Client {
if intent == 1 {
self.status_intent_handle(&mut packet, packet_id).await?;
} else if intent == 2 {
self.login_intent_handle(&mut packet, packet_id).await?;
}
Ok(())
}
@ -201,12 +199,11 @@ impl Client {
}
async fn login_intent_handle(&mut self, mut _packet: &mut VecDeque<u8>, _packet_id: i32) -> Result<(),String> {
let stream = TcpStream::connect("localhost:25566").await.map_err(|_| "failed to connect to remote host".to_string())?;
let stream = TcpStream::connect("play.hypixel.net:25565").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;
new_handshake.server_address = "play.hypixel.net".to_string();
new_handshake.server_port = 25565;
println!("{}", new_handshake);
let handshake_packet = new_handshake.to_packet();
let mut packet = Vec::new();
packet.extend(varint_write(handshake_packet.len() as i32));

3
src/minecraft/socket.rs
View File

@ -9,15 +9,12 @@ pub async fn process_mc_socket(stream: TcpStream) -> Result<(), String> {
loop {
tokio::select! {
Ok(()) = client.in_stream.readable() => {
println!("[{}] in read", client);
let res = client.in_read().await?;
if res == 0 {
break;
}
println!("[{}] continue listening", client);
}
_ = client.out_readable() => {
println!("[{}] out read", client);
let res = client.out_read().await?;
if res == 0 {
break;