Handling offline login

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"

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<u128>,
+}
+
+fn check_player(player: &Player) -> Result<bool> {
+    Ok(true)
+}
+
 pub async fn respond_login(
     client_reader: &mut OwnedReadHalf,
     client_writer: &mut OwnedWriteHalf,
     server_reader: &mut OwnedReadHalf,
     server_writer: &mut OwnedWriteHalf,
 ) -> Result<bool> {
+    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<Option<Player>> {
+    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(())
 }

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,6 +71,7 @@ async fn handle_client(client_socket: TcpStream) {
             ).await.expect("Error handling status request");
             return;
         } else if handshake_packet.next_state == 2 {
+            if handshake_packet.protocol_version == mc_types::VERSION_PROTOCOL {
                 match server_writer {
                     Some(mut server_writer) => {
                         match server_reader {
@@ -81,15 +82,17 @@ async fn handle_client(client_socket: TcpStream) {
                                     &mut client_writer,
                                     &mut server_reader,
                                     &mut server_writer,
-                            )
+                                ).await.expect(
-                                .await
+                                    "Error logging into proxy or server"
-                                .expect("Error logging into backend server") {
+                                ) {
                                     handle_play(
                                         client_reader,
                                         client_writer,
                                         server_reader,
                                         server_writer,
                                     ).await;
+                                } else {
+                                    println!("Player blocked from server");
                                 }
                             },
                             None => {
@@ -110,6 +113,30 @@ async fn handle_client(client_socket: TcpStream) {
 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;
         }