tribufu/rust-gamedig
1
0
Fork 0
mirror of https://github.com/tribufu/rust-gamedig synced 2026-05-06 15:27:28 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Change buffer reading implementation (#8)

Browse source 
* Add new implementation an valve protocol refactor

* Refactor minecraft protocol with new bufferer
This commit is contained in:
CosminPerRam 2022-12-29 16:30:24 +02:00 • committed by GitHub
parent 91f8bbb9fe
commit b09fa4ada5
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
10 changed files with 455 additions and 353 deletions
Download patch file Download diff file Expand all files Collapse all files

22
src/protocols/minecraft/protocol/bedrock.rs
View file

@ -5,10 +5,10 @@ https://github.com/gamedig/node-gamedig/blob/master/protocols/minecraftbedrock.j
*/
use crate::{GDError, GDResult};
use crate::bufferer::{Bufferer, Endianess};
use crate::protocols::minecraft::{BedrockResponse, GameMode, Server};
use crate::protocols::types::TimeoutSettings;
use crate::socket::{Socket, UdpSocket};
use crate::utils::buffer::{get_string_utf8_le_unended, get_u16_be, get_u64_le, get_u8};
use crate::utils::error_by_expected_size;
pub struct Bedrock {
@ -42,34 +42,34 @@ impl Bedrock {
fn get_info(&mut self) -> GDResult<BedrockResponse> {
self.send_status_request()?;
let buf = self.socket.receive(None)?;
let mut pos = 0;
let mut buffer = Bufferer::new_with_data(Endianess::Little, &self.socket.receive(None)?);
if get_u8(&buf, &mut pos)? != 0x1c {
if buffer.get_u8()? != 0x1c {
return Err(GDError::PacketBad("Invalid message id.".to_string()));
}
// Checking for our nonce directly from a u64 (as the nonce is 8 bytes).
if get_u64_le(&buf, &mut pos)? != 9833440827789222417 {
if buffer.get_u64()? != 9833440827789222417 {
return Err(GDError::PacketBad("Invalid nonce.".to_string()));
}
// These 8 bytes are identical to the serverId string we receive in decimal below
pos += 8;
buffer.move_position_ahead(8);
// Verifying the magic value (as we need 16 bytes, cast to two u64 values)
if get_u64_le(&buf, &mut pos)? != 18374403896610127616 {
if buffer.get_u64()? != 18374403896610127616 {
return Err(GDError::PacketBad("Invalid magic (part 1).".to_string()));
}
if get_u64_le(&buf, &mut pos)? != 8671175388723805693 {
if buffer.get_u64()? != 8671175388723805693 {
return Err(GDError::PacketBad("Invalid magic (part 2).".to_string()));
}
let remaining_length = get_u16_be(&buf, &mut pos)? as usize;
error_by_expected_size(remaining_length, buf.len() - pos)?;
let remaining_length = buffer.as_endianess(Endianess::Big).get_u16()? as usize;
buffer.move_position_ahead(2);
error_by_expected_size(remaining_length, buffer.remaining_length())?;
let binding = get_string_utf8_le_unended(&buf, &mut pos)?;
let binding = buffer.get_string_utf8_unended()?;
let status: Vec<&str> = binding.split(";").collect();
// We must have at least 6 values

17
src/protocols/minecraft/protocol/java.rs
View file

@ -1,5 +1,6 @@
use serde_json::Value;
use crate::{GDError, GDResult};
use crate::bufferer::{Bufferer, Endianess};
use crate::protocols::minecraft::{as_varint, get_string, get_varint, Player, Response, Server};
use crate::protocols::types::TimeoutSettings;
use crate::socket::{Socket, TcpSocket};
@ -22,14 +23,13 @@ impl Java {
self.socket.send(&[as_varint(data.len() as i32), data].concat())
}
fn receive(&mut self) -> GDResult<Vec<u8>> {
let buf = self.socket.receive(None)?;
let mut pos = 0;
fn receive(&mut self) -> GDResult<Bufferer> {
let mut buffer = Bufferer::new_with_data(Endianess::Little, &self.socket.receive(None)?);
let _packet_length = get_varint(&buf, &mut pos)? as usize;
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(buf[pos..].to_vec())
Ok(buffer)
}
fn send_handshake(&mut self) -> GDResult<()> {
@ -69,14 +69,13 @@ impl Java {
self.send_status_request()?;
self.send_ping_request()?;
let buf = self.receive()?;
let mut pos = 0;
let mut buffer = self.receive()?;
if get_varint(&buf, &mut pos)? != 0 { //first var int is the packet id
if get_varint(&mut buffer)? != 0 { //first var int is the packet id
return Err(GDError::PacketBad("Bad receive packet id.".to_string()));
}
let json_response = get_string(&buf, &mut pos)?;
let json_response = get_string(&mut buffer)?;
let value_response: Value = serde_json::from_str(&json_response)
.map_err(|e| GDError::JsonParse(e.to_string()))?;

13
src/protocols/minecraft/protocol/legacy_bv1_8.rs
View file

@ -1,9 +1,9 @@
use crate::{GDError, GDResult};
use crate::bufferer::{Bufferer, Endianess};
use crate::protocols::minecraft::{LegacyGroup, Response, Server};
use crate::protocols::types::TimeoutSettings;
use crate::socket::{Socket, TcpSocket};
use crate::utils::buffer::{get_string_utf16_be, get_u16_be, get_u8};
use crate::utils::error_by_expected_size;
pub struct LegacyBV1_8 {
@ -27,17 +27,16 @@ impl LegacyBV1_8 {
fn get_info(&mut self) -> GDResult<Response> {
self.send_initial_request()?;
let buf = self.socket.receive(None)?;
let mut pos = 0;
let mut buffer = Bufferer::new_with_data(Endianess::Big, &self.socket.receive(None)?);
if get_u8(&buf, &mut pos)? != 0xFF {
if buffer.get_u8()? != 0xFF {
return Err(GDError::ProtocolFormat("Expected 0xFF at the begin of the packet.".to_string()));
}
let length = get_u16_be(&buf, &mut pos)? * 2;
error_by_expected_size((length + 3) as usize, buf.len())?;
let length = buffer.get_u16()? * 2;
error_by_expected_size((length + 3) as usize, buffer.data_length())?;
let packet_string = get_string_utf16_be(&buf, &mut pos)?;
let packet_string = buffer.get_string_utf16()?;
let split: Vec<&str> = packet_string.split("§").collect();
error_by_expected_size(3, split.len())?;

17
src/protocols/minecraft/protocol/legacy_v1_4.rs
View file

@ -1,10 +1,10 @@
use crate::{GDError, GDResult};
use crate::bufferer::{Bufferer, Endianess};
use crate::protocols::minecraft::{LegacyGroup, Response, Server};
use crate::protocols::minecraft::protocol::legacy_v1_6::LegacyV1_6;
use crate::protocols::types::TimeoutSettings;
use crate::socket::{Socket, TcpSocket};
use crate::utils::buffer::{get_string_utf16_be, get_u16_be, get_u8};
use crate::utils::error_by_expected_size;
pub struct LegacyV1_4 {
@ -28,21 +28,20 @@ impl LegacyV1_4 {
fn get_info(&mut self) -> GDResult<Response> {
self.send_initial_request()?;
let buf = self.socket.receive(None)?;
let mut pos = 0;
let mut buffer = Bufferer::new_with_data(Endianess::Big, &self.socket.receive(None)?);
if get_u8(&buf, &mut pos)? != 0xFF {
if buffer.get_u8()? != 0xFF {
return Err(GDError::ProtocolFormat("Expected 0xFF at the begin of the packet.".to_string()));
}
let length = get_u16_be(&buf, &mut pos)? * 2;
error_by_expected_size((length + 3) as usize, buf.len())?;
let length = buffer.get_u16()? * 2;
error_by_expected_size((length + 3) as usize, buffer.data_length())?;
if LegacyV1_6::is_protocol(&buf, &mut pos)? {
return LegacyV1_6::get_response(&buf, &mut pos);
if LegacyV1_6::is_protocol(&mut buffer)? {
return LegacyV1_6::get_response(&mut buffer);
}
let packet_string = get_string_utf16_be(&buf, &mut pos)?;
let packet_string = buffer.get_string_utf16()?;
let split: Vec<&str> = packet_string.split("§").collect();
error_by_expected_size(3, split.len())?;

25
src/protocols/minecraft/protocol/legacy_v1_6.rs
View file

@ -1,8 +1,8 @@
use crate::{GDError, GDResult};
use crate::bufferer::{Bufferer, Endianess};
use crate::protocols::minecraft::{LegacyGroup, Response, Server};
use crate::protocols::types::TimeoutSettings;
use crate::socket::{Socket, TcpSocket};
use crate::utils::buffer::{get_string_utf16_be, get_u16_be, get_u8};
use crate::utils::error_by_expected_size;
pub struct LegacyV1_6 {
@ -35,18 +35,18 @@ impl LegacyV1_6 {
Ok(())
}
pub fn is_protocol(buf: &[u8], pos: &mut usize) -> GDResult<bool> {
let state = buf[*pos..].starts_with(&[0x00, 0xA7, 0x00, 0x31, 0x00, 0x00]);
pub fn is_protocol(buffer: &mut Bufferer) -> GDResult<bool> {
let state = buffer.remaining_data().starts_with(&[0x00, 0xA7, 0x00, 0x31, 0x00, 0x00]);
if state {
*pos += 6;
buffer.move_position_ahead(6);
}
Ok(state)
}
pub fn get_response(buf: &[u8], pos: &mut usize) -> GDResult<Response> {
let packet_string = get_string_utf16_be(&buf, pos)?;
pub fn get_response(buffer: &mut Bufferer) -> GDResult<Response> {
let packet_string = buffer.get_string_utf16()?;
let split: Vec<&str> = packet_string.split("\x00").collect();
error_by_expected_size(5, split.len())?;
@ -77,21 +77,20 @@ impl LegacyV1_6 {
fn get_info(&mut self) -> GDResult<Response> {
self.send_initial_request()?;
let buf = self.socket.receive(None)?;
let mut pos = 0;
let mut buffer = Bufferer::new_with_data(Endianess::Big, &self.socket.receive(None)?);
if get_u8(&buf, &mut pos)? != 0xFF {
if buffer.get_u8()? != 0xFF {
return Err(GDError::ProtocolFormat("Expected a certain byte (0xFF) at the begin of the packet.".to_string()));
}
let length = get_u16_be(&buf, &mut pos)? * 2;
error_by_expected_size((length + 3) as usize, buf.len())?;
let length = buffer.get_u16()? * 2;
error_by_expected_size((length + 3) as usize, buffer.data_length())?;
if !LegacyV1_6::is_protocol(&buf, &mut pos)? {
if !LegacyV1_6::is_protocol(&mut buffer)? {
return Err(GDError::ProtocolFormat("Expected certain bytes at the beginning of the packet.".to_string()));
}
LegacyV1_6::get_response(&buf, &mut pos)
LegacyV1_6::get_response(&mut buffer)
}
pub fn query(address: &str, port: u16, timeout_settings: Option<TimeoutSettings>) -> GDResult<Response> {

12
src/protocols/minecraft/types.rs
View file

@ -6,7 +6,7 @@ https://github.com/thisjaiden/golden_apple/blob/master/src/lib.rs
*/
use crate::{GDError, GDResult};
use crate::utils::buffer::get_u8;
use crate::bufferer::Bufferer;
/// The type of Minecraft Server you want to query.
#[derive(Debug)]
@ -123,14 +123,14 @@ impl GameMode {
}
}
pub fn get_varint(buf: &[u8], pos: &mut usize) -> GDResult<i32> {
pub fn get_varint(buffer: &mut Bufferer) -> GDResult<i32> {
let mut result = 0;
let msb: u8 = 0b10000000;
let mask: u8 = !msb;
for i in 0..5 {
let current_byte = get_u8(buf, pos)?;
let current_byte = buffer.get_u8()?;
result |= ((current_byte & mask) as i32) << (7 * i);
@ -171,12 +171,12 @@ pub fn as_varint(value: i32) -> Vec<u8> {
bytes
}
pub fn get_string(buf: &[u8], pos: &mut usize) -> GDResult<String> {
let length = get_varint(buf, pos)? as usize;
pub fn get_string(buffer: &mut Bufferer) -> GDResult<String> {
let length = get_varint(buffer)? as usize;
let mut text = vec![0; length];
for i in 0..length {
text[i] = get_u8(buf, pos)?;
text[i] = buffer.get_u8()?;
}
Ok(String::from_utf8(text)