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

WIP, borked

Browse Source
This commit is contained in:
tomoron
2026-05-19 18:59:52 +02:00
parent 20ce06657d
commit 1de458dc54
5 changed files with 170 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files

142
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/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> {
if data.len() == 0 {
return Ok(());
pub async fn in_read(&mut self) -> Result<u8, String> {
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<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) {
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>) {
panic!("proxy not implemented")
}
fn handle_packet(&mut self, mut packet: VecDeque<u8>) -> Result<(), String> {
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::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> {
panic!("not implemented")
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 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())
}
}
}

35
src/minecraft/handshake.rs
View File

@ -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
)
}
}

31
src/minecraft/socket.rs
View File

@ -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(())
}

2
src/rpc/actions/mod.rs
View File

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

6
src/rpc/actions/ping.rs
View File

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