From 8058a05876d84a79c282e6b9855feef10be03b03 Mon Sep 17 00:00:00 2001 From: MeexReay Date: Thu, 23 May 2024 19:15:38 +0300 Subject: [PATCH] fix compression mb --- Cargo.toml | 4 +- examples/status_server.rs | 29 +++++- examples/test_compression.rs | 38 ++++++++ src/lib.rs | 182 ++++++++++------------------------- 4 files changed, 119 insertions(+), 134 deletions(-) create mode 100644 examples/test_compression.rs diff --git a/Cargo.toml b/Cargo.toml index f09be0b..07d9999 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -7,10 +7,10 @@ license-file = "LICENSE" readme = "README.md" keywords = ["minecraft", "protocol", "packets", "lightweight"] -version = "0.1.6" +version = "0.1.7" edition = "2021" [dependencies] -flate2 = "1.0.30" +flate2 = { version = "1.0.30", features = ["zlib"]} bytebuffer = "2.2.0" uuid = "1.8.0" \ No newline at end of file diff --git a/examples/status_server.rs b/examples/status_server.rs index 52ec436..1101ed3 100644 --- a/examples/status_server.rs +++ b/examples/status_server.rs @@ -36,7 +36,9 @@ fn accept_client(mut conn: MCConnTcp, server: Arc>) -> Re loop { let mut packet = match conn.read_packet() { Ok(i) => i, - Err(_) => { break; }, + Err(_) => { + break; + }, }; if handshake { @@ -76,10 +78,31 @@ fn accept_client(mut conn: MCConnTcp, server: Arc>) -> Re fn main() { let server = MinecraftServer::new( - "localhost", + "127.0.0.1", 25565, 765, - "{\"version\":{\"protocol\":765,\"name\":\"Куриный ништяк\"},\"players\":{\"online\":0,\"max\":1},\"description\":{\"extra\":[{\"extra\":[{\"color\":\"aqua\",\"text\":\"☄\"},\" \",{\"bold\":true,\"extra\":[{\"color\":\"#00D982\",\"text\":\"S\"},{\"color\":\"#0DCB8B\",\"text\":\"l\"},{\"color\":\"#1BBC93\",\"text\":\"o\"},{\"color\":\"#28AE9C\",\"text\":\"g\"},{\"color\":\"#35A0A5\",\"text\":\"a\"},{\"color\":\"#4392AE\",\"text\":\"n\"},{\"color\":\"#5083B6\",\"text\":\"M\"},{\"color\":\"#5D75BF\",\"text\":\"C\"},{\"color\":\"#6A67C8\",\"text\":\".\"},{\"color\":\"#7858D0\",\"text\":\"r\"},{\"color\":\"#854AD9\",\"text\":\"u\"}],\"text\":\"\"},\" \",{\"color\":\"aqua\",\"text\":\"☄\"},\" \"],\"text\":\"\"},\"\\n\",{\"extra\":[{\"extra\":[{\"bold\":true,\"color\":\"#A1999E\",\"text\":\"░\"},\" \",{\"color\":\"#D1C7CD\",\"text\":\"прикол\"},\" \",{\"bold\":true,\"color\":\"#A1999E\",\"text\":\"░\"}],\"text\":\"\"}],\"text\":\" \"}],\"text\":\" \"},\"favicon\":\"data:image/png;base64,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\\u003d\"}" + "{ + \"version\":{ + \"protocol\":765, + \"name\":\"Version name\" + }, + \"players\":{ + \"online\":0, + \"max\":1, + \"sample\":[ + { + \"uuid\": \"\", + \"name\": \"Notch\" + } + ] + }, + \"description\": { + \"text\": \"Hello World!\", + \"color\": \"red\", + \"bold\": true + }, + \"favicon\": \"data:image/png;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=\" + }" ); let addr = server.server_ip.clone() + ":" + &server.server_port.to_string(); diff --git a/examples/test_compression.rs b/examples/test_compression.rs new file mode 100644 index 0000000..c85654b --- /dev/null +++ b/examples/test_compression.rs @@ -0,0 +1,38 @@ +use std::{net::TcpListener, sync::{atomic::AtomicBool, atomic::Ordering}, thread}; +use std::sync::mpsc::channel; +use rust_mc_proto::{DataBufferReader, DataBufferWriter, MCConn, MCConnTcp, MinecraftConnection, Packet, ProtocolError}; + +const LONG_TEXT: &str = "some_long_text_wow_123123123123123123123123"; + +fn main() { + let (tx, rx) = channel::<()>(); + + let server_tx = tx.clone(); + thread::spawn(move || { + let listener = TcpListener::bind("localhost:44447").unwrap(); + + server_tx.send(()).unwrap(); + + for stream in listener.incoming() { + let mut stream = MCConnTcp::new(stream.unwrap()); + stream.set_compression(2); + + let packet = stream.read_packet().unwrap(); + stream.write_packet(&packet).unwrap(); + } + }); + + rx.recv().unwrap(); + + let mut conn = MCConnTcp::connect("localhost:44447").unwrap(); + conn.set_compression(2); + + let mut packet = Packet::empty(0x12); + packet.write_string(LONG_TEXT).unwrap(); + conn.write_packet(&packet).unwrap(); + + let mut packet = conn.read_packet().unwrap(); + if packet.id == 0x12 && packet.read_string().unwrap() == LONG_TEXT { + println!("success"); + } +} diff --git a/src/lib.rs b/src/lib.rs index c89c48f..636b28a 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,7 +1,8 @@ use std::io::{Write, Read}; use std::net::{TcpStream, ToSocketAddrs}; -use flate2::bufread::ZlibDecoder; +use flate2::read::ZlibDecoder; +use flate2::write::ZlibEncoder; use flate2::{Compress, Compression, Decompress, FlushCompress, Status, FlushDecompress}; use bytebuffer::ByteBuffer; use uuid::Uuid; @@ -116,6 +117,15 @@ macro_rules! write_varint { }; } +macro_rules! return_error { + ($ex: expr, $error: expr) => { + match $ex { + Ok(i) => i, + Err(_) => { return Err($error) }, + } + }; +} + pub trait DataBufferReader { fn read_bytes(&mut self, size: usize) -> Result, ProtocolError>; fn read_byte(&mut self) -> Result; @@ -265,14 +275,8 @@ pub trait DataBufferWriter { impl DataBufferReader for R { fn read_bytes(&mut self, size: usize) -> Result, ProtocolError> { let mut buf = vec![0; size]; - match self.read(&mut buf) { - Ok(i) => { - if i < size { - Err(ProtocolError::ReadError) - } else { - Ok(buf) - } - }, + match self.read_exact(&mut buf) { + Ok(_) => Ok(buf), Err(_) => Err(ProtocolError::ReadError), } } @@ -391,14 +395,8 @@ impl MinecraftConnection { impl DataBufferReader for MinecraftConnection { fn read_bytes(&mut self, size: usize) -> Result, ProtocolError> { let mut buf = vec![0; size]; - match self.stream.read(&mut buf) { - Ok(i) => { - if i < size { - Err(ProtocolError::ReadError) - } else { - Ok(buf) - } - }, + match self.stream.read_exact(&mut buf) { + Ok(_) => Ok(buf), Err(_) => Err(ProtocolError::ReadError), } } @@ -436,155 +434,81 @@ impl MinecraftConnection { self.compress = true; self.compress_threashold = threashold; } + pub fn read_packet(&mut self) -> Result { if !self.compress { let length = self.read_usize_varint()?; let packet_id = self.read_u8_varint()?; - let mut data: Vec = vec![0; length - 1]; - match self.stream.read_exact(&mut data) { - Ok(i) => i, - Err(_) => { return Err(ProtocolError::ReadError) }, - }; + let data = self.read_bytes(length - 1)?; return Ok(Packet::from_bytes(packet_id, &data)) } - let packet_length = self.read_usize_varint_size()?; - let data_length = self.read_usize_varint_size()?; - if data_length.0 == 0 { + let packet_length = self.read_usize_varint()?; + let data_length = self.read_usize_varint()?; + + if data_length == 0 { let packet_id = self.read_u8_varint()?; - let mut data: Vec = vec![0; packet_length.0 - 2]; - match self.stream.read_exact(&mut data) { - Ok(i) => i, - Err(_) => { return Err(ProtocolError::ReadError) }, - }; + let data = self.read_bytes(packet_length - 2)?; return Ok(Packet::from_bytes(packet_id, &data)) } - let mut data: Vec = vec![0; packet_length.0 - packet_length.1 - data_length.1]; - match self.stream.read_exact(&mut data) { - Ok(i) => i, - Err(_) => { return Err(ProtocolError::ReadError) }, - }; + let data = self.read_bytes(packet_length - 2)?; + let mut data_buf = ByteBuffer::from_vec(decompress_zlib(&data, packet_length)?); - let mut data_buf = ByteBuffer::from_vec(decompress_zlib(&data, packet_length.0 - packet_length.1 - data_length.1)?); + let packet_id = return_error!(data_buf.read_u8_varint(), ProtocolError::VarIntError); + let mut packet_data = vec![0; data_length - 1]; + return_error!(data_buf.read_exact(&mut packet_data), ProtocolError::ReadError); - let packet_id = match data_buf.read_u8_varint() { - Ok(i) => i, - Err(_) => { return Err(ProtocolError::VarIntError) }, - }; - let mut data: Vec = vec![0; packet_length.0 - packet_length.1 - data_length.1 - 1]; - match data_buf.read_exact(&mut data) { - Ok(i) => i, - Err(_) => { return Err(ProtocolError::ReadError) }, - }; - - Ok(Packet::from_bytes(packet_id, &data)) + Ok(Packet::from_bytes(packet_id, &packet_data)) } - pub fn write_packet(&mut self, packet: &Packet) -> Result<(), ProtocolError> { + pub fn write_packet(&mut self, pack: &Packet) -> Result<(), ProtocolError> { let mut buf = ByteBuffer::new(); if !self.compress { - match buf.write_usize_varint(packet.buffer.len() + 1) { - Ok(_) => {}, - Err(_) => { return Err(ProtocolError::WriteError) }, - }; - match buf.write_u8_varint(packet.id) { - Ok(_) => {}, - Err(_) => { return Err(ProtocolError::WriteError) }, - }; - match buf.write_all(packet.buffer.as_bytes()) { - Ok(_) => {}, - Err(_) => { return Err(ProtocolError::WriteError) }, - }; + return_error!(buf.write_usize_varint(pack.buffer.len() + 1), ProtocolError::WriteError); + return_error!(buf.write_u8_varint(pack.id), ProtocolError::WriteError); + return_error!(buf.write_all(pack.buffer.as_bytes()), ProtocolError::WriteError); } else { - let mut pack = ByteBuffer::new(); + let mut packet = ByteBuffer::new(); - if packet.buffer.len() < self.compress_threashold { - match pack.write_usize_varint(0) { - Ok(_) => {}, - Err(_) => { return Err(ProtocolError::WriteError) }, - }; - match pack.write_u8_varint(packet.id) { - Ok(_) => {}, - Err(_) => { return Err(ProtocolError::WriteError) }, - }; - match pack.write_all(packet.buffer.as_bytes()) { - Ok(_) => {}, - Err(_) => { return Err(ProtocolError::WriteError) }, - }; + let mut data = ByteBuffer::new(); + return_error!(data.write_u8_varint(pack.id), ProtocolError::WriteError); + return_error!(data.write_all(pack.buffer.as_bytes()), ProtocolError::WriteError); + + if pack.buffer.len() < self.compress_threashold { + return_error!(packet.write_usize_varint(0), ProtocolError::WriteError); // data length + return_error!(packet.write_all(data.as_bytes()), ProtocolError::WriteError); } else { - let mut data = ByteBuffer::new(); - - match data.write_u8_varint(packet.id) { - Ok(_) => {}, - Err(_) => { return Err(ProtocolError::WriteError) }, - }; - match data.write_all(packet.buffer.as_bytes()) { - Ok(_) => {}, - Err(_) => { return Err(ProtocolError::WriteError) }, - }; - - let data = compress_zlib(data.as_bytes())?; - - match pack.write_usize_varint(packet.buffer.len() + 1) { - Ok(_) => {}, - Err(_) => { return Err(ProtocolError::WriteError) }, - }; - match pack.write_all(&data) { - Ok(_) => {}, - Err(_) => { return Err(ProtocolError::WriteError) }, - }; + return_error!(packet.write_usize_varint(data.len()), ProtocolError::WriteError); // data length + return_error!(packet.write_all(&compress_zlib(data.as_bytes())?), ProtocolError::WriteError); } - match buf.write_usize_varint(pack.len()) { - Ok(_) => {}, - Err(_) => { return Err(ProtocolError::WriteError) }, - }; - match buf.write_all(pack.as_bytes()) { - Ok(_) => {}, - Err(_) => { return Err(ProtocolError::WriteError) }, - }; + return_error!(buf.write_usize_varint(packet.len()), ProtocolError::WriteError); // packet length + return_error!(buf.write_all(packet.as_bytes()), ProtocolError::WriteError); } - match self.stream.write_all(buf.as_bytes()) { - Ok(_) => {}, - Err(_) => { return Err(ProtocolError::WriteError) }, - }; + return_error!(self.write_bytes(buf.as_bytes()), ProtocolError::WriteError); Ok(()) } } fn compress_zlib(bytes: &[u8]) -> Result, ProtocolError> { - let mut compresser = Compress::new(Compression::best(), true); - let mut output: Vec = Vec::new(); - match compresser.compress_vec(&bytes, &mut output, FlushCompress::Finish) { - Ok(i) => { - match i { - Status::Ok => Ok(output), - _ => Err(ProtocolError::ZlibError), - } - }, - Err(_) => Err(ProtocolError::ZlibError) - } + let mut encoder = ZlibEncoder::new(Vec::new(), Compression::fast()); + return_error!(encoder.write_all(bytes), ProtocolError::ZlibError); + let output = return_error!(encoder.finish(), ProtocolError::ZlibError); + Ok(output) } fn decompress_zlib(bytes: &[u8], packet_length: usize) -> Result, ProtocolError> { - let mut compresser = Decompress::new(true); - let mut output: Vec = Vec::with_capacity(packet_length); - match compresser.decompress_vec(&bytes, &mut output, FlushDecompress::Sync) { - Ok(i) => { - match i { - Status::Ok => Ok(output), - _ => Err(ProtocolError::ZlibError), - } - }, - Err(_) => Err(ProtocolError::ZlibError) - } + let mut decoder = ZlibDecoder::new(bytes); + let mut output = Vec::new(); + return_error!(decoder.read_to_end(&mut output), ProtocolError::ZlibError); + Ok(output) }