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

fix multiple packet in single handle_buffer call, set server as stopped when proxy connection failed and container can't be found

Browse Source
This commit is contained in:
tomoron
2026-06-11 18:33:38 +02:00
parent 5ccac4f3d4
commit 0bbb8b3245
8 changed files with 79 additions and 28 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
src/minecraft/client/buffer.rs
View File

@ -79,33 +79,35 @@ impl Client {
let _ = self.buffer.extend(data);
let varint_buffer_len = min(self.buffer.len(), 5);
let mut varint_buffer: VecDeque<u8> = self.buffer[..varint_buffer_len].to_vec().into();
println!("varint_buffer : {:?}", varint_buffer);
let expected_len = varint_read(&mut varint_buffer)?;
let varint_len = varint_buffer_len - varint_buffer.len();
loop {
if self.buffer.len() == 0 {
break;
}
println!("expected len : {}, current len : {}", expected_len as usize, self.buffer.len());
println!("buffer : {:?}", self.buffer);
let varint_buffer_len = min(self.buffer.len(), 5);
let mut varint_buffer: VecDeque<u8> = self.buffer[..varint_buffer_len].to_vec().into();
let expected_len = varint_read(&mut varint_buffer)?;
let varint_len = varint_buffer_len - varint_buffer.len();
println!("current len : {}, expected_len : {}", self.buffer.len() -varint_len, expected_len);
if self.buffer.len() - varint_len < expected_len as usize {
break ;
}
println!("buffer : {:?}", self.buffer);
while self.buffer.len() != 0 && self.buffer.len() - 1 >= expected_len as usize {
if self.buffer[0] == 0 {
return Err("invalid packet".to_string());
}
println!("valid packet found, handling");
println!("varint len : {}", varint_len);
println!("len : {}", expected_len);
self.handle_packet(self.buffer[varint_len..=(expected_len as usize)].to_vec().into()).await?;
self.buffer.drain(..(expected_len as usize + varint_len));
println!("buffer after handle : {:?}", self.buffer);
if let Some(out_stream) = &self.out_stream {
println!("out stream present , sending the {} remaining bytes", self.buffer.len());
if self.buffer.len() != 0 {
let _ = out_stream.writable().await.map_err(|e| format!("out stream writable call failed : {}", e))?;
let _ = out_stream.try_write(self.buffer.as_slice()).map_err(|e| format!("Failed to send remaining buffer to out stream : {}", e))?;

41
src/minecraft/client/client.rs
View File

@ -6,13 +6,14 @@
/* By: tomoron <tomoron@student.42angouleme.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2026/05/07 17:23:09 by tomoron #+# #+# */
/* Updated: 2026/06/11 12:21:51 by tomoron ### ########.fr */
/* Updated: 2026/06/11 17:25:09 by tomoron ### ########.fr */
/* */
/* ************************************************************************** */
use bollard::Docker;
use tokio::net::TcpStream;
use crate::minecraft::handshake::Handshake;
use crate::status::ServerStatus;
use std::fmt;
use crate::models::Servers;
@ -25,6 +26,8 @@ use diesel::prelude::*;
use regex::Regex;
use chrono::Utc;
pub struct Client {
pub in_stream: TcpStream,
@ -92,6 +95,42 @@ impl Client {
}
pub async fn update_last_login(&mut self) {
use schema::servers::dsl::*;
let server = match self.server.as_ref().unwrap() {
Ok(server) => {server},
Err(_) => { return; },
};
let conn = &mut self.db_pool.get().unwrap();
if self.handshake.as_ref().unwrap().intent == 2 {
match diesel::update(servers).filter(name.eq(&server.name)).set(last_login.eq(Utc::now().naive_utc())).execute(conn) {
Err(e) => { eprintln!("Failed to set last login time : {}",e); },
Ok(_) => {},
};
}
}
pub async fn check_online(&mut self) {
use schema::servers::dsl::*;
let server = match self.server.as_ref().unwrap() {
Ok(server) => { server },
Err(_) => { return; },
};
let conn = &mut self.db_pool.get().unwrap();
match self.docker.inspect_container(&format!("minecraft-{}", server.name), None).await {
Ok(_) => { return; },
Err(_) => {
let _ = diesel::update(servers).filter(name.eq(&server.name)).set(status.eq(ServerStatus::Stopped)).execute(conn);
},
};
}
}
impl fmt::Display for Client {

4
src/minecraft/client/login.rs
View File

@ -5,7 +5,9 @@ use json::object;
use crate::minecraft::varint::varint_write;
use std::collections::VecDeque;
use crate::dockermgr;
use crate::{ dockermgr };
impl Client {
pub async fn login_intent_handle(&mut self, mut _packet: &mut VecDeque<u8>, _packet_id: i32) -> Result<(),String> {

17
src/minecraft/client/packet.rs
View File

@ -7,6 +7,7 @@ use std::collections::VecDeque;
use tokio::net::TcpStream;
impl Client {
pub async fn handle_packet(&mut self, mut packet: VecDeque<u8>) -> Result<(), String> {
println!("packet len : {}", packet.len());
@ -19,6 +20,9 @@ impl Client {
}
self.handshake = Some(Handshake::from_packet(&mut packet)?);
self.server = Some(self.get_server().await);
self.update_last_login().await;
if let Some(Ok(server)) = &self.server {
if server.status == ServerStatus::Running {
return self.proxy_start().await;
@ -62,8 +66,15 @@ impl Client {
let split_ip = redirect_ip.split_once(":");
let domain : String = split_ip.unwrap_or_else(|| (redirect_ip, "")).0.to_string();
let port : u16 = split_ip.unwrap_or_else(|| ("", "25565")).1.parse().map_err(|e| format!("Failed to parse redirect_ip : {}", e))?;
let stream = TcpStream::connect(redirect_ip).await
.map_err(|_| "failed to connect to remote host".to_string())?;
let stream = match TcpStream::connect(redirect_ip).await {
Ok(stream) => {stream},
Err(e) => {
self.check_online().await;
return Err(format!("failed to connect to remote host : {}", e));
},
};
let mut new_handshake = self.handshake.as_ref().unwrap().clone();
if server.simple_redirect {
@ -90,3 +101,5 @@ impl Client {
Ok(())
}
}