PurpleCelloServer
/
reverse_proxy
mirror of https://github.com/PurpleCelloServer/reverse_proxy.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Handling offline login

This commit is contained in:
Kyler 2023-12-24 22:37:51 -07:00
parent cf377ec1c8
commit bc4c7544ac
3 changed files with 131 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Cargo.toml
View File

@ -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"

78
src/login_handle.rs
View File

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

85
src/main.rs
View File

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