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

server from db working

Browse Source
This commit is contained in:
tomoron
2026-05-31 23:59:51 +02:00
parent 2303f06fea
commit b818f7eaa3
12 changed files with 203 additions and 69 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1,8 +1,6 @@
use crate::minecraft::client::client::Client;
use crate::minecraft::varint::varint_read;
use crate::minecraft::handshake::Handshake;
use std::collections::VecDeque;
use std::io;
@ -95,28 +93,4 @@ impl Client {
Ok(())
}
async 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::from_packet(&mut packet)?);
if self.handshake.as_ref().unwrap().intent == 2 {
self.login_intent_handle(&mut packet, packet_id).await?;
}
return Ok(());
}
let intent = self.handshake.as_ref().unwrap().intent;
if intent == 1 {
self.status_intent_handle(&mut packet, packet_id).await?;
}
Ok(())
}
}

51
src/minecraft/client/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/30 00:27:19 by tomoron ### ########.fr */
/* Updated: 2026/05/31 23:23:05 by tomoron ### ########.fr */
/* */
/* ************************************************************************** */
@ -15,6 +15,8 @@ use crate::minecraft::handshake::Handshake;
use crate::minecraft::varint::varint_write;
use std::fmt;
use crate::models::Servers;
pub struct Client {
pub in_stream: TcpStream,
@ -22,11 +24,22 @@ pub struct Client {
pub buffer: Vec<u8>,
pub out_stream: Option<TcpStream>,
pub handshake: Option<Handshake>,
pub closed: bool,
pub server: Option<Result<Servers,diesel::result::Error>>,
pub dbPool: DbPool
}
use crate::DbPool;
use crate::schema;
use crate::models;
use diesel::prelude::*;
use regex::Regex;
impl Client {
pub fn create(stream: TcpStream, pool: DbPool) -> Self {
Self {
@ -37,20 +50,40 @@ impl Client {
out_stream: None,
handshake: None,
closed: false,
server: None,
dbPool: pool
}
}
pub 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); },
_ => { }
pub async fn get_server(&self) -> Result<Servers, diesel::result::Error> {
println!("get server name from domain : {}", self.handshake.as_ref().unwrap().server_address);
if let None = self.handshake {
panic!("get server called without a handshake");
}
let conn = &mut self.dbPool.get().unwrap();
let reg = Regex::new(r"^(?:([a-zA-Z-_]*)\.)?mc\.tmoron\.fr$").unwrap();
let mut found: Option<String> = None;
if let Some(capture) = reg.captures(&self.handshake.as_ref().unwrap().server_address) {
if let Some(captured_str) = capture.get(1) {
found = Some(captured_str.as_str().to_string());
}
}
if let Some(name) = found {
println!("found server name : {}", name);
schema::servers::table.filter(schema::servers::name.eq(name)).select(models::Servers::as_select()).first(conn)
} else {
schema::servers::table.filter(schema::servers::is_default.eq(true)).select(models::Servers::as_select()).first(conn)
}
}
}

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

@ -1,26 +1,24 @@
use crate::minecraft::client::client::Client;
use json::object;
use crate::minecraft::varint::varint_write;
use std::collections::VecDeque;
use tokio::net::TcpStream;
impl Client {
pub async fn login_intent_handle(&mut self, mut _packet: &mut VecDeque<u8>, _packet_id: i32) -> Result<(),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 = "play.hypixel.net".to_string();
new_handshake.server_port = 25565;
let reason_json = object! {
"type": "text",
"text": "login to start not implemented yet",
"color": "red"
};
let mut response: Vec<u8> = vec![];
let response_json = json::stringify(reason_json);
let mut response_json_len = varint_write(response_json.len() as i32);
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);
response.append(&mut response_json_len);
response.append(&mut response_json.as_bytes().into());
self.send_packet(0x0, response).await;
Ok(())
}
}

1
src/minecraft/client/mod.rs
View File

@ -2,3 +2,4 @@ pub mod client;
mod buffer;
mod status;
mod login;
mod packet;

80
src/minecraft/client/packet.rs Normal file
View File

@ -0,0 +1,80 @@
use crate::minecraft::client::client::Client;
use crate::minecraft::varint::{varint_read, varint_write};
use crate::minecraft::handshake::Handshake;
use crate::models;
use crate::status::ServerStatus;
use std::collections::VecDeque;
use diesel::result::Error::NotFound;
use tokio::net::TcpStream;
impl Client {
pub async 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::from_packet(&mut packet)?);
self.server = Some(self.get_server().await);
// if self.server.as_ref().unwrap().status == ServerStatus::Running {
// return self.proxy_start().await;
// }
if self.handshake.as_ref().unwrap().intent == 2 {
self.login_intent_handle(&mut packet, packet_id).await?;
}
return Ok(());
}
let intent = self.handshake.as_ref().unwrap().intent;
if intent == 1 {
self.status_intent_handle(&mut packet, packet_id).await?;
}
Ok(())
}
pub async fn send_packet(&self, packet_id: i32, data: Vec<u8>) {
let sent_id = varint_write(packet_id);
let mut sent_data: Vec<u8> = vec![];
sent_data.extend(varint_write((data.len() + sent_id.len()) as i32));
sent_data.extend(sent_id);
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); },
_ => { }
}
}
async fn proxy_start(&mut self) -> Result<(),String> {
println!("[{}] starting proxy mode", self);
// let stream = TcpStream::connect(&self.server.as_ref().unwrap().redirect_ip.as_ref().unwrap()).await
let stream = TcpStream::connect("play.hypixel.net").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 = "play.hypixel.net".to_string();
new_handshake.server_port = 25565;
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(())
}
}

37
src/minecraft/client/status.rs
View File

@ -1,5 +1,10 @@
use crate::minecraft::client::client::Client;
use diesel::prelude::*;
use diesel::result::Error::NotFound;
use crate::schema;
use crate::models;
use json::object;
use crate::minecraft::varint::varint_write;
@ -16,27 +21,47 @@ impl Client {
"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(),
"description": self.get_description().await,
};
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());
println!("[{}] sent status response to client", self);
self.send_packet(response).await;
self.send_packet(0x0, response).await;
} else if packet_id == 1 {
let mut response = varint_write(1);
let mut response = vec![];
response.extend(packet.drain(..));
self.send_packet(response).await;
self.send_packet(0x1, response).await;
println!("[{}] sent ping response to client", self);
}
Ok(())
}
pub async fn get_description(&self) -> String {
if let None = self.server {
"How did you send a status request without a handshake ???".to_string();
}
match self.server.as_ref().unwrap() {
Ok(server) => {
let login = match server.last_login {
Some(date) => { format!("{:?}", date) },
None => { "never".to_string() }
};
format!("§fServer is {}\nlast login: {}", server.status, login)
},
Err(NotFound) => { "§cThis server does not exist".to_string() },
Err(error) => { format!("§cAn error occured while retreiving the information:\n{}", error) }
}
}
}

3
src/minecraft/socket.rs
View File

@ -23,6 +23,9 @@ pub async fn process_mc_socket(stream: TcpStream, pool: DbPool) -> Result<(), St
}
}
}
if client.closed {
break;
}
}
Ok(())
}