MeexReay/meexprox
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

events

Browse Source
This commit is contained in:
MeexReay 2024-07-17 17:26:22 +03:00
parent d125b94661
commit 968395af9c
4 changed files with 479 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
Cargo.lock generated
View File

@ -53,6 +53,17 @@ dependencies = [
"powerfmt",
]
[[package]]
name = "derivative"
version = "2.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fcc3dd5e9e9c0b295d6e1e4d811fb6f157d5ffd784b8d202fc62eac8035a770b"
dependencies = [
"proc-macro2",
"quote",
"syn 1.0.109",
]
[[package]]
name = "equivalent"
version = "1.0.1"
@ -135,6 +146,7 @@ checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
name = "meexprox"
version = "0.1.0"
dependencies = [
"derivative",
"log",
"rust_mc_proto",
"serde_yml",
@ -243,7 +255,7 @@ checksum = "e0cd7e117be63d3c3678776753929474f3b04a43a080c744d6b0ae2a8c28e222"
dependencies = [
"proc-macro2",
"quote",
"syn",
"syn 2.0.71",
]
[[package]]
@ -285,6 +297,17 @@ dependencies = [
"time",
]
[[package]]
name = "syn"
version = "1.0.109"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
dependencies = [
"proc-macro2",
"quote",
"unicode-ident",
]
[[package]]
name = "syn"
version = "2.0.71"

1
Cargo.toml
View File

@ -9,3 +9,4 @@ rust_mc_proto = "0.1.15"
uuid = "1.10.0"
log = "0.4.22"
simplelog = "0.12.2"
derivative = "2.2.0"

491
src/lib.rs
View File

@ -1,3 +1,4 @@
use derivative::Derivative;
use log::{error, info};
use rust_mc_proto::{
DataBufferReader, DataBufferWriter, MinecraftConnection, Packet, ProtocolError, Zigzag,
@ -12,11 +13,11 @@ use std::{
};
use uuid::Uuid;
#[derive(Clone)]
#[derive(Clone, Debug)]
pub struct ProxyServer {
pub name: String,
pub host: String,
pub forced_host: Option<String>,
name: String,
host: String,
forced_host: Option<String>,
}
impl ProxyServer {
@ -33,6 +34,7 @@ impl ProxyServer {
pub enum ProxyError {
ConfigParse,
ServerConnect,
EventChanged,
}
impl std::fmt::Display for ProxyError {
@ -61,13 +63,13 @@ pub enum PlayerForwarding {
#[derive(Clone)]
pub struct ProxyConfig {
pub host: String,
pub servers: Vec<ProxyServer>,
pub default_server: Option<ProxyServer>,
pub talk_host: Option<String>,
pub talk_secret: Option<String>,
pub player_forwarding: PlayerForwarding,
pub no_pf_for_ip_connect: bool,
host: String,
servers: Vec<ProxyServer>,
default_server: Option<ProxyServer>,
talk_host: Option<String>,
talk_secret: Option<String>,
player_forwarding: PlayerForwarding,
no_pf_for_ip_connect: bool,
}
impl ProxyConfig {
@ -173,15 +175,19 @@ impl ProxyConfig {
}
}
#[derive(Derivative)]
#[derivative(Debug)]
pub struct ProxyPlayer {
pub client_conn: MinecraftConnection<TcpStream>,
pub server_conn: MinecraftConnection<TcpStream>,
pub name: Option<String>,
pub uuid: Option<Uuid>,
pub protocol_version: u16,
pub server: Option<ProxyServer>,
pub shared_secret: Option<Vec<u8>>,
pub verify_token: Option<Vec<u8>>,
#[derivative(Debug = "ignore")]
client_conn: MinecraftConnection<TcpStream>,
#[derivative(Debug = "ignore")]
server_conn: MinecraftConnection<TcpStream>,
name: Option<String>,
uuid: Option<Uuid>,
protocol_version: u16,
server: Option<ProxyServer>,
shared_secret: Option<Vec<u8>>,
verify_token: Option<Vec<u8>>,
}
impl ProxyPlayer {
@ -208,12 +214,23 @@ impl ProxyPlayer {
}
pub fn connect_to_ip(
player: Arc<Mutex<Self>>,
this: Arc<Mutex<MeexProx>>,
player: PlayerMutex,
this: MeexProxMutex,
ip: &str,
server_address: &str,
server_port: u16,
) -> Result<(), Box<dyn Error>> {
let ProxyEvent::PlayerConnectingIPEvent { player: _, ip } = this
.lock()
.unwrap()
.trigger_event(ProxyEvent::PlayerConnectingIPEvent {
player: player.clone(),
ip: ip.to_string(),
})
else {
return Ok(());
};
Self::connect_to_stream(
player,
this,
@ -225,12 +242,23 @@ impl ProxyPlayer {
}
pub fn connect_to_server(
player: Arc<Mutex<Self>>,
this: Arc<Mutex<MeexProx>>,
player: PlayerMutex,
this: MeexProxMutex,
server: ProxyServer,
server_address: &str,
server_port: u16,
) -> Result<(), Box<dyn Error>> {
let ProxyEvent::PlayerConnectingServerEvent { player: _, server } = this
.lock()
.unwrap()
.trigger_event(ProxyEvent::PlayerConnectingServerEvent {
player: player.clone(),
server,
})
else {
return Ok(());
};
Self::connect_to_stream(
player,
this,
@ -242,8 +270,8 @@ impl ProxyPlayer {
}
pub fn connect_to_stream(
player: Arc<Mutex<Self>>,
this: Arc<Mutex<MeexProx>>,
player: PlayerMutex,
this: MeexProxMutex,
stream: TcpStream,
server: Option<ProxyServer>,
server_address: &str,
@ -290,23 +318,35 @@ impl ProxyPlayer {
{
let locked = player.lock().unwrap();
match locked.name.as_ref() {
Some(player_name) => match locked.uuid.as_ref() {
Some(player_uuid) => {
if let Some(player_name) = locked.name.as_ref() {
if let Some(player_uuid) = locked.uuid.as_ref() {
let login_packet = Packet::build(0x00, move |login| {
login.write_string(&player_name)?;
login.write_uuid(&player_uuid)?;
Ok(())
})?;
let ProxyEvent::SendServerPacketEvent {
packet: login_packet,
player: _,
} = this
.lock()
.unwrap()
.trigger_event(ProxyEvent::SendServerPacketEvent {
packet: login_packet,
player: player.clone(),
})
else {
return Ok(());
};
player
.lock()
.unwrap()
.server_conn
.write_packet(&Packet::build(0x00, move |login| {
login.write_string(&player_name)?;
login.write_uuid(&player_uuid)?;
Ok(())
})?)?;
.write_packet(&login_packet)?;
}
}
None => {}
},
None => {}
};
}
let plugin_response_packet = Packet::build(0x02, |packet| {
@ -357,6 +397,28 @@ impl ProxyPlayer {
Err(_) => break,
};
let ProxyEvent::RecvClientPacketEvent { packet, player: _ } = this
.lock()
.unwrap()
.trigger_event(ProxyEvent::RecvClientPacketEvent {
packet,
player: player.clone(),
})
else {
return Ok(());
};
let ProxyEvent::SendServerPacketEvent { packet, player: _ } = this
.lock()
.unwrap()
.trigger_event(ProxyEvent::SendServerPacketEvent {
packet,
player: player.clone(),
})
else {
return Ok(());
};
server_conn.write_packet(&packet)?;
}
@ -368,15 +430,22 @@ impl ProxyPlayer {
server_conn.close();
if this.lock().unwrap().remove_player(player.clone()) {
match player.lock().unwrap().name.clone() {
Some(name) => {
info!("{} disconnected player {}", addr.to_string(), name)
}
None => {}
if let Some(name) = player.lock().unwrap().name.clone() {
info!("{} disconnected player {}", addr.to_string(), name);
let ProxyEvent::PlayerDisconnectedEvent { player: _ } = this
.lock()
.unwrap()
.trigger_event(ProxyEvent::PlayerDisconnectedEvent {
player: player.clone(),
})
else {
return;
};
}
}
}
}
});
let res = || -> Result<(), ProtocolError> {
@ -395,13 +464,41 @@ impl ProxyPlayer {
}
}
let mut packet = match server_conn.read_packet() {
let packet = match server_conn.read_packet() {
Ok(packet) => packet,
Err(_) => break,
};
let ProxyEvent::RecvServerPacketEvent {
mut packet,
player: _,
} = this
.lock()
.unwrap()
.trigger_event(ProxyEvent::RecvServerPacketEvent {
packet,
player: player.clone(),
})
else {
return Ok(());
};
if packet.id() == 0x02 && !logged {
if let PlayerForwarding::PluginResponse = server_config.player_forwarding {
let ProxyEvent::SendServerPacketEvent {
packet: plugin_response_packet,
player: _,
} = this
.lock()
.unwrap()
.trigger_event(ProxyEvent::SendServerPacketEvent {
packet: plugin_response_packet.clone(),
player: player.clone(),
})
else {
return Ok(());
};
server_conn.write_packet(&plugin_response_packet)?;
}
logged = true;
@ -412,22 +509,33 @@ impl ProxyPlayer {
if packet.id() == 0x01 && !logged {
let locked = player.lock().unwrap();
match locked.shared_secret.as_ref() {
Some(shared_secret) => match locked.verify_token.as_ref() {
Some(verify_token) => {
server_conn.write_packet(&Packet::build(0x00, move |resp| {
if let Some(shared_secret) = locked.shared_secret.as_ref() {
if let Some(verify_token) = locked.verify_token.as_ref() {
let encryption_response = Packet::build(0x00, move |resp| {
resp.write_usize_varint(shared_secret.len())?;
resp.write_bytes(&shared_secret)?;
resp.write_usize_varint(verify_token.len())?;
resp.write_bytes(&verify_token)?;
Ok(())
})?)?;
}
None => {}
})?;
let ProxyEvent::SendServerPacketEvent {
packet: encryption_response,
player: _,
} = this.lock().unwrap().trigger_event(
ProxyEvent::SendServerPacketEvent {
packet: encryption_response,
player: player.clone(),
},
None => {}
)
else {
return Ok(());
};
server_conn.write_packet(&encryption_response)?;
}
}
continue;
}
@ -447,6 +555,17 @@ impl ProxyPlayer {
continue;
}
let ProxyEvent::SendClientPacketEvent { packet, player: _ } = this
.lock()
.unwrap()
.trigger_event(ProxyEvent::SendClientPacketEvent {
packet,
player: player.clone(),
})
else {
return Ok(());
};
client_conn.write_packet(&packet)?;
}
@ -458,21 +577,94 @@ impl ProxyPlayer {
server_conn.close();
if this.lock().unwrap().remove_player(player.clone()) {
match player.lock().unwrap().name.clone() {
Some(name) => info!("{} disconnected player {}", addr.to_string(), name),
None => {}
if let Some(name) = player.lock().unwrap().name.clone() {
info!("{} disconnected player {}", addr.to_string(), name);
let ProxyEvent::PlayerDisconnectedEvent { player: _ } = this
.lock()
.unwrap()
.trigger_event(ProxyEvent::PlayerDisconnectedEvent {
player: player.clone(),
})
else {
return Ok(());
};
}
}
}
Ok(())
}
}
#[derive(Debug)]
pub enum ProxyEvent {
/// client <- proxy <- server
/// |
/// RecvServerPacketEvent
RecvServerPacketEvent {
packet: Packet,
player: PlayerMutex,
},
/// client -> proxy -> server
/// |
/// SendServerPacketEvent
SendServerPacketEvent {
packet: Packet,
player: PlayerMutex,
},
/// client <- proxy <- server
/// |
/// SendClientPacketEvent
SendClientPacketEvent {
packet: Packet,
player: PlayerMutex,
},
/// client -> proxy -> server
/// |
/// RecvClientPacketEvent
RecvClientPacketEvent {
packet: Packet,
player: PlayerMutex,
},
PlayerConnectedEvent {
player: PlayerMutex,
},
PlayerConnectingServerEvent {
player: PlayerMutex,
server: ProxyServer,
},
PlayerConnectingIPEvent {
player: PlayerMutex,
ip: String,
},
PlayerDisconnectedEvent {
player: PlayerMutex,
},
StatusRequestEvent {
status: String,
client_address: SocketAddr,
server_address: String,
server_port: u16,
},
}
pub trait EventListener {
fn on_event(&mut self, event: &mut ProxyEvent);
}
pub struct MeexProx {
pub config: ProxyConfig,
pub players: Vec<Arc<Mutex<ProxyPlayer>>>,
pub listener: Option<TcpListener>,
config: ProxyConfig,
players: Vec<PlayerMutex>,
event_listeners: Vec<Box<dyn EventListener + Send + Sync>>,
}
impl MeexProx {
@ -480,11 +672,22 @@ impl MeexProx {
MeexProx {
config,
players: Vec::new(),
listener: None,
event_listeners: Vec::new(),
}
}
pub fn get_player(&self, uuid: Uuid) -> Option<Arc<Mutex<ProxyPlayer>>> {
pub fn add_event_listener(&mut self, event_listener: Box<dyn EventListener + Send + Sync>) {
self.event_listeners.push(event_listener);
}
pub fn trigger_event(&mut self, mut event: ProxyEvent) -> ProxyEvent {
for event_listener in &mut self.event_listeners {
event_listener.on_event(&mut event);
}
event
}
pub fn get_player(&self, uuid: Uuid) -> Option<PlayerMutex> {
for player in &self.players {
if let Some(player_uuid) = player.lock().unwrap().uuid {
if player_uuid == uuid {
@ -495,7 +698,17 @@ impl MeexProx {
None
}
pub fn accept(this: Arc<Mutex<Self>>, stream: TcpStream) -> Result<(), Box<dyn Error>> {
pub fn remove_player(&mut self, player: PlayerMutex) -> bool {
match self.players.iter().position(|x| Arc::ptr_eq(x, &player)) {
Some(i) => {
self.players.remove(i);
true
}
None => false,
}
}
pub fn accept_client(this: MeexProxMutex, stream: TcpStream) -> Result<(), Box<dyn Error>> {
let Ok(addr) = stream.peer_addr() else {
return Ok(());
};
@ -547,8 +760,37 @@ impl MeexProx {
if next_state == 1 {
loop {
server_conn.write_packet(&client_conn.read_packet()?)?;
client_conn.write_packet(&server_conn.read_packet()?)?;
let client_packet = client_conn.read_packet()?;
server_conn.write_packet(&client_packet)?;
let mut server_packet = server_conn.read_packet()?;
if client_packet.id() == 0x00 {
let server_status = server_packet.read_string()?;
let ProxyEvent::StatusRequestEvent {
status: server_status,
client_address: _,
server_address: _,
server_port: _,
} = this
.lock()
.unwrap()
.trigger_event(ProxyEvent::StatusRequestEvent {
status: server_status.clone(),
client_address: addr.clone(),
server_address: server_address.clone(),
server_port,
})
else {
return Ok(());
};
server_packet = Packet::build(0x00, |p| p.write_string(&server_status))?;
}
client_conn.write_packet(&server_packet)?;
}
} else if next_state == 2 {
let plugin_response_packet = Packet::build(0x02, |packet| {
@ -604,11 +846,24 @@ impl MeexProx {
break;
}
let mut packet = match client_conn.read_packet() {
let packet = match client_conn.read_packet() {
Ok(packet) => packet,
Err(_) => break,
};
let ProxyEvent::RecvClientPacketEvent {
mut packet,
player: _,
} = this.lock().unwrap().trigger_event(
ProxyEvent::RecvClientPacketEvent {
packet,
player: player.clone(),
},
)
else {
return Ok(());
};
if packet.id() == 0x00 && !joined {
let name = packet.read_string()?;
let uuid = packet.read_uuid()?;
@ -623,6 +878,16 @@ impl MeexProx {
&uuid
);
let ProxyEvent::PlayerConnectedEvent { player: _ } = this
.lock()
.unwrap()
.trigger_event(ProxyEvent::PlayerConnectedEvent {
player: player.clone(),
})
else {
return Ok(());
};
joined = true;
}
@ -638,6 +903,17 @@ impl MeexProx {
encryption = true;
}
let ProxyEvent::SendServerPacketEvent { packet, player: _ } = this
.lock()
.unwrap()
.trigger_event(ProxyEvent::SendServerPacketEvent {
packet,
player: player.clone(),
})
else {
return Ok(());
};
server_conn.write_packet(&packet)?;
}
@ -649,15 +925,22 @@ impl MeexProx {
server_conn.close();
if this.lock().unwrap().remove_player(player.clone()) {
match player.lock().unwrap().name.clone() {
Some(name) => {
info!("{} disconnected player {}", addr.to_string(), name)
}
None => {}
if let Some(name) = player.lock().unwrap().name.clone() {
info!("{} disconnected player {}", addr.to_string(), name);
let ProxyEvent::PlayerDisconnectedEvent { player: _ } = this
.lock()
.unwrap()
.trigger_event(ProxyEvent::PlayerDisconnectedEvent {
player: player.clone(),
})
else {
return;
};
}
}
}
}
});
let res = || -> Result<(), ProtocolError> {
@ -670,17 +953,55 @@ impl MeexProx {
break;
}
let mut packet = match server_conn.read_packet() {
let packet = match server_conn.read_packet() {
Ok(packet) => packet,
Err(_) => break,
};
let ProxyEvent::RecvServerPacketEvent { packet, player: _ } = this
.lock()
.unwrap()
.trigger_event(ProxyEvent::RecvServerPacketEvent {
packet,
player: player.clone(),
})
else {
return Ok(());
};
if packet.id() == 0x02 {
if let PlayerForwarding::PluginResponse = server_config.player_forwarding {
let ProxyEvent::SendServerPacketEvent {
packet: plugin_response_packet,
player: _,
} = this.lock().unwrap().trigger_event(
ProxyEvent::SendServerPacketEvent {
packet: plugin_response_packet.clone(),
player: player.clone(),
},
)
else {
return Ok(());
};
server_conn.write_packet(&plugin_response_packet)?;
}
}
let ProxyEvent::SendClientPacketEvent {
mut packet,
player: _,
} = this
.lock()
.unwrap()
.trigger_event(ProxyEvent::SendClientPacketEvent {
packet,
player: player.clone(),
})
else {
return Ok(());
};
client_conn.write_packet(&packet)?;
if packet.id() == 0x03 {
@ -706,27 +1027,26 @@ impl MeexProx {
server_conn.close();
if this.lock().unwrap().remove_player(player.clone()) {
match player.lock().unwrap().name.clone() {
Some(name) => info!("{} disconnected player {}", addr.to_string(), name),
None => {}
if let Some(name) = player.lock().unwrap().name.clone() {
info!("{} disconnected player {}", addr.to_string(), name);
let ProxyEvent::PlayerDisconnectedEvent { player: _ } = this
.lock()
.unwrap()
.trigger_event(ProxyEvent::PlayerDisconnectedEvent {
player: player.clone(),
})
else {
return Ok(());
};
}
}
}
}
Ok(())
}
pub fn remove_player(&mut self, player: Arc<Mutex<ProxyPlayer>>) -> bool {
match self.players.iter().position(|x| Arc::ptr_eq(x, &player)) {
Some(i) => {
self.players.remove(i);
true
}
None => false,
}
}
pub fn start(self) {
let listener = TcpListener::bind(&self.config.host).expect("invalid host");
@ -738,9 +1058,9 @@ impl MeexProx {
if let Ok(client) = client {
let mutex_self_clone = mutex_self.clone();
thread::spawn(move || {
match Self::accept(mutex_self_clone, client) {
match Self::accept_client(mutex_self_clone, client) {
Ok(_) => {}
Err(e) => {
Err(_) => {
// error!("connection error: {:?}", e);
}
};
@ -749,3 +1069,6 @@ impl MeexProx {
}
}
}
pub type PlayerMutex = Arc<Mutex<ProxyPlayer>>;
pub type MeexProxMutex = Arc<Mutex<MeexProx>>;

40
src/main.rs
View File

@ -1,16 +1,38 @@
use meexprox::{MeexProx, ProxyConfig};
use simplelog::{CombinedLogger, TermLogger, Config, LevelFilter, TerminalMode, ColorChoice, WriteLogger};
use meexprox::{EventListener, MeexProx, ProxyConfig, ProxyEvent};
use simplelog::{
ColorChoice, CombinedLogger, Config, LevelFilter, TermLogger, TerminalMode, WriteLogger,
};
use std::fs::File;
pub struct MyEventListener {}
impl EventListener for MyEventListener {
fn on_event(&mut self, event: &mut ProxyEvent) {
dbg!(event);
}
}
fn main() {
CombinedLogger::init(
vec![
TermLogger::new(LevelFilter::Debug, Config::default(), TerminalMode::Mixed, ColorChoice::Auto),
WriteLogger::new(LevelFilter::Info, Config::default(), File::create("latest.log").unwrap()),
]
).unwrap();
CombinedLogger::init(vec![
TermLogger::new(
LevelFilter::Debug,
Config::default(),
TerminalMode::Mixed,
ColorChoice::Auto,
),
WriteLogger::new(
LevelFilter::Info,
Config::default(),
File::create("latest.log").unwrap(),
),
])
.unwrap();
let config = ProxyConfig::load("config.yml").expect("config parse error");
let meexprox = MeexProx::new(config);
let mut meexprox = MeexProx::new(config);
meexprox.add_event_listener(Box::new(MyEventListener {}));
meexprox.start();
}