mirror of
https://github.com/tribufu/rust-gamedig
synced 2026-06-01 09:42:41 +00:00
chore: Move minecraft protocol to games. (#153)
* chore: initial move and refactor of minecraft * fix: glob re-exports * fix: failing example sample * docs: update changelog to note the mc protocol implementation to games * docs: add back the reference query standard reference
This commit is contained in:
CosminPerRam
GitHub
parent
bd73b657c7
commit
7416d54b14
15 changed files with 88 additions and 94 deletions
|
|
@ -1,12 +1,7 @@
|
|||
//! Static definitions of currently supported games
|
||||
|
||||
use crate::protocols::{
|
||||
gamespy::GameSpyVersion,
|
||||
minecraft::{LegacyGroup, Server},
|
||||
quake::QuakeVersion,
|
||||
valve::Engine,
|
||||
Protocol,
|
||||
};
|
||||
use crate::games::minecraft::types::{LegacyGroup, Server};
|
||||
use crate::protocols::{gamespy::GameSpyVersion, quake::QuakeVersion, valve::Engine, Protocol};
|
||||
use crate::Game;
|
||||
|
||||
use crate::protocols::types::ProprietaryProtocol;
|
||||
|
|
@ -36,14 +31,14 @@ macro_rules! game {
|
|||
/// Map of all currently supported games
|
||||
pub static GAMES: Map<&'static str, Game> = phf_map! {
|
||||
// Query with all minecraft protocols
|
||||
"minecraft" => game!("Minecraft", 25565, Protocol::Minecraft(None)),
|
||||
"minecraft" => game!("Minecraft", 25565, Protocol::PROPRIETARY(ProprietaryProtocol::Minecraft(None))),
|
||||
// Query with specific minecraft protocols
|
||||
"minecraftbedrock" => game!("Minecraft (bedrock)", 19132, Protocol::Minecraft(Some(Server::Bedrock))),
|
||||
"minecraftpocket" => game!("Minecraft (pocket)", 19132, Protocol::Minecraft(Some(Server::Bedrock))),
|
||||
"minecraftjava" => game!("Minecraft (java)", 25565, Protocol::Minecraft(Some(Server::Java))),
|
||||
"minecraftlegacy16" => game!("Minecraft (legacy 1.6)", 25565, Protocol::Minecraft(Some(Server::Legacy(LegacyGroup::V1_6)))),
|
||||
"minecraftlegacy14" => game!("Minecraft (legacy 1.4)", 25565, Protocol::Minecraft(Some(Server::Legacy(LegacyGroup::V1_4)))),
|
||||
"minecraftlegacyb18" => game!("Minecraft (legacy b1.8)", 25565, Protocol::Minecraft(Some(Server::Legacy(LegacyGroup::VB1_8)))),
|
||||
"minecraftbedrock" => game!("Minecraft (bedrock)", 19132, Protocol::PROPRIETARY(ProprietaryProtocol::Minecraft(Some(Server::Bedrock)))),
|
||||
"minecraftpocket" => game!("Minecraft (pocket)", 19132, Protocol::PROPRIETARY(ProprietaryProtocol::Minecraft(Some(Server::Bedrock)))),
|
||||
"minecraftjava" => game!("Minecraft (java)", 25565, Protocol::PROPRIETARY(ProprietaryProtocol::Minecraft(Some(Server::Java)))),
|
||||
"minecraftlegacy16" => game!("Minecraft (legacy 1.6)", 25565, Protocol::PROPRIETARY(ProprietaryProtocol::Minecraft(Some(Server::Legacy(LegacyGroup::V1_6))))),
|
||||
"minecraftlegacy14" => game!("Minecraft (legacy 1.4)", 25565, Protocol::PROPRIETARY(ProprietaryProtocol::Minecraft(Some(Server::Legacy(LegacyGroup::V1_4))))),
|
||||
"minecraftlegacyb18" => game!("Minecraft (legacy b1.8)", 25565, Protocol::PROPRIETARY(ProprietaryProtocol::Minecraft(Some(Server::Legacy(LegacyGroup::VB1_8))))),
|
||||
"alienswarm" => game!("Alien Swarm", 27015, Protocol::Valve(Engine::new(630))),
|
||||
"aoc" => game!("Age of Chivalry", 27015, Protocol::Valve(Engine::new(17510))),
|
||||
"a2oa" => game!("ARMA 2: Operation Arrowhead", 2304, Protocol::Valve(Engine::new(33930))),
|
||||
|
|
|
|||
|
|
@ -1,9 +1,13 @@
|
|||
use crate::protocols::minecraft::RequestSettings;
|
||||
use crate::{
|
||||
protocols::minecraft::{self, BedrockResponse, JavaResponse, LegacyGroup},
|
||||
GDErrorKind,
|
||||
GDResult,
|
||||
};
|
||||
/// The implementation.
|
||||
/// Reference: [Server List Ping](https://wiki.vg/Server_List_Ping)
|
||||
pub mod protocol;
|
||||
/// All types used by the implementation.
|
||||
pub mod types;
|
||||
|
||||
pub use protocol::*;
|
||||
pub use types::*;
|
||||
|
||||
use crate::{GDErrorKind, GDResult};
|
||||
use std::net::{IpAddr, SocketAddr};
|
||||
|
||||
/// Query with all the protocol variants one by one (Java -> Bedrock -> Legacy
|
||||
|
|
@ -30,7 +34,7 @@ pub fn query_java(
|
|||
port: Option<u16>,
|
||||
request_settings: Option<RequestSettings>,
|
||||
) -> GDResult<JavaResponse> {
|
||||
minecraft::query_java(
|
||||
protocol::query_java(
|
||||
&SocketAddr::new(*address, port_or_java_default(port)),
|
||||
None,
|
||||
request_settings,
|
||||
|
|
@ -39,12 +43,12 @@ pub fn query_java(
|
|||
|
||||
/// Query a (Java) Legacy Server (1.6 -> 1.4 -> Beta 1.8).
|
||||
pub fn query_legacy(address: &IpAddr, port: Option<u16>) -> GDResult<JavaResponse> {
|
||||
minecraft::query_legacy(&SocketAddr::new(*address, port_or_java_default(port)), None)
|
||||
protocol::query_legacy(&SocketAddr::new(*address, port_or_java_default(port)), None)
|
||||
}
|
||||
|
||||
/// Query a specific (Java) Legacy Server.
|
||||
pub fn query_legacy_specific(group: LegacyGroup, address: &IpAddr, port: Option<u16>) -> GDResult<JavaResponse> {
|
||||
minecraft::query_legacy_specific(
|
||||
protocol::query_legacy_specific(
|
||||
group,
|
||||
&SocketAddr::new(*address, port_or_java_default(port)),
|
||||
None,
|
||||
|
|
@ -53,7 +57,7 @@ pub fn query_legacy_specific(group: LegacyGroup, address: &IpAddr, port: Option<
|
|||
|
||||
/// Query a Bedrock Server.
|
||||
pub fn query_bedrock(address: &IpAddr, port: Option<u16>) -> GDResult<BedrockResponse> {
|
||||
minecraft::query_bedrock(
|
||||
protocol::query_bedrock(
|
||||
&SocketAddr::new(*address, port_or_bedrock_default(port)),
|
||||
None,
|
||||
)
|
||||
112
crates/lib/src/games/minecraft/protocol/bedrock.rs
Normal file
112
crates/lib/src/games/minecraft/protocol/bedrock.rs
Normal file
|
|
@ -0,0 +1,112 @@
|
|||
// This file has code that has been documented by the NodeJS GameDig library
|
||||
// (MIT) from https://github.com/gamedig/node-gamedig/blob/master/protocols/minecraftbedrock.js
|
||||
use crate::{
|
||||
buffer::{Buffer, Utf8Decoder},
|
||||
games::minecraft::{BedrockResponse, GameMode, Server},
|
||||
protocols::types::TimeoutSettings,
|
||||
socket::{Socket, UdpSocket},
|
||||
utils::{error_by_expected_size, retry_on_timeout},
|
||||
GDErrorKind::{PacketBad, TypeParse},
|
||||
GDResult,
|
||||
};
|
||||
|
||||
use std::net::SocketAddr;
|
||||
|
||||
use byteorder::LittleEndian;
|
||||
|
||||
pub struct Bedrock {
|
||||
socket: UdpSocket,
|
||||
retry_count: usize,
|
||||
}
|
||||
|
||||
impl Bedrock {
|
||||
fn new(address: &SocketAddr, timeout_settings: Option<TimeoutSettings>) -> GDResult<Self> {
|
||||
let socket = UdpSocket::new(address)?;
|
||||
socket.apply_timeout(&timeout_settings)?;
|
||||
|
||||
let retry_count = TimeoutSettings::get_retries_or_default(&timeout_settings);
|
||||
Ok(Self {
|
||||
socket,
|
||||
retry_count,
|
||||
})
|
||||
}
|
||||
|
||||
fn send_status_request(&mut self) -> GDResult<()> {
|
||||
self.socket.send(&[
|
||||
0x01, // Message ID: ID_UNCONNECTED_PING
|
||||
0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, // Nonce / timestamp
|
||||
0x00, 0xff, 0xff, 0x00, 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfd, 0x12, 0x34, // Magic
|
||||
0x56, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Client GUID
|
||||
])?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Send a status request, and parse the response.
|
||||
/// This function will retry fetch on timeouts.
|
||||
fn get_info(&mut self) -> GDResult<BedrockResponse> {
|
||||
retry_on_timeout(self.retry_count, move || self.get_info_impl())
|
||||
}
|
||||
|
||||
/// Send a status request, and parse the response (without retry logic).
|
||||
fn get_info_impl(&mut self) -> GDResult<BedrockResponse> {
|
||||
self.send_status_request()?;
|
||||
|
||||
let received = self.socket.receive(None)?;
|
||||
let mut buffer = Buffer::<LittleEndian>::new(&received);
|
||||
|
||||
if buffer.read::<u8>()? != 0x1c {
|
||||
return Err(PacketBad.context("Expected 0x1c"));
|
||||
}
|
||||
|
||||
// Checking for our nonce directly from a u64 (as the nonce is 8 bytes).
|
||||
if buffer.read::<u64>()? != 9_833_440_827_789_222_417 {
|
||||
return Err(PacketBad.context("Invalid nonce"));
|
||||
}
|
||||
|
||||
// These 8 bytes are identical to the serverId string we receive in decimal
|
||||
// below
|
||||
buffer.move_cursor(8)?;
|
||||
|
||||
// Verifying the magic value (as we need 16 bytes, cast to two u64 values)
|
||||
if buffer.read::<u64>()? != 18_374_403_896_610_127_616 {
|
||||
return Err(PacketBad.context("Invalid magic"));
|
||||
}
|
||||
|
||||
if buffer.read::<u64>()? != 8_671_175_388_723_805_693 {
|
||||
return Err(PacketBad.context("Invalid magic"));
|
||||
}
|
||||
|
||||
let remaining_length = buffer.switch_endian_chunk(2)?.read::<u16>()? as usize;
|
||||
|
||||
error_by_expected_size(remaining_length, buffer.remaining_length())?;
|
||||
|
||||
let binding = buffer.read_string::<Utf8Decoder>(None)?;
|
||||
let status: Vec<&str> = binding.split(';').collect();
|
||||
|
||||
// We must have at least 6 values
|
||||
if status.len() < 6 {
|
||||
return Err(PacketBad.context("Not enough values"));
|
||||
}
|
||||
|
||||
Ok(BedrockResponse {
|
||||
edition: status[0].to_string(),
|
||||
name: status[1].to_string(),
|
||||
version_name: status[3].to_string(),
|
||||
protocol_version: status[2].to_string(),
|
||||
players_maximum: status[5].parse().map_err(|e| TypeParse.context(e))?,
|
||||
players_online: status[4].parse().map_err(|e| TypeParse.context(e))?,
|
||||
id: status.get(6).map(std::string::ToString::to_string),
|
||||
map: status.get(7).map(std::string::ToString::to_string),
|
||||
game_mode: match status.get(8) {
|
||||
None => None,
|
||||
Some(v) => Some(GameMode::from_bedrock(v)?),
|
||||
},
|
||||
server_type: Server::Bedrock,
|
||||
})
|
||||
}
|
||||
|
||||
pub fn query(address: &SocketAddr, timeout_settings: Option<TimeoutSettings>) -> GDResult<BedrockResponse> {
|
||||
Self::new(address, timeout_settings)?.get_info()
|
||||
}
|
||||
}
|
||||
173
crates/lib/src/games/minecraft/protocol/java.rs
Normal file
173
crates/lib/src/games/minecraft/protocol/java.rs
Normal file
|
|
@ -0,0 +1,173 @@
|
|||
use crate::{
|
||||
buffer::Buffer,
|
||||
games::minecraft::{as_string, as_varint, get_string, get_varint, JavaResponse, Player, RequestSettings, Server},
|
||||
protocols::types::TimeoutSettings,
|
||||
socket::{Socket, TcpSocket},
|
||||
utils::retry_on_timeout,
|
||||
GDErrorKind::{JsonParse, PacketBad},
|
||||
GDResult,
|
||||
};
|
||||
|
||||
use byteorder::LittleEndian;
|
||||
use serde_json::Value;
|
||||
use std::net::SocketAddr;
|
||||
|
||||
pub struct Java {
|
||||
socket: TcpSocket,
|
||||
request_settings: RequestSettings,
|
||||
retry_count: usize,
|
||||
}
|
||||
|
||||
impl Java {
|
||||
fn new(
|
||||
address: &SocketAddr,
|
||||
timeout_settings: Option<TimeoutSettings>,
|
||||
request_settings: Option<RequestSettings>,
|
||||
) -> GDResult<Self> {
|
||||
let socket = TcpSocket::new(address)?;
|
||||
socket.apply_timeout(&timeout_settings)?;
|
||||
|
||||
let retry_count = TimeoutSettings::get_retries_or_default(&timeout_settings);
|
||||
Ok(Self {
|
||||
socket,
|
||||
request_settings: request_settings.unwrap_or_default(),
|
||||
retry_count,
|
||||
})
|
||||
}
|
||||
|
||||
fn send(&mut self, data: Vec<u8>) -> GDResult<()> {
|
||||
self.socket
|
||||
.send(&[as_varint(data.len() as i32), data].concat())
|
||||
}
|
||||
|
||||
fn receive(&mut self) -> GDResult<Vec<u8>> {
|
||||
let data = &self.socket.receive(None)?;
|
||||
let mut buffer = Buffer::<LittleEndian>::new(data);
|
||||
|
||||
let _packet_length = get_varint(&mut buffer)? as usize;
|
||||
// this declared 'packet length' from within the packet might be wrong (?), not
|
||||
// checking with it...
|
||||
|
||||
Ok(buffer.remaining_bytes().to_vec())
|
||||
}
|
||||
|
||||
fn send_handshake(&mut self) -> GDResult<()> {
|
||||
let handshake_payload = [
|
||||
&[
|
||||
// Packet ID (0)
|
||||
0x00,
|
||||
], // Protocol Version (-1 to determine version)
|
||||
as_varint(self.request_settings.protocol_version).as_slice(),
|
||||
// Server address (can be anything)
|
||||
as_string(&self.request_settings.hostname)?.as_slice(),
|
||||
// Server port (can be anything)
|
||||
&self.socket.port().to_le_bytes(),
|
||||
&[
|
||||
// Next state (1 for status)
|
||||
0x01,
|
||||
],
|
||||
]
|
||||
.concat();
|
||||
|
||||
self.send(handshake_payload)?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn send_status_request(&mut self) -> GDResult<()> {
|
||||
self.send(
|
||||
[0x00] // Packet ID (0)
|
||||
.to_vec(),
|
||||
)?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn send_ping_request(&mut self) -> GDResult<()> {
|
||||
self.send(
|
||||
[0x01] // Packet ID (1)
|
||||
.to_vec(),
|
||||
)?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Send minecraft ping request and parse the response.
|
||||
/// This function will retry fetch on timeouts.
|
||||
fn get_info(&mut self) -> GDResult<JavaResponse> {
|
||||
retry_on_timeout(self.retry_count, move || self.get_info_impl())
|
||||
}
|
||||
|
||||
/// Send minecraft ping request and parse the response (without retry
|
||||
/// logic).
|
||||
fn get_info_impl(&mut self) -> GDResult<JavaResponse> {
|
||||
self.send_handshake()?;
|
||||
self.send_status_request()?;
|
||||
self.send_ping_request()?;
|
||||
|
||||
let socket_data = self.receive()?;
|
||||
let mut buffer = Buffer::<LittleEndian>::new(&socket_data);
|
||||
|
||||
if get_varint(&mut buffer)? != 0 {
|
||||
// first var int is the packet id
|
||||
return Err(PacketBad.context("Expected 0"));
|
||||
}
|
||||
|
||||
let json_response = get_string(&mut buffer)?;
|
||||
let value_response: Value = serde_json::from_str(&json_response).map_err(|e| JsonParse.context(e))?;
|
||||
|
||||
let game_version = value_response["version"]["name"]
|
||||
.as_str()
|
||||
.ok_or(PacketBad)?
|
||||
.to_string();
|
||||
let protocol_version = value_response["version"]["protocol"]
|
||||
.as_i64()
|
||||
.ok_or(PacketBad)? as i32;
|
||||
|
||||
let max_players = value_response["players"]["max"].as_u64().ok_or(PacketBad)? as u32;
|
||||
let online_players = value_response["players"]["online"]
|
||||
.as_u64()
|
||||
.ok_or(PacketBad)? as u32;
|
||||
let players: Option<Vec<Player>> = match value_response["players"]["sample"].is_null() {
|
||||
true => None,
|
||||
false => {
|
||||
Some({
|
||||
let players_values = value_response["players"]["sample"]
|
||||
.as_array()
|
||||
.ok_or(PacketBad)?;
|
||||
|
||||
let mut players = Vec::with_capacity(players_values.len());
|
||||
for player in players_values {
|
||||
players.push(Player {
|
||||
name: player["name"].as_str().ok_or(PacketBad)?.to_string(),
|
||||
id: player["id"].as_str().ok_or(PacketBad)?.to_string(),
|
||||
});
|
||||
}
|
||||
|
||||
players
|
||||
})
|
||||
}
|
||||
};
|
||||
|
||||
Ok(JavaResponse {
|
||||
game_version,
|
||||
protocol_version,
|
||||
players_maximum: max_players,
|
||||
players_online: online_players,
|
||||
players,
|
||||
description: value_response["description"].to_string(),
|
||||
favicon: value_response["favicon"].as_str().map(str::to_string),
|
||||
previews_chat: value_response["previewsChat"].as_bool(),
|
||||
enforces_secure_chat: value_response["enforcesSecureChat"].as_bool(),
|
||||
server_type: Server::Java,
|
||||
})
|
||||
}
|
||||
|
||||
pub fn query(
|
||||
address: &SocketAddr,
|
||||
timeout_settings: Option<TimeoutSettings>,
|
||||
request_settings: Option<RequestSettings>,
|
||||
) -> GDResult<JavaResponse> {
|
||||
Self::new(address, timeout_settings, request_settings)?.get_info()
|
||||
}
|
||||
}
|
||||
84
crates/lib/src/games/minecraft/protocol/legacy_v1_4.rs
Normal file
84
crates/lib/src/games/minecraft/protocol/legacy_v1_4.rs
Normal file
|
|
@ -0,0 +1,84 @@
|
|||
use byteorder::BigEndian;
|
||||
|
||||
use crate::minecraft::protocol::legacy_v1_6::LegacyV1_6;
|
||||
use crate::{
|
||||
buffer::{Buffer, Utf16Decoder},
|
||||
games::minecraft::{JavaResponse, LegacyGroup, Server},
|
||||
protocols::types::TimeoutSettings,
|
||||
socket::{Socket, TcpSocket},
|
||||
utils::{error_by_expected_size, retry_on_timeout},
|
||||
GDErrorKind::{PacketBad, ProtocolFormat},
|
||||
GDResult,
|
||||
};
|
||||
use std::net::SocketAddr;
|
||||
|
||||
pub struct LegacyV1_4 {
|
||||
socket: TcpSocket,
|
||||
retry_count: usize,
|
||||
}
|
||||
|
||||
impl LegacyV1_4 {
|
||||
fn new(address: &SocketAddr, timeout_settings: Option<TimeoutSettings>) -> GDResult<Self> {
|
||||
let socket = TcpSocket::new(address)?;
|
||||
socket.apply_timeout(&timeout_settings)?;
|
||||
|
||||
let retry_count = TimeoutSettings::get_retries_or_default(&timeout_settings);
|
||||
Ok(Self {
|
||||
socket,
|
||||
retry_count,
|
||||
})
|
||||
}
|
||||
|
||||
fn send_initial_request(&mut self) -> GDResult<()> { self.socket.send(&[0xFE, 0x01]) }
|
||||
|
||||
/// Send info request and parse response.
|
||||
/// This function will retry fetch on timeouts.
|
||||
fn get_info(&mut self) -> GDResult<JavaResponse> {
|
||||
retry_on_timeout(self.retry_count, move || self.get_info_impl())
|
||||
}
|
||||
|
||||
/// Send info request and parse response (without retry logic).
|
||||
fn get_info_impl(&mut self) -> GDResult<JavaResponse> {
|
||||
self.send_initial_request()?;
|
||||
|
||||
let data = self.socket.receive(None)?;
|
||||
let mut buffer = Buffer::<BigEndian>::new(&data);
|
||||
|
||||
if buffer.read::<u8>()? != 0xFF {
|
||||
return Err(ProtocolFormat.context("Expected 0xFF"));
|
||||
}
|
||||
|
||||
let length = buffer.read::<u16>()? * 2;
|
||||
error_by_expected_size((length + 3) as usize, data.len())?;
|
||||
|
||||
if LegacyV1_6::is_protocol(&mut buffer)? {
|
||||
return LegacyV1_6::get_response(&mut buffer);
|
||||
}
|
||||
|
||||
let packet_string = buffer.read_string::<Utf16Decoder<BigEndian>>(None)?;
|
||||
|
||||
let split: Vec<&str> = packet_string.split('§').collect();
|
||||
error_by_expected_size(3, split.len())?;
|
||||
|
||||
let description = split[0].to_string();
|
||||
let online_players = split[1].parse().map_err(|e| PacketBad.context(e))?;
|
||||
let max_players = split[2].parse().map_err(|e| PacketBad.context(e))?;
|
||||
|
||||
Ok(JavaResponse {
|
||||
game_version: "1.4+".to_string(),
|
||||
protocol_version: -1,
|
||||
players_maximum: max_players,
|
||||
players_online: online_players,
|
||||
players: None,
|
||||
description,
|
||||
favicon: None,
|
||||
previews_chat: None,
|
||||
enforces_secure_chat: None,
|
||||
server_type: Server::Legacy(LegacyGroup::V1_4),
|
||||
})
|
||||
}
|
||||
|
||||
pub fn query(address: &SocketAddr, timeout_settings: Option<TimeoutSettings>) -> GDResult<JavaResponse> {
|
||||
Self::new(address, timeout_settings)?.get_info()
|
||||
}
|
||||
}
|
||||
117
crates/lib/src/games/minecraft/protocol/legacy_v1_6.rs
Normal file
117
crates/lib/src/games/minecraft/protocol/legacy_v1_6.rs
Normal file
|
|
@ -0,0 +1,117 @@
|
|||
use byteorder::BigEndian;
|
||||
|
||||
use crate::{
|
||||
buffer::{Buffer, Utf16Decoder},
|
||||
games::minecraft::{JavaResponse, LegacyGroup, Server},
|
||||
protocols::types::TimeoutSettings,
|
||||
socket::{Socket, TcpSocket},
|
||||
utils::{error_by_expected_size, retry_on_timeout},
|
||||
GDErrorKind::{PacketBad, ProtocolFormat},
|
||||
GDResult,
|
||||
};
|
||||
use std::net::SocketAddr;
|
||||
|
||||
pub struct LegacyV1_6 {
|
||||
socket: TcpSocket,
|
||||
retry_count: usize,
|
||||
}
|
||||
|
||||
impl LegacyV1_6 {
|
||||
fn new(address: &SocketAddr, timeout_settings: Option<TimeoutSettings>) -> GDResult<Self> {
|
||||
let socket = TcpSocket::new(address)?;
|
||||
socket.apply_timeout(&timeout_settings)?;
|
||||
|
||||
let retry_count = TimeoutSettings::get_retries_or_default(&timeout_settings);
|
||||
Ok(Self {
|
||||
socket,
|
||||
retry_count,
|
||||
})
|
||||
}
|
||||
|
||||
fn send_initial_request(&mut self) -> GDResult<()> {
|
||||
self.socket.send(&[
|
||||
0xfe, // Packet ID (FE)
|
||||
0x01, // Ping payload (01)
|
||||
0xfa, // Packet identifier for plugin message
|
||||
0x00, 0x07, // Length of 'GameDig' string (7) as unsigned short
|
||||
0x00, 0x47, 0x00, 0x61, 0x00, 0x6D, 0x00, 0x65, 0x00, 0x44, 0x00, 0x69, 0x00,
|
||||
0x67, // 'GameDig' string as UTF-16BE
|
||||
])?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub(crate) fn is_protocol(buffer: &mut Buffer<BigEndian>) -> GDResult<bool> {
|
||||
let state = buffer
|
||||
.remaining_bytes()
|
||||
.starts_with(&[0x00, 0xA7, 0x00, 0x31, 0x00, 0x00]);
|
||||
|
||||
if state {
|
||||
buffer.move_cursor(6)?;
|
||||
}
|
||||
|
||||
Ok(state)
|
||||
}
|
||||
|
||||
pub(crate) fn get_response(buffer: &mut Buffer<BigEndian>) -> GDResult<JavaResponse> {
|
||||
// This is a specific order!
|
||||
let protocol_version = buffer
|
||||
.read_string::<Utf16Decoder<BigEndian>>(None)?
|
||||
.parse()
|
||||
.map_err(|e| PacketBad.context(e))?;
|
||||
let game_version = buffer.read_string::<Utf16Decoder<BigEndian>>(None)?;
|
||||
let description = buffer.read_string::<Utf16Decoder<BigEndian>>(None)?;
|
||||
let online_players = buffer
|
||||
.read_string::<Utf16Decoder<BigEndian>>(None)?
|
||||
.parse()
|
||||
.map_err(|e| PacketBad.context(e))?;
|
||||
let max_players = buffer
|
||||
.read_string::<Utf16Decoder<BigEndian>>(None)?
|
||||
.parse()
|
||||
.map_err(|e| PacketBad.context(e))?;
|
||||
|
||||
Ok(JavaResponse {
|
||||
game_version,
|
||||
protocol_version,
|
||||
players_maximum: max_players,
|
||||
players_online: online_players,
|
||||
players: None,
|
||||
description,
|
||||
favicon: None,
|
||||
previews_chat: None,
|
||||
enforces_secure_chat: None,
|
||||
server_type: Server::Legacy(LegacyGroup::V1_6),
|
||||
})
|
||||
}
|
||||
|
||||
/// Send info request and parse response.
|
||||
/// This function will retry fetch on timeouts.
|
||||
fn get_info(&mut self) -> GDResult<JavaResponse> {
|
||||
retry_on_timeout(self.retry_count, move || self.get_info_impl())
|
||||
}
|
||||
|
||||
/// Send info request and parse response (without retry logic).
|
||||
fn get_info_impl(&mut self) -> GDResult<JavaResponse> {
|
||||
self.send_initial_request()?;
|
||||
|
||||
let data = self.socket.receive(None)?;
|
||||
let mut buffer = Buffer::<BigEndian>::new(&data);
|
||||
|
||||
if buffer.read::<u8>()? != 0xFF {
|
||||
return Err(ProtocolFormat.context("Expected 0xFF"));
|
||||
}
|
||||
|
||||
let length = buffer.read::<u16>()? * 2;
|
||||
error_by_expected_size((length + 3) as usize, data.len())?;
|
||||
|
||||
if !Self::is_protocol(&mut buffer)? {
|
||||
return Err(ProtocolFormat.context("Not legacy 1.6 protocol"));
|
||||
}
|
||||
|
||||
Self::get_response(&mut buffer)
|
||||
}
|
||||
|
||||
pub fn query(address: &SocketAddr, timeout_settings: Option<TimeoutSettings>) -> GDResult<JavaResponse> {
|
||||
Self::new(address, timeout_settings)?.get_info()
|
||||
}
|
||||
}
|
||||
80
crates/lib/src/games/minecraft/protocol/legacy_vb1_8.rs
Normal file
80
crates/lib/src/games/minecraft/protocol/legacy_vb1_8.rs
Normal file
|
|
@ -0,0 +1,80 @@
|
|||
use crate::{
|
||||
buffer::{Buffer, Utf16Decoder},
|
||||
games::minecraft::{JavaResponse, LegacyGroup, Server},
|
||||
protocols::types::TimeoutSettings,
|
||||
socket::{Socket, TcpSocket},
|
||||
utils::{error_by_expected_size, retry_on_timeout},
|
||||
GDErrorKind::{PacketBad, ProtocolFormat},
|
||||
GDResult,
|
||||
};
|
||||
|
||||
use std::net::SocketAddr;
|
||||
|
||||
use byteorder::BigEndian;
|
||||
|
||||
pub struct LegacyVB1_8 {
|
||||
socket: TcpSocket,
|
||||
retry_count: usize,
|
||||
}
|
||||
|
||||
impl LegacyVB1_8 {
|
||||
fn new(address: &SocketAddr, timeout_settings: Option<TimeoutSettings>) -> GDResult<Self> {
|
||||
let socket = TcpSocket::new(address)?;
|
||||
socket.apply_timeout(&timeout_settings)?;
|
||||
|
||||
let retry_count = TimeoutSettings::get_retries_or_default(&timeout_settings);
|
||||
Ok(Self {
|
||||
socket,
|
||||
retry_count,
|
||||
})
|
||||
}
|
||||
|
||||
fn send_initial_request(&mut self) -> GDResult<()> { self.socket.send(&[0xFE]) }
|
||||
|
||||
/// Send request for info and parse response.
|
||||
/// This function will retry fetch on timeouts.
|
||||
fn get_info(&mut self) -> GDResult<JavaResponse> {
|
||||
retry_on_timeout(self.retry_count, move || self.get_info_impl())
|
||||
}
|
||||
|
||||
/// Send request for info and parse response (without retry logic).
|
||||
fn get_info_impl(&mut self) -> GDResult<JavaResponse> {
|
||||
self.send_initial_request()?;
|
||||
|
||||
let data = self.socket.receive(None)?;
|
||||
let mut buffer = Buffer::<BigEndian>::new(&data);
|
||||
|
||||
if buffer.read::<u8>()? != 0xFF {
|
||||
return Err(ProtocolFormat.context("Expected 0xFF"));
|
||||
}
|
||||
|
||||
let length = buffer.read::<u16>()? * 2;
|
||||
error_by_expected_size((length + 3) as usize, data.len())?;
|
||||
|
||||
let packet_string = buffer.read_string::<Utf16Decoder<BigEndian>>(None)?;
|
||||
|
||||
let split: Vec<&str> = packet_string.split('§').collect();
|
||||
error_by_expected_size(3, split.len())?;
|
||||
|
||||
let description = split[0].to_string();
|
||||
let online_players = split[1].parse().map_err(|e| PacketBad.context(e))?;
|
||||
let max_players = split[2].parse().map_err(|e| PacketBad.context(e))?;
|
||||
|
||||
Ok(JavaResponse {
|
||||
game_version: "Beta 1.8+".to_string(),
|
||||
protocol_version: -1,
|
||||
players_maximum: max_players,
|
||||
players_online: online_players,
|
||||
players: None,
|
||||
description,
|
||||
favicon: None,
|
||||
previews_chat: None,
|
||||
enforces_secure_chat: None,
|
||||
server_type: Server::Legacy(LegacyGroup::VB1_8),
|
||||
})
|
||||
}
|
||||
|
||||
pub fn query(address: &SocketAddr, timeout_settings: Option<TimeoutSettings>) -> GDResult<JavaResponse> {
|
||||
Self::new(address, timeout_settings)?.get_info()
|
||||
}
|
||||
}
|
||||
91
crates/lib/src/games/minecraft/protocol/mod.rs
Normal file
91
crates/lib/src/games/minecraft/protocol/mod.rs
Normal file
|
|
@ -0,0 +1,91 @@
|
|||
use crate::games::minecraft::types::RequestSettings;
|
||||
use crate::{
|
||||
games::minecraft::{
|
||||
protocol::{
|
||||
bedrock::Bedrock,
|
||||
java::Java,
|
||||
legacy_v1_4::LegacyV1_4,
|
||||
legacy_v1_6::LegacyV1_6,
|
||||
legacy_vb1_8::LegacyVB1_8,
|
||||
},
|
||||
BedrockResponse,
|
||||
JavaResponse,
|
||||
LegacyGroup,
|
||||
},
|
||||
protocols::types::TimeoutSettings,
|
||||
GDErrorKind::AutoQuery,
|
||||
GDResult,
|
||||
};
|
||||
use std::net::SocketAddr;
|
||||
|
||||
mod bedrock;
|
||||
mod java;
|
||||
mod legacy_v1_4;
|
||||
mod legacy_v1_6;
|
||||
mod legacy_vb1_8;
|
||||
|
||||
/// Queries a Minecraft server with all the protocol variants one by one (Java
|
||||
/// -> Bedrock -> Legacy (1.6 -> 1.4 -> Beta 1.8)).
|
||||
pub fn query(
|
||||
address: &SocketAddr,
|
||||
timeout_settings: Option<TimeoutSettings>,
|
||||
request_settings: Option<RequestSettings>,
|
||||
) -> GDResult<JavaResponse> {
|
||||
if let Ok(response) = query_java(address, timeout_settings, request_settings) {
|
||||
return Ok(response);
|
||||
}
|
||||
|
||||
if let Ok(response) = query_bedrock(address, timeout_settings) {
|
||||
return Ok(JavaResponse::from_bedrock_response(response));
|
||||
}
|
||||
|
||||
if let Ok(response) = query_legacy(address, timeout_settings) {
|
||||
return Ok(response);
|
||||
}
|
||||
|
||||
Err(AutoQuery.into())
|
||||
}
|
||||
|
||||
/// Query a Java Server.
|
||||
pub fn query_java(
|
||||
address: &SocketAddr,
|
||||
timeout_settings: Option<TimeoutSettings>,
|
||||
request_settings: Option<RequestSettings>,
|
||||
) -> GDResult<JavaResponse> {
|
||||
Java::query(address, timeout_settings, request_settings)
|
||||
}
|
||||
|
||||
/// Query a (Java) Legacy Server (1.6 -> 1.4 -> Beta 1.8).
|
||||
pub fn query_legacy(address: &SocketAddr, timeout_settings: Option<TimeoutSettings>) -> GDResult<JavaResponse> {
|
||||
if let Ok(response) = query_legacy_specific(LegacyGroup::V1_6, address, timeout_settings) {
|
||||
return Ok(response);
|
||||
}
|
||||
|
||||
if let Ok(response) = query_legacy_specific(LegacyGroup::V1_4, address, timeout_settings) {
|
||||
return Ok(response);
|
||||
}
|
||||
|
||||
if let Ok(response) = query_legacy_specific(LegacyGroup::VB1_8, address, timeout_settings) {
|
||||
return Ok(response);
|
||||
}
|
||||
|
||||
Err(AutoQuery.into())
|
||||
}
|
||||
|
||||
/// Query a specific (Java) Legacy Server.
|
||||
pub fn query_legacy_specific(
|
||||
group: LegacyGroup,
|
||||
address: &SocketAddr,
|
||||
timeout_settings: Option<TimeoutSettings>,
|
||||
) -> GDResult<JavaResponse> {
|
||||
match group {
|
||||
LegacyGroup::V1_6 => LegacyV1_6::query(address, timeout_settings),
|
||||
LegacyGroup::V1_4 => LegacyV1_4::query(address, timeout_settings),
|
||||
LegacyGroup::VB1_8 => LegacyVB1_8::query(address, timeout_settings),
|
||||
}
|
||||
}
|
||||
|
||||
/// Query a Bedrock Server.
|
||||
pub fn query_bedrock(address: &SocketAddr, timeout_settings: Option<TimeoutSettings>) -> GDResult<BedrockResponse> {
|
||||
Bedrock::query(address, timeout_settings)
|
||||
}
|
||||
305
crates/lib/src/games/minecraft/types.rs
Normal file
305
crates/lib/src/games/minecraft/types.rs
Normal file
|
|
@ -0,0 +1,305 @@
|
|||
// Although its a lightly modified version, this file contains code
|
||||
// by Jaiden Bernard (2021-2022 - MIT) from
|
||||
// https://github.com/thisjaiden/golden_apple/blob/master/src/lib.rs
|
||||
|
||||
use crate::{
|
||||
buffer::Buffer,
|
||||
protocols::{
|
||||
types::{CommonPlayer, CommonResponse, ExtraRequestSettings, GenericPlayer},
|
||||
GenericResponse,
|
||||
},
|
||||
GDErrorKind::{InvalidInput, PacketBad, UnknownEnumCast},
|
||||
GDResult,
|
||||
};
|
||||
|
||||
use byteorder::ByteOrder;
|
||||
#[cfg(feature = "serde")]
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
/// The type of Minecraft Server you want to query.
|
||||
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
|
||||
pub enum Server {
|
||||
/// Java Edition.
|
||||
Java,
|
||||
/// Legacy Java.
|
||||
Legacy(LegacyGroup),
|
||||
/// Bedrock Edition.
|
||||
Bedrock,
|
||||
}
|
||||
|
||||
/// Legacy Java (Versions) Groups.
|
||||
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
|
||||
pub enum LegacyGroup {
|
||||
/// 1.6
|
||||
V1_6,
|
||||
/// 1.4 - 1.5
|
||||
V1_4,
|
||||
/// Beta 1.8 - 1.3
|
||||
VB1_8,
|
||||
}
|
||||
|
||||
/// Information about a player.
|
||||
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
|
||||
pub struct Player {
|
||||
pub name: String,
|
||||
pub id: String,
|
||||
}
|
||||
|
||||
impl CommonPlayer for Player {
|
||||
fn as_original(&self) -> GenericPlayer { GenericPlayer::Minecraft(self) }
|
||||
|
||||
fn name(&self) -> &str { &self.name }
|
||||
}
|
||||
|
||||
/// Versioned response type
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub enum VersionedResponse<'a> {
|
||||
Bedrock(&'a BedrockResponse),
|
||||
Java(&'a JavaResponse),
|
||||
}
|
||||
|
||||
/// A Java query response.
|
||||
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
|
||||
pub struct JavaResponse {
|
||||
/// Version name, example: "1.19.2".
|
||||
pub game_version: String,
|
||||
/// Protocol version, example: 760 (for 1.19.1 or 1.19.2).
|
||||
/// Note that for versions below 1.6 this field is always -1.
|
||||
pub protocol_version: i32,
|
||||
/// Number of server capacity.
|
||||
pub players_maximum: u32,
|
||||
/// Number of online players.
|
||||
pub players_online: u32,
|
||||
/// Some online players (can be missing).
|
||||
pub players: Option<Vec<Player>>,
|
||||
/// Server's description or MOTD.
|
||||
pub description: String,
|
||||
/// The favicon (can be missing).
|
||||
pub favicon: Option<String>,
|
||||
/// Tells if the chat preview is enabled (can be missing).
|
||||
pub previews_chat: Option<bool>,
|
||||
/// Tells if secure chat is enforced (can be missing).
|
||||
pub enforces_secure_chat: Option<bool>,
|
||||
/// Tell's the server type.
|
||||
pub server_type: Server,
|
||||
}
|
||||
|
||||
/// Java-only additional request settings.
|
||||
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
|
||||
pub struct RequestSettings {
|
||||
/// Some Minecraft servers do not respond as expected if this
|
||||
/// isn't a specific value, `mc.hypixel.net` is an example.
|
||||
pub hostname: String,
|
||||
/// Specifies the client [protocol version number](https://wiki.vg/Protocol_version_numbers),
|
||||
/// `-1` means anything.
|
||||
pub protocol_version: i32,
|
||||
}
|
||||
|
||||
impl Default for RequestSettings {
|
||||
/// `hostname`: "gamedig"
|
||||
/// `protocol_version`: -1
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
hostname: "gamedig".to_string(),
|
||||
protocol_version: -1,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl RequestSettings {
|
||||
/// Make a new *RequestSettings* with just the hostname, the protocol
|
||||
/// version defaults to -1
|
||||
pub fn new_just_hostname(hostname: String) -> Self {
|
||||
Self {
|
||||
hostname,
|
||||
protocol_version: -1,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<ExtraRequestSettings> for RequestSettings {
|
||||
fn from(value: ExtraRequestSettings) -> Self {
|
||||
let default = Self::default();
|
||||
Self {
|
||||
hostname: value.hostname.unwrap_or(default.hostname),
|
||||
protocol_version: value.protocol_version.unwrap_or(default.protocol_version),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl CommonResponse for JavaResponse {
|
||||
fn as_original(&self) -> GenericResponse { GenericResponse::Minecraft(VersionedResponse::Java(self)) }
|
||||
|
||||
fn description(&self) -> Option<&str> { Some(&self.description) }
|
||||
fn players_maximum(&self) -> u32 { self.players_maximum }
|
||||
fn players_online(&self) -> u32 { self.players_online }
|
||||
fn game_version(&self) -> Option<&str> { Some(&self.game_version) }
|
||||
|
||||
fn players(&self) -> Option<Vec<&dyn CommonPlayer>> {
|
||||
self.players
|
||||
.as_ref()
|
||||
.map(|players| players.iter().map(|p| p as &dyn CommonPlayer).collect())
|
||||
}
|
||||
}
|
||||
|
||||
/// A Bedrock Edition query response.
|
||||
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
|
||||
pub struct BedrockResponse {
|
||||
/// Server's edition.
|
||||
pub edition: String,
|
||||
/// Server's name.
|
||||
pub name: String,
|
||||
/// Version name, example: "1.19.40".
|
||||
pub version_name: String,
|
||||
/// Protocol version, example: 760 (for 1.19.2).
|
||||
pub protocol_version: String,
|
||||
/// Maximum number of players the server reports it can hold.
|
||||
pub players_maximum: u32,
|
||||
/// Number of players on the server.
|
||||
pub players_online: u32,
|
||||
/// Server id.
|
||||
pub id: Option<String>,
|
||||
/// Currently running map's name.
|
||||
pub map: Option<String>,
|
||||
/// Current game mode.
|
||||
pub game_mode: Option<GameMode>,
|
||||
/// Tells the server type.
|
||||
pub server_type: Server,
|
||||
}
|
||||
|
||||
impl CommonResponse for BedrockResponse {
|
||||
fn as_original(&self) -> GenericResponse { GenericResponse::Minecraft(VersionedResponse::Bedrock(self)) }
|
||||
|
||||
fn name(&self) -> Option<&str> { Some(&self.name) }
|
||||
fn map(&self) -> Option<&str> { self.map.as_deref() }
|
||||
fn game_version(&self) -> Option<&str> { Some(&self.version_name) }
|
||||
fn players_maximum(&self) -> u32 { self.players_maximum }
|
||||
fn players_online(&self) -> u32 { self.players_online }
|
||||
}
|
||||
|
||||
impl JavaResponse {
|
||||
pub fn from_bedrock_response(response: BedrockResponse) -> Self {
|
||||
Self {
|
||||
game_version: response.version_name,
|
||||
protocol_version: 0,
|
||||
players_maximum: response.players_maximum,
|
||||
players_online: response.players_online,
|
||||
players: None,
|
||||
description: response.name,
|
||||
favicon: None,
|
||||
previews_chat: None,
|
||||
enforces_secure_chat: None,
|
||||
server_type: Server::Bedrock,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A server's game mode (used only by Bedrock servers.
|
||||
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
|
||||
pub enum GameMode {
|
||||
Survival,
|
||||
Creative,
|
||||
Hardcore,
|
||||
Spectator,
|
||||
Adventure,
|
||||
}
|
||||
|
||||
impl GameMode {
|
||||
pub fn from_bedrock(value: &&str) -> GDResult<Self> {
|
||||
match *value {
|
||||
"Survival" => Ok(Self::Survival),
|
||||
"Creative" => Ok(Self::Creative),
|
||||
"Hardcore" => Ok(Self::Hardcore),
|
||||
"Spectator" => Ok(Self::Spectator),
|
||||
"Adventure" => Ok(Self::Adventure),
|
||||
_ => Err(UnknownEnumCast.context(format!("Unknown gamemode {value:?}"))),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn get_varint<B: ByteOrder>(buffer: &mut Buffer<B>) -> GDResult<i32> {
|
||||
let mut result = 0;
|
||||
|
||||
let msb: u8 = 0b1000_0000;
|
||||
let mask: u8 = !msb;
|
||||
|
||||
for i in 0 .. 5 {
|
||||
let current_byte = buffer.read::<u8>()?;
|
||||
|
||||
result |= ((current_byte & mask) as i32) << (7 * i);
|
||||
|
||||
// The 5th byte is only allowed to have the 4 smallest bits set
|
||||
if i == 4 && (current_byte & 0xf0 != 0) {
|
||||
return Err(PacketBad.context("Bad 5th byte"));
|
||||
}
|
||||
|
||||
if (current_byte & msb) == 0 {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
Ok(result)
|
||||
}
|
||||
|
||||
pub(crate) fn as_varint(value: i32) -> Vec<u8> {
|
||||
let mut bytes = vec![];
|
||||
let mut reading_value = value;
|
||||
|
||||
let msb: u8 = 0b1000_0000;
|
||||
let mask: i32 = 0b0111_1111;
|
||||
|
||||
for _ in 0 .. 5 {
|
||||
let tmp = (reading_value & mask) as u8;
|
||||
|
||||
reading_value &= !mask;
|
||||
reading_value = reading_value.rotate_right(7);
|
||||
|
||||
if reading_value == 0 {
|
||||
bytes.push(tmp);
|
||||
break;
|
||||
}
|
||||
|
||||
bytes.push(tmp | msb);
|
||||
}
|
||||
|
||||
bytes
|
||||
}
|
||||
|
||||
pub(crate) fn get_string<B: ByteOrder>(buffer: &mut Buffer<B>) -> GDResult<String> {
|
||||
let length = get_varint(buffer)? as usize;
|
||||
let mut text = Vec::with_capacity(length);
|
||||
|
||||
for _ in 0 .. length {
|
||||
text.push(buffer.read::<u8>()?)
|
||||
}
|
||||
|
||||
String::from_utf8(text).map_err(|e| PacketBad.context(e))
|
||||
}
|
||||
|
||||
pub(crate) fn as_string(value: &str) -> GDResult<Vec<u8>> {
|
||||
let length = value
|
||||
.len()
|
||||
.try_into()
|
||||
.map_err(|e| InvalidInput.context(e))?;
|
||||
let mut buf = as_varint(length);
|
||||
buf.extend(value.as_bytes());
|
||||
|
||||
Ok(buf)
|
||||
}
|
||||
|
||||
#[cfg(tests)]
|
||||
mod tests {
|
||||
#[test]
|
||||
fn test_extra_request_settings() {
|
||||
let settings = ExtraRequestSettings::default();
|
||||
|
||||
let _: minecraft::RequestSettings = settings.clone().into();
|
||||
}
|
||||
}
|
||||
|
|
@ -89,32 +89,6 @@ pub fn query_with_timeout_and_extra_settings(
|
|||
)
|
||||
.map(Box::new)?
|
||||
}
|
||||
Protocol::Minecraft(version) => {
|
||||
match version {
|
||||
Some(protocols::minecraft::Server::Java) => {
|
||||
protocols::minecraft::query_java(
|
||||
&socket_addr,
|
||||
timeout_settings,
|
||||
extra_settings.map(ExtraRequestSettings::into),
|
||||
)
|
||||
.map(Box::new)?
|
||||
}
|
||||
Some(protocols::minecraft::Server::Bedrock) => {
|
||||
protocols::minecraft::query_bedrock(&socket_addr, timeout_settings).map(Box::new)?
|
||||
}
|
||||
Some(protocols::minecraft::Server::Legacy(group)) => {
|
||||
protocols::minecraft::query_legacy_specific(*group, &socket_addr, timeout_settings).map(Box::new)?
|
||||
}
|
||||
None => {
|
||||
protocols::minecraft::query(
|
||||
&socket_addr,
|
||||
timeout_settings,
|
||||
extra_settings.map(ExtraRequestSettings::into),
|
||||
)
|
||||
.map(Box::new)?
|
||||
}
|
||||
}
|
||||
}
|
||||
Protocol::Gamespy(version) => {
|
||||
match version {
|
||||
GameSpyVersion::One => protocols::gamespy::one::query(&socket_addr, timeout_settings).map(Box::new)?,
|
||||
|
|
@ -148,6 +122,33 @@ pub fn query_with_timeout_and_extra_settings(
|
|||
}
|
||||
ProprietaryProtocol::FFOW => ffow::query_with_timeout(address, port, timeout_settings).map(Box::new)?,
|
||||
ProprietaryProtocol::JC2M => jc2m::query_with_timeout(address, port, timeout_settings).map(Box::new)?,
|
||||
ProprietaryProtocol::Minecraft(version) => {
|
||||
match version {
|
||||
Some(minecraft::Server::Java) => {
|
||||
minecraft::protocol::query_java(
|
||||
&socket_addr,
|
||||
timeout_settings,
|
||||
extra_settings.map(ExtraRequestSettings::into),
|
||||
)
|
||||
.map(Box::new)?
|
||||
}
|
||||
Some(minecraft::Server::Bedrock) => {
|
||||
minecraft::protocol::query_bedrock(&socket_addr, timeout_settings).map(Box::new)?
|
||||
}
|
||||
Some(minecraft::Server::Legacy(group)) => {
|
||||
minecraft::protocol::query_legacy_specific(*group, &socket_addr, timeout_settings)
|
||||
.map(Box::new)?
|
||||
}
|
||||
None => {
|
||||
minecraft::protocol::query(
|
||||
&socket_addr,
|
||||
timeout_settings,
|
||||
extra_settings.map(ExtraRequestSettings::into),
|
||||
)
|
||||
.map(Box::new)?
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
})
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue