157 lines
3.9 KiB
Rust
157 lines
3.9 KiB
Rust
use std::collections::HashMap;
|
|
|
|
use serde_derive::{Deserialize, Serialize};
|
|
use serde_json::Value;
|
|
use tokio::{io::AsyncWriteExt, net::TcpStream};
|
|
|
|
use crate::{
|
|
packets::{Packet, SendPacket},
|
|
types::VarString,
|
|
};
|
|
|
|
pub trait StatusTrait {
|
|
fn get_players_online(&self) -> i32;
|
|
fn set_description(&mut self, str: String);
|
|
fn get_description(&mut self) -> &mut String;
|
|
fn get_string(&self) -> String;
|
|
}
|
|
impl StatusTrait for StatusStructNew {
|
|
fn get_players_online(&self) -> i32
|
|
where
|
|
Self: Sized,
|
|
{
|
|
self.players.online
|
|
}
|
|
|
|
fn set_description(&mut self, str: String)
|
|
where
|
|
Self: Sized,
|
|
{
|
|
self.description.text = str;
|
|
}
|
|
fn get_description(&mut self) -> &mut String
|
|
where
|
|
Self: Sized,
|
|
{
|
|
&mut self.description.text
|
|
}
|
|
|
|
fn get_string(&self) -> String {
|
|
serde_json::to_string(&self).unwrap()
|
|
}
|
|
}
|
|
|
|
impl StatusTrait for StatusStructOld {
|
|
fn get_players_online(&self) -> i32 {
|
|
self.players.online
|
|
}
|
|
|
|
fn set_description(&mut self, str: String) {
|
|
self.description = str;
|
|
}
|
|
|
|
fn get_description(&mut self) -> &mut String {
|
|
&mut self.description
|
|
}
|
|
|
|
fn get_string(&self) -> String {
|
|
serde_json::to_string(&self).unwrap()
|
|
}
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Clone)]
|
|
pub struct StatusStructNew {
|
|
pub version: StatusVersion,
|
|
pub enforcesSecureChat: Option<bool>,
|
|
pub description: StatusDescription,
|
|
pub players: StatusPlayers,
|
|
#[serde(flatten)]
|
|
extra: HashMap<String, Value>,
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Clone)]
|
|
pub struct StatusStructOld {
|
|
pub version: StatusVersion,
|
|
pub description: String,
|
|
pub players: StatusPlayers,
|
|
#[serde(flatten)]
|
|
extra: HashMap<String, Value>,
|
|
}
|
|
impl StatusStructNew {
|
|
pub fn create() -> StatusStructNew {
|
|
StatusStructNew {
|
|
version: StatusVersion {
|
|
name: "???".to_owned(),
|
|
protocol: -1,
|
|
},
|
|
enforcesSecureChat: Some(false),
|
|
description: StatusDescription {
|
|
text: "Proxy default config".to_owned(),
|
|
},
|
|
players: StatusPlayers { max: 0, online: 0 },
|
|
extra: HashMap::new(),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Clone)]
|
|
pub struct StatusDescription {
|
|
pub text: String,
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Clone)]
|
|
pub struct StatusVersion {
|
|
pub name: String,
|
|
pub protocol: i32,
|
|
}
|
|
#[derive(Serialize, Deserialize, Clone)]
|
|
pub struct StatusPlayers {
|
|
pub max: i32,
|
|
pub online: i32,
|
|
}
|
|
|
|
/// id: 0x00
|
|
#[derive(Debug)]
|
|
pub struct StatusResponse {
|
|
json: VarString,
|
|
all: Vec<u8>,
|
|
}
|
|
|
|
impl StatusResponse {
|
|
pub async fn parse(packet: Packet) -> Option<StatusResponse> {
|
|
Some(StatusResponse {
|
|
all: packet.all,
|
|
json: VarString::parse(&mut packet.data.clone()).await?,
|
|
})
|
|
}
|
|
pub fn get_string(&self) -> String {
|
|
self.json.get_value()
|
|
}
|
|
pub fn get_json(&self) -> Option<Box<dyn StatusTrait>> {
|
|
if let Some(json) = serde_json::from_str::<StatusStructNew>(&self.json.get_value()).ok() {
|
|
return Some(Box::new(json));
|
|
} else if let Some(json) =
|
|
serde_json::from_str::<StatusStructOld>(&self.json.get_value()).ok()
|
|
{
|
|
return Some(Box::new(json));
|
|
}
|
|
None
|
|
}
|
|
pub async fn set_json(json: Box<dyn StatusTrait>) -> StatusResponse {
|
|
let vec = VarString::from(json.get_string()).move_data().unwrap();
|
|
StatusResponse::parse(Packet::from_bytes(0, vec).unwrap())
|
|
.await
|
|
.unwrap()
|
|
}
|
|
pub fn get_all(&self) -> Vec<u8> {
|
|
self.all.clone()
|
|
}
|
|
}
|
|
|
|
impl SendPacket for StatusResponse {
|
|
async fn send_packet(&self, stream: &mut TcpStream) -> std::io::Result<()> {
|
|
stream.write_all(&self.all).await?;
|
|
stream.flush().await?;
|
|
Ok(())
|
|
}
|
|
}
|