From bc4c7544acd6f5cf6fa5d4c152e48b76bbb33418 Mon Sep 17 00:00:00 2001 From: Kyler <59854022+KylerOlsen@users.noreply.github.com> Date: Sun, 24 Dec 2023 22:37:51 -0700 Subject: [PATCH] Handling offline login --- Cargo.toml | 2 +- src/login_handle.rs | 78 ++++++++++++++++++++++++++++++++++++++--- src/main.rs | 85 +++++++++++++++++++++++++++++---------------- 3 files changed, 131 insertions(+), 34 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index a16c7cf..ae95b37 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -8,7 +8,7 @@ license = "MIT" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies] -purple_cello_mc_protocol = { git = "https://github.com/PurpleCelloServer/purple_cello_mc_protocol.git" } +purple_cello_mc_protocol = { git = "https://github.com/PurpleCelloServer/purple_cello_mc_protocol.git", rev = "b1a8cfdc91657566d68fb6f7dbc71bdee390cc9e" } tokio = { version = "1", features = ["full"] } serde = { version = "1", features = ["derive"] } serde_json = "1" diff --git a/src/login_handle.rs b/src/login_handle.rs index a1cdb32..797798c 100644 --- a/src/login_handle.rs +++ b/src/login_handle.rs @@ -1,8 +1,6 @@ // Yeahbut December 2023 use tokio::net::tcp::{OwnedReadHalf, OwnedWriteHalf}; -use tokio::io; -use std::error::Error; use purple_cello_mc_protocol::{ mc_types::{self, Result, Packet}, @@ -10,17 +8,89 @@ use purple_cello_mc_protocol::{ login, }; +struct Player { + name: String, + player_uuid: Option, +} + +fn check_player(player: &Player) -> Result { + Ok(true) +} + pub async fn respond_login( client_reader: &mut OwnedReadHalf, client_writer: &mut OwnedWriteHalf, server_reader: &mut OwnedReadHalf, server_writer: &mut OwnedWriteHalf, -)-> Result { +) -> Result { + let proxy_login = login_to_proxy(client_reader).await?; + match proxy_login { + Some(player) => { + login_to_backend( + player, + client_writer, + server_reader, + server_writer, + ).await?; + return Ok(true) + }, + None => return Ok(false) + } +} + +async fn login_to_proxy( + client_reader: &mut OwnedReadHalf, +) -> Result> { + println!("Logging into proxy"); + + let start_packet = + login::serverbound::LoginStart::read(client_reader).await?; + + let player: Player = Player { + name: start_packet.name, + player_uuid: start_packet.player_uuid, + }; + + if check_player(&player)? { + println!("Player allowed"); + Ok(Some(player)) + } else { + println!("Player blocked"); + Ok(None) + } +} + +async fn login_to_backend( + player: Player, + client_writer: &mut OwnedWriteHalf, + server_reader: &mut OwnedReadHalf, + server_writer: &mut OwnedWriteHalf, +) -> Result<()> { + println!("Logging into backend"); handshake::serverbound::Handshake { protocol_version: mc_types::VERSION_PROTOCOL, server_address: "localhost".to_string(), server_port: 25565, next_state: 2, }.write(server_writer).await?; - Ok(true) + + println!("Login start"); + login::serverbound::LoginStart { + name: player.name, + player_uuid: player.player_uuid, + }.write(server_writer).await?; + + println!("Finishing backend login"); + let packet = login::clientbound::LoginSuccess::read(server_reader).await?; + + println!("Finishing proxy login"); + login::clientbound::LoginSuccess { + uuid: packet.uuid.clone(), + username: packet.username.clone(), + properties: packet.properties.clone(), + }.write(client_writer).await?; + + println!("Client logged in"); + + Ok(()) } diff --git a/src/main.rs b/src/main.rs index c50fc8b..dfe7daa 100644 --- a/src/main.rs +++ b/src/main.rs @@ -5,7 +5,7 @@ use tokio::io; use std::error::Error; use purple_cello_mc_protocol::{ - mc_types::Packet, + mc_types::{self, Packet}, handshake, login, }; @@ -71,45 +71,72 @@ async fn handle_client(client_socket: TcpStream) { ).await.expect("Error handling status request"); return; } else if handshake_packet.next_state == 2 { - match server_writer { - Some(mut server_writer) => { - match server_reader { - Some(mut server_reader) => { + if handshake_packet.protocol_version == mc_types::VERSION_PROTOCOL { + match server_writer { + Some(mut server_writer) => { + match server_reader { + Some(mut server_reader) => { - if login_handle::respond_login( - &mut client_reader, - &mut client_writer, - &mut server_reader, - &mut server_writer, - ) - .await - .expect("Error logging into backend server") { + if login_handle::respond_login( + &mut client_reader, + &mut client_writer, + &mut server_reader, + &mut server_writer, + ).await.expect( + "Error logging into proxy or server" + ) { handle_play( client_reader, client_writer, server_reader, server_writer, ).await; + } else { + println!("Player blocked from server"); } - }, - None => { - eprintln!( - "Failed to connect to the backend server"); - return; + }, + None => { + eprintln!( + "Failed to connect to the backend server"); + return; + } + }; + }, + None => { + login::clientbound::Disconnect { + reason: "\"Server Error (Server may be starting)\"" + .to_string() } - }; - }, - None => { - login::clientbound::Disconnect { - reason: "\"Server Error (Server may be starting)\"" - .to_string() - } - .write(&mut client_writer) - .await - .expect("Error sending disconnect on: \ + .write(&mut client_writer) + .await + .expect("Error sending disconnect on: \ Failed to connect to the backend server"); + } + }; + } + else + if handshake_packet.protocol_version < mc_types::VERSION_PROTOCOL { + println!("Client on outdated version"); + login::clientbound::Disconnect { + reason: format!( + "\"Client Error: Outdated Version (I'm on {})\"", + mc_types::VERSION_NAME, + ).to_string() } - }; + .write(&mut client_writer).await.expect( + "Error sending disconnect on: Client on wrong version"); + // if handshake_packet.protocol_version > mc_types::VERSION_PROTOCOL + } else { + println!("Client on future version"); + login::clientbound::Disconnect { + reason: format!( + "\"Client Error: Future Version (I'm on {})\"", + mc_types::VERSION_NAME, + ).to_string() + } + .write(&mut client_writer).await.expect( + "Error sending disconnect on: Client on wrong version"); + } } else { return; }